Ignore:
Timestamp:
Apr 21, 2017, 4:28:29 AM (2 months ago)
Author:
brainslayer
Message:

update

File:
1 edited

Legend:

Unmodified
Added
Removed
  • src/linux/universal/linux-4.9/crypto/ahash.c

    r31574 r31885  
    3232        void *data;
    3333        u8 *result;
     34        u32 flags;
    3435        void *ubuf[] CRYPTO_MINALIGN_ATTR;
    3536};
     
    253254        priv->complete = req->base.complete;
    254255        priv->data = req->base.data;
     256        priv->flags = req->base.flags;
     257
    255258        /*
    256259         * WARNING: We do not backup req->priv here! The req->priv
     
    267270}
    268271
    269 static void ahash_restore_req(struct ahash_request *req)
     272static void ahash_restore_req(struct ahash_request *req, int err)
    270273{
    271274        struct ahash_request_priv *priv = req->priv;
    272 
    273         /* Restore the original crypto request. */
    274         req->result = priv->result;
    275         req->base.complete = priv->complete;
    276         req->base.data = priv->data;
    277         req->priv = NULL;
    278 
    279         /* Free the req->priv.priv from the ADJUSTED request. */
    280         kzfree(priv);
    281 }
    282 
    283 static void ahash_op_unaligned_finish(struct ahash_request *req, int err)
    284 {
    285         struct ahash_request_priv *priv = req->priv;
    286 
    287         if (err == -EINPROGRESS)
    288                 return;
    289275
    290276        if (!err)
     
    292278                       crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
    293279
    294         ahash_restore_req(req);
     280        /* Restore the original crypto request. */
     281        req->result = priv->result;
     282
     283        ahash_request_set_callback(req, priv->flags,
     284                                   priv->complete, priv->data);
     285        req->priv = NULL;
     286
     287        /* Free the req->priv.priv from the ADJUSTED request. */
     288        kzfree(priv);
     289}
     290
     291static void ahash_notify_einprogress(struct ahash_request *req)
     292{
     293        struct ahash_request_priv *priv = req->priv;
     294        struct crypto_async_request oreq;
     295
     296        oreq.data = priv->data;
     297
     298        priv->complete(&oreq, -EINPROGRESS);
    295299}
    296300
     
    298302{
    299303        struct ahash_request *areq = req->data;
     304
     305        if (err == -EINPROGRESS) {
     306                ahash_notify_einprogress(areq);
     307                return;
     308        }
    300309
    301310        /*
     
    309318
    310319        /* First copy req->result into req->priv.result */
    311         ahash_op_unaligned_finish(areq, err);
     320        ahash_restore_req(areq, err);
    312321
    313322        /* Complete the ORIGINAL request. */
     
    325334
    326335        err = op(req);
    327         ahash_op_unaligned_finish(req, err);
     336        if (err == -EINPROGRESS ||
     337            (err == -EBUSY && (ahash_request_flags(req) &
     338                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     339                return err;
     340
     341        ahash_restore_req(req, err);
    328342
    329343        return err;
     
    360374EXPORT_SYMBOL_GPL(crypto_ahash_digest);
    361375
    362 static void ahash_def_finup_finish2(struct ahash_request *req, int err)
    363 {
    364         struct ahash_request_priv *priv = req->priv;
     376static void ahash_def_finup_done2(struct crypto_async_request *req, int err)
     377{
     378        struct ahash_request *areq = req->data;
    365379
    366380        if (err == -EINPROGRESS)
    367381                return;
    368382
    369         if (!err)
    370                 memcpy(priv->result, req->result,
    371                        crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
    372 
    373         ahash_restore_req(req);
    374 }
    375 
    376 static void ahash_def_finup_done2(struct crypto_async_request *req, int err)
    377 {
    378         struct ahash_request *areq = req->data;
    379 
    380         ahash_def_finup_finish2(areq, err);
     383        ahash_restore_req(areq, err);
    381384
    382385        areq->base.complete(&areq->base, err);
     
    389392
    390393        req->base.complete = ahash_def_finup_done2;
    391         req->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
     394
    392395        err = crypto_ahash_reqtfm(req)->final(req);
     396        if (err == -EINPROGRESS ||
     397            (err == -EBUSY && (ahash_request_flags(req) &
     398                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     399                return err;
    393400
    394401out:
    395         ahash_def_finup_finish2(req, err);
     402        ahash_restore_req(req, err);
    396403        return err;
    397404}
     
    401408        struct ahash_request *areq = req->data;
    402409
     410        if (err == -EINPROGRESS) {
     411                ahash_notify_einprogress(areq);
     412                return;
     413        }
     414
     415        areq->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
     416
    403417        err = ahash_def_finup_finish1(areq, err);
     418        if (areq->priv)
     419                return;
    404420
    405421        areq->base.complete(&areq->base, err);
     
    416432
    417433        err = tfm->update(req);
     434        if (err == -EINPROGRESS ||
     435            (err == -EBUSY && (ahash_request_flags(req) &
     436                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     437                return err;
     438
    418439        return ahash_def_finup_finish1(req, err);
    419440}
Note: See TracChangeset for help on using the changeset viewer.