code.ossystems Code Review - meta-freescale.git/blob

   1 From 34e765977633b5f81845c0183af6d388d8225f00 Mon Sep 17 00:00:00 2001
   2 From: Cristian Stoica <cristian.stoica@freescale.com>
   3 Date: Mon, 23 Feb 2015 12:14:07 +0200
   4 Subject: [PATCH 14/15] remove redundant data copy for pkc operations
   5
   6 This patch removes a copy of a pkc request that was
   7 allocated on the hot-path. The copy was not necessary
   8 and was just slowing things down.
   9
  10 Change-Id: I3ad85f78c188f100ab9fc03a5777bb704a9dcb63
  11 Signed-off-by: Cristian Stoica <cristian.stoica@freescale.com>
  12 Reviewed-on: http://git.am.freescale.net:8181/34223
  13 ---
  14  cryptlib.c |  49 +++----------------
  15  cryptlib.h |   3 +-
  16  ioctl.c    |  17 +++----
  17  main.c     | 162 +++++++++++++++++++++++++++++++++++++------------------------
  18  4 files changed, 113 insertions(+), 118 deletions(-)
  19
  20 diff --git a/cryptlib.c b/cryptlib.c
  21 index 21e691b..5882a30 100644
  22 --- a/cryptlib.c
  23 +++ b/cryptlib.c
  24 @@ -436,59 +436,22 @@ int cryptodev_hash_final(struct hash_data *hdata, void *output)
  25
  26  int cryptodev_pkc_offload(struct cryptodev_pkc *pkc)
  27  {
  28 -       int ret = 0;
  29 -       struct pkc_request *pkc_req = &pkc->req, *pkc_requested;
  30 -
  31 -       switch (pkc_req->type) {
  32 -       case RSA_KEYGEN:
  33 -       case RSA_PUB:
  34 -       case RSA_PRIV_FORM1:
  35 -       case RSA_PRIV_FORM2:
  36 -       case RSA_PRIV_FORM3:
  37 -               pkc->s = crypto_alloc_pkc("pkc(rsa)", CRYPTO_ALG_TYPE_PKC_RSA, 0);
  38 -               break;
  39 -       case DSA_SIGN:
  40 -       case DSA_VERIFY:
  41 -       case ECDSA_SIGN:
  42 -       case ECDSA_VERIFY:
  43 -       case DLC_KEYGEN:
  44 -       case ECC_KEYGEN:
  45 -               pkc->s = crypto_alloc_pkc("pkc(dsa)", CRYPTO_ALG_TYPE_PKC_DSA, 0);
  46 -               break;
  47 -       case DH_COMPUTE_KEY:
  48 -       case ECDH_COMPUTE_KEY:
  49 -               pkc->s = crypto_alloc_pkc("pkc(dh)", CRYPTO_ALG_TYPE_PKC_DH, 0);
  50 -               break;
  51 -       default:
  52 -               return -EINVAL;
  53 -       }
  54 -
  55 -       if (IS_ERR_OR_NULL(pkc->s))
  56 -               return -EINVAL;
  57 +       int ret;
  58
  59         init_completion(&pkc->result.completion);
  60 -       pkc_requested = pkc_request_alloc(pkc->s, GFP_KERNEL);
  61 -
  62 -       if (unlikely(IS_ERR_OR_NULL(pkc_requested))) {
  63 -               ret = -ENOMEM;
  64 -               goto error;
  65 -       }
  66 -       pkc_requested->type = pkc_req->type;
  67 -       pkc_requested->curve_type = pkc_req->curve_type;
  68 -       memcpy(&pkc_requested->req_u, &pkc_req->req_u, sizeof(pkc_req->req_u));
  69 -       pkc_request_set_callback(pkc_requested, CRYPTO_TFM_REQ_MAY_BACKLOG,
  70 +       pkc_request_set_callback(pkc->req, CRYPTO_TFM_REQ_MAY_BACKLOG,
  71                                  cryptodev_complete_asym, pkc);
  72 -       ret = crypto_pkc_op(pkc_requested);
  73 +       ret = crypto_pkc_op(pkc->req);
  74         if (ret != -EINPROGRESS && ret != 0)
  75 -               goto error2;
  76 +               goto error;
  77
  78         if (pkc->type == SYNCHRONOUS)
  79                 ret = waitfor(&pkc->result, ret);
  80
  81         return ret;
  82 -error2:
  83 -       kfree(pkc_requested);
  84 +
  85  error:
  86 +       kfree(pkc->req);
  87         crypto_free_pkc(pkc->s);
  88         return ret;
  89  }
  90 diff --git a/cryptlib.h b/cryptlib.h
  91 index 7ffa54c..4fac0c8 100644
  92 --- a/cryptlib.h
  93 +++ b/cryptlib.h
  94 @@ -110,8 +110,7 @@ struct cryptodev_pkc {
  95         struct crypto_pkc *s;    /* Transform pointer from CryptoAPI */
  96         struct cryptodev_result result; /* Result to be updated by
  97                                          completion handler */
  98 -       struct pkc_request req; /* PKC request structure allocated
  99 -                                from CryptoAPI */
 100 +       struct pkc_request *req; /* PKC request allocated from CryptoAPI */
 101         enum offload_type type; /* Synchronous Vs Asynchronous request */
 102         /*
 103          * cookie used for transfering tranparent information from async
 104 diff --git a/ioctl.c b/ioctl.c
 105 index ee0486c..797b73c 100644
 106 --- a/ioctl.c
 107 +++ b/ioctl.c
 108 @@ -708,26 +708,25 @@ static int crypto_async_fetch_asym(struct cryptodev_pkc *pkc)
 109         int ret = 0;
 110         struct kernel_crypt_kop *kop = &pkc->kop;
 111         struct crypt_kop *ckop = &kop->kop;
 112 -       struct pkc_request *pkc_req = &pkc->req;
 113
 114         switch (ckop->crk_op) {
 115         case CRK_MOD_EXP:
 116         {
 117 -               struct rsa_pub_req_s *rsa_req = &pkc_req->req_u.rsa_pub_req;
 118 +               struct rsa_pub_req_s *rsa_req = &pkc->req->req_u.rsa_pub_req;
 119                 copy_to_user(ckop->crk_param[3].crp_p, rsa_req->g, rsa_req->g_len);
 120         }
 121         break;
 122         case CRK_MOD_EXP_CRT:
 123         {
 124 -               struct rsa_priv_frm3_req_s *rsa_req = &pkc_req->req_u.rsa_priv_f3;
 125 +               struct rsa_priv_frm3_req_s *rsa_req = &pkc->req->req_u.rsa_priv_f3;
 126                 copy_to_user(ckop->crk_param[6].crp_p, rsa_req->f, rsa_req->f_len);
 127         }
 128         break;
 129         case CRK_DSA_SIGN:
 130         {
 131 -               struct dsa_sign_req_s *dsa_req = &pkc_req->req_u.dsa_sign;
 132 +               struct dsa_sign_req_s *dsa_req = &pkc->req->req_u.dsa_sign;
 133
 134 -               if (pkc_req->type == ECDSA_SIGN) {
 135 +               if (pkc->req->type == ECDSA_SIGN) {
 136                         copy_to_user(ckop->crk_param[6].crp_p, dsa_req->c, dsa_req->d_len);
 137                         copy_to_user(ckop->crk_param[7].crp_p, dsa_req->d, dsa_req->d_len);
 138                 } else {
 139 @@ -740,8 +739,8 @@ static int crypto_async_fetch_asym(struct cryptodev_pkc *pkc)
 140                 break;
 141         case CRK_DH_COMPUTE_KEY:
 142         {
 143 -               struct dh_key_req_s *dh_req = &pkc_req->req_u.dh_req;
 144 -               if (pkc_req->type == ECDH_COMPUTE_KEY)
 145 +               struct dh_key_req_s *dh_req = &pkc->req->req_u.dh_req;
 146 +               if (pkc->req->type == ECDH_COMPUTE_KEY)
 147                         copy_to_user(ckop->crk_param[4].crp_p, dh_req->z, dh_req->z_len);
 148                 else
 149                         copy_to_user(ckop->crk_param[3].crp_p, dh_req->z, dh_req->z_len);
 150 @@ -750,9 +749,9 @@ static int crypto_async_fetch_asym(struct cryptodev_pkc *pkc)
 151         case CRK_DSA_GENERATE_KEY:
 152         case CRK_DH_GENERATE_KEY:
 153         {
 154 -               struct keygen_req_s *key_req = &pkc_req->req_u.keygen;
 155 +               struct keygen_req_s *key_req = &pkc->req->req_u.keygen;
 156
 157 -               if (pkc_req->type == ECC_KEYGEN) {
 158 +               if (pkc->req->type == ECC_KEYGEN) {
 159                         copy_to_user(ckop->crk_param[4].crp_p, key_req->pub_key,
 160                                         key_req->pub_key_len);
 161                         copy_to_user(ckop->crk_param[5].crp_p, key_req->priv_key,
 162 diff --git a/main.c b/main.c
 163 index af66553..ed1c69a 100644
 164 --- a/main.c
 165 +++ b/main.c
 166 @@ -186,8 +186,7 @@ int crypto_kop_dsasign(struct cryptodev_pkc *pkc)
 167  {
 168         struct kernel_crypt_kop *kop = &pkc->kop;
 169         struct crypt_kop *cop = &kop->kop;
 170 -       struct pkc_request *pkc_req = &pkc->req;
 171 -       struct dsa_sign_req_s *dsa_req = &pkc_req->req_u.dsa_sign;
 172 +       struct dsa_sign_req_s *dsa_req = &pkc->req->req_u.dsa_sign;
 173         int rc, buf_size;
 174         uint8_t *buf;
 175
 176 @@ -210,10 +209,7 @@ int crypto_kop_dsasign(struct cryptodev_pkc *pkc)
 177         if (cop->crk_iparams == 6) {
 178                 dsa_req->ab_len = (cop->crk_param[5].crp_nbits + 7)/8;
 179                 buf_size += dsa_req->ab_len;
 180 -               pkc_req->type = ECDSA_SIGN;
 181 -               pkc_req->curve_type = cop->curve_type;
 182 -       } else {
 183 -               pkc_req->type = DSA_SIGN;
 184 +               pkc->req->curve_type = cop->curve_type;
 185         }
 186
 187         buf = kmalloc(buf_size, GFP_DMA);
 188 @@ -269,7 +265,6 @@ int crypto_kop_dsaverify(struct cryptodev_pkc *pkc)
 189  {
 190         struct kernel_crypt_kop *kop = &pkc->kop;
 191         struct crypt_kop *cop = &kop->kop;
 192 -       struct pkc_request *pkc_req;
 193         struct dsa_verify_req_s *dsa_req;
 194         int rc, buf_size;
 195         uint8_t *buf;
 196 @@ -281,8 +276,7 @@ int crypto_kop_dsaverify(struct cryptodev_pkc *pkc)
 197             !cop->crk_param[7].crp_nbits))
 198                 return -EINVAL;
 199
 200 -       pkc_req = &pkc->req;
 201 -       dsa_req = &pkc_req->req_u.dsa_verify;
 202 +       dsa_req = &pkc->req->req_u.dsa_verify;
 203         dsa_req->m_len = (cop->crk_param[0].crp_nbits + 7)/8;
 204         dsa_req->q_len = (cop->crk_param[1].crp_nbits + 7)/8;
 205         dsa_req->r_len = (cop->crk_param[2].crp_nbits + 7)/8;
 206 @@ -295,10 +289,7 @@ int crypto_kop_dsaverify(struct cryptodev_pkc *pkc)
 207         if (cop->crk_iparams == 8) {
 208                 dsa_req->ab_len = (cop->crk_param[5].crp_nbits + 7)/8;
 209                 buf_size += dsa_req->ab_len;
 210 -               pkc_req->type = ECDSA_VERIFY;
 211 -               pkc_req->curve_type = cop->curve_type;
 212 -       } else {
 213 -               pkc_req->type = DSA_VERIFY;
 214 +               pkc->req->curve_type = cop->curve_type;
 215         }
 216
 217         buf = kmalloc(buf_size, GFP_DMA);
 218 @@ -351,7 +342,6 @@ int crypto_kop_rsa_keygen(struct cryptodev_pkc *pkc)
 219  {
 220         struct kernel_crypt_kop *kop = &pkc->kop;
 221         struct crypt_kop *cop = &kop->kop;
 222 -       struct pkc_request *pkc_req;
 223         struct rsa_keygen_req_s *key_req;
 224         int rc, buf_size;
 225         uint8_t *buf;
 226 @@ -362,9 +352,7 @@ int crypto_kop_rsa_keygen(struct cryptodev_pkc *pkc)
 227                 !cop->crk_param[6].crp_nbits)
 228                 return -EINVAL;
 229
 230 -       pkc_req = &pkc->req;
 231 -       pkc_req->type = RSA_KEYGEN;
 232 -       key_req = &pkc_req->req_u.rsa_keygen;
 233 +       key_req = &pkc->req->req_u.rsa_keygen;
 234         key_req->n_len = (cop->crk_param[2].crp_nbits + 7)/8;
 235         key_req->p_len = (cop->crk_param[0].crp_nbits + 7) / 8;
 236         key_req->q_len = (cop->crk_param[1].crp_nbits + 7) / 8;
 237 @@ -427,7 +415,6 @@ int crypto_kop_keygen(struct cryptodev_pkc *pkc)
 238  {
 239         struct kernel_crypt_kop *kop = &pkc->kop;
 240         struct crypt_kop *cop = &kop->kop;
 241 -       struct pkc_request *pkc_req;
 242         struct keygen_req_s *key_req;
 243         int rc, buf_size;
 244         uint8_t *buf;
 245 @@ -437,8 +424,7 @@ int crypto_kop_keygen(struct cryptodev_pkc *pkc)
 246             !cop->crk_param[4].crp_nbits)
 247                 return -EINVAL;
 248
 249 -       pkc_req = &pkc->req;
 250 -       key_req = &pkc_req->req_u.keygen;
 251 +       key_req = &pkc->req->req_u.keygen;
 252         key_req->q_len = (cop->crk_param[0].crp_nbits + 7)/8;
 253         key_req->r_len = (cop->crk_param[1].crp_nbits + 7)/8;
 254         key_req->g_len = (cop->crk_param[2].crp_nbits + 7)/8;
 255 @@ -447,7 +433,6 @@ int crypto_kop_keygen(struct cryptodev_pkc *pkc)
 256                 key_req->priv_key_len = (cop->crk_param[4].crp_nbits + 7)/8;
 257                 buf_size = key_req->q_len + key_req->r_len + key_req->g_len +
 258                         key_req->pub_key_len + key_req->priv_key_len;
 259 -               pkc_req->type = DLC_KEYGEN;
 260         } else {
 261                 key_req->ab_len = (cop->crk_param[3].crp_nbits + 7)/8;
 262                 key_req->pub_key_len = (cop->crk_param[4].crp_nbits + 7)/8;
 263 @@ -455,8 +440,7 @@ int crypto_kop_keygen(struct cryptodev_pkc *pkc)
 264                 buf_size = key_req->q_len + key_req->r_len + key_req->g_len +
 265                         key_req->pub_key_len + key_req->priv_key_len +
 266                         key_req->ab_len;
 267 -               pkc_req->type = ECC_KEYGEN;
 268 -               pkc_req->curve_type = cop->curve_type;
 269 +               pkc->req->curve_type = cop->curve_type;
 270         }
 271
 272         buf = kmalloc(buf_size, GFP_DMA);
 273 @@ -508,26 +492,22 @@ int crypto_kop_dh_key(struct cryptodev_pkc *pkc)
 274  {
 275         struct kernel_crypt_kop *kop = &pkc->kop;
 276         struct crypt_kop *cop = &kop->kop;
 277 -       struct pkc_request *pkc_req;
 278         struct dh_key_req_s *dh_req;
 279         int buf_size;
 280         uint8_t *buf;
 281         int rc = -EINVAL;
 282
 283 -       pkc_req = &pkc->req;
 284 -       dh_req = &pkc_req->req_u.dh_req;
 285 +       dh_req = &pkc->req->req_u.dh_req;
 286         dh_req->s_len = (cop->crk_param[0].crp_nbits + 7)/8;
 287         dh_req->pub_key_len = (cop->crk_param[1].crp_nbits + 7)/8;
 288         dh_req->q_len = (cop->crk_param[2].crp_nbits + 7)/8;
 289         buf_size = dh_req->q_len + dh_req->pub_key_len + dh_req->s_len;
 290         if (cop->crk_iparams == 4) {
 291 -               pkc_req->type = ECDH_COMPUTE_KEY;
 292                 dh_req->ab_len = (cop->crk_param[3].crp_nbits + 7)/8;
 293                 dh_req->z_len = (cop->crk_param[4].crp_nbits + 7)/8;
 294                 buf_size += dh_req->ab_len;
 295         } else {
 296                 dh_req->z_len = (cop->crk_param[3].crp_nbits + 7)/8;
 297 -               pkc_req->type = DH_COMPUTE_KEY;
 298         }
 299         buf_size += dh_req->z_len;
 300         buf = kmalloc(buf_size, GFP_DMA);
 301 @@ -539,7 +519,7 @@ int crypto_kop_dh_key(struct cryptodev_pkc *pkc)
 302         dh_req->z = dh_req->pub_key + dh_req->pub_key_len;
 303         if (cop->crk_iparams == 4) {
 304                 dh_req->ab = dh_req->z + dh_req->z_len;
 305 -               pkc_req->curve_type = cop->curve_type;
 306 +               pkc->req->curve_type = cop->curve_type;
 307                 copy_from_user(dh_req->ab, cop->crk_param[3].crp_p,
 308                                dh_req->ab_len);
 309         }
 310 @@ -573,7 +553,6 @@ int crypto_modexp_crt(struct cryptodev_pkc *pkc)
 311  {
 312         struct kernel_crypt_kop *kop = &pkc->kop;
 313         struct crypt_kop *cop = &kop->kop;
 314 -       struct pkc_request *pkc_req;
 315         struct rsa_priv_frm3_req_s *rsa_req;
 316         int rc;
 317         uint8_t *buf;
 318 @@ -583,9 +562,7 @@ int crypto_modexp_crt(struct cryptodev_pkc *pkc)
 319             !cop->crk_param[4].crp_nbits || !cop->crk_param[5].crp_nbits)
 320                 return -EINVAL;
 321
 322 -       pkc_req = &pkc->req;
 323 -       pkc_req->type = RSA_PRIV_FORM3;
 324 -       rsa_req = &pkc_req->req_u.rsa_priv_f3;
 325 +       rsa_req = &pkc->req->req_u.rsa_priv_f3;
 326         rsa_req->p_len = (cop->crk_param[0].crp_nbits + 7)/8;
 327         rsa_req->q_len = (cop->crk_param[1].crp_nbits + 7)/8;
 328         rsa_req->g_len = (cop->crk_param[2].crp_nbits + 7)/8;
 329 @@ -632,7 +609,6 @@ err:
 330
 331  int crypto_bn_modexp(struct cryptodev_pkc *pkc)
 332  {
 333 -       struct pkc_request *pkc_req;
 334         struct rsa_pub_req_s *rsa_req;
 335         int rc;
 336         struct kernel_crypt_kop *kop = &pkc->kop;
 337 @@ -643,9 +619,7 @@ int crypto_bn_modexp(struct cryptodev_pkc *pkc)
 338             !cop->crk_param[2].crp_nbits || !cop->crk_param[3].crp_nbits)
 339                 return -EINVAL;
 340
 341 -       pkc_req = &pkc->req;
 342 -       pkc_req->type = RSA_PUB;
 343 -       rsa_req = &pkc_req->req_u.rsa_pub_req;
 344 +       rsa_req = &pkc->req->req_u.rsa_pub_req;
 345         rsa_req->f_len = (cop->crk_param[0].crp_nbits + 7)/8;
 346         rsa_req->e_len = (cop->crk_param[1].crp_nbits + 7)/8;
 347         rsa_req->n_len = (cop->crk_param[2].crp_nbits + 7)/8;
 348 @@ -680,56 +654,116 @@ err:
 349         return rc;
 350  }
 351
 352 +static struct {
 353 +       char *alg_name;
 354 +       u32 type;
 355 +       u32 mask;
 356 +} pkc_alg_list[] = {
 357 +               {"pkc(rsa)", CRYPTO_ALG_TYPE_PKC_RSA, 0},
 358 +               {"pkc(dsa)", CRYPTO_ALG_TYPE_PKC_DSA, 0},
 359 +               {"pkc(dh)", CRYPTO_ALG_TYPE_PKC_DH, 0},
 360 +};
 361 +
 362  int crypto_run_asym(struct cryptodev_pkc *pkc)
 363  {
 364 -       int ret = -EINVAL;
 365 +       int err = -EINVAL;
 366 +       int id;
 367         struct kernel_crypt_kop *kop = &pkc->kop;
 368 +       enum pkc_req_type pkc_req_type;
 369 +       int (*call_next_action)(struct cryptodev_pkc *pkc);
 370
 371         switch (kop->kop.crk_op) {
 372         case CRK_MOD_EXP:
 373                 if (kop->kop.crk_iparams != 3 && kop->kop.crk_oparams != 1)
 374 -                       goto err;
 375 -
 376 -               ret = crypto_bn_modexp(pkc);
 377 +                       return err;
 378 +               pkc_req_type = RSA_PUB;
 379 +               id = 0;
 380 +               call_next_action = crypto_bn_modexp;
 381                 break;
 382         case CRK_MOD_EXP_CRT:
 383                 if (kop->kop.crk_iparams != 6 && kop->kop.crk_oparams != 1)
 384 -                       goto err;
 385 -
 386 -               ret = crypto_modexp_crt(pkc);
 387 +                       return err;
 388 +               pkc_req_type = RSA_PRIV_FORM3;
 389 +               id = 0;
 390 +               call_next_action = crypto_modexp_crt;
 391                 break;
 392         case CRK_DSA_SIGN:
 393 -               if ((kop->kop.crk_iparams != 5 && kop->kop.crk_iparams != 6) ||
 394 -                   kop->kop.crk_oparams != 2)
 395 -                       goto err;
 396 -
 397 -               ret = crypto_kop_dsasign(pkc);
 398 +               if (kop->kop.crk_oparams != 2)
 399 +                       return err;
 400 +               else if (kop->kop.crk_iparams == 5)
 401 +                       pkc_req_type = DSA_SIGN;
 402 +               else if (kop->kop.crk_iparams == 6)
 403 +                       pkc_req_type = ECDSA_SIGN;
 404 +               else
 405 +                       return err;
 406 +               id = 1;
 407 +               call_next_action = crypto_kop_dsasign;
 408                 break;
 409         case CRK_DSA_VERIFY:
 410 -               if ((kop->kop.crk_iparams != 7 && kop->kop.crk_iparams != 8) ||
 411 -                   kop->kop.crk_oparams != 0)
 412 -                       goto err;
 413 -
 414 -               ret = crypto_kop_dsaverify(pkc);
 415 +               if (kop->kop.crk_oparams != 0)
 416 +                       return err;
 417 +               else if (kop->kop.crk_iparams == 7)
 418 +                       pkc_req_type = DSA_VERIFY;
 419 +               else if (kop->kop.crk_iparams == 8)
 420 +                       pkc_req_type = ECDSA_VERIFY;
 421 +               else
 422 +                       return err;
 423 +               id = 1;
 424 +               call_next_action = crypto_kop_dsaverify;
 425                 break;
 426         case CRK_DH_COMPUTE_KEY:
 427 -               if ((kop->kop.crk_iparams != 3 && kop->kop.crk_iparams != 4) ||
 428 -                   kop->kop.crk_oparams != 1)
 429 -                       goto err;
 430 -               ret = crypto_kop_dh_key(pkc);
 431 +               if (kop->kop.crk_oparams != 1)
 432 +                       return err;
 433 +               else if (kop->kop.crk_iparams == 3)
 434 +                       pkc_req_type =  DH_COMPUTE_KEY;
 435 +               else if (kop->kop.crk_iparams == 4)
 436 +                       pkc_req_type =  ECDH_COMPUTE_KEY;
 437 +               else
 438 +                       return err;
 439 +               id = 2;
 440 +               call_next_action = crypto_kop_dh_key;
 441                 break;
 442         case CRK_DH_GENERATE_KEY:
 443         case CRK_DSA_GENERATE_KEY:
 444 -               if ((kop->kop.crk_iparams != 3 && kop->kop.crk_iparams != 4))
 445 -                       goto err;
 446 -               ret = crypto_kop_keygen(pkc);
 447 +               if (kop->kop.crk_iparams == 3)
 448 +                       pkc_req_type = DLC_KEYGEN;
 449 +               else if (kop->kop.crk_iparams == 4)
 450 +                       pkc_req_type = ECC_KEYGEN;
 451 +               else
 452 +                       return err;
 453 +               id = 1;
 454 +               call_next_action = crypto_kop_keygen;
 455                 break;
 456         case CRK_RSA_GENERATE_KEY:
 457 -               ret = crypto_kop_rsa_keygen(pkc);
 458 +               pkc_req_type = RSA_KEYGEN;
 459 +               id = 0;
 460 +               call_next_action = crypto_kop_rsa_keygen;
 461                 break;
 462 +       default:
 463 +               return err;
 464         }
 465 -err:
 466 -       return ret;
 467 +       err = -ENOMEM;
 468 +       pkc->s = crypto_alloc_pkc(pkc_alg_list[id].alg_name,
 469 +                                       pkc_alg_list[id].type,
 470 +                                       pkc_alg_list[id].mask);
 471 +       if (IS_ERR_OR_NULL(pkc->s))
 472 +               return err;
 473 +
 474 +       pkc->req = pkc_request_alloc(pkc->s, GFP_KERNEL);
 475 +       if (IS_ERR_OR_NULL(pkc->req))
 476 +               goto out_free_tfm;
 477 +
 478 +       /* todo - fix alloc-free on error path */
 479 +       pkc->req->type = pkc_req_type;
 480 +       err = call_next_action(pkc);
 481 +       if (pkc->type == SYNCHRONOUS)
 482 +               kfree(pkc->req);
 483 +
 484 +       return err;
 485 +
 486 +out_free_tfm:
 487 +       crypto_free_pkc(pkc->s);
 488 +       return err;
 489  }
 490
 491  int crypto_run(struct fcrypt *fcr, struct kernel_crypt_op *kcop)
 492 --
 493 2.3.5
 494