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

update

File:
1 edited

Legend:

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

    r29744 r31885  
    3232        void *data;
    3333        u8 *result;
     34        u32 flags;
    3435        void *ubuf[] CRYPTO_MINALIGN_ATTR;
    3536};
     
    271272        priv->complete = req->base.complete;
    272273        priv->data = req->base.data;
     274        priv->flags = req->base.flags;
     275
    273276        /*
    274277         * WARNING: We do not backup req->priv here! The req->priv
     
    285288}
    286289
    287 static void ahash_restore_req(struct ahash_request *req)
     290static void ahash_restore_req(struct ahash_request *req, int err)
    288291{
    289292        struct ahash_request_priv *priv = req->priv;
    290 
    291         /* Restore the original crypto request. */
    292         req->result = priv->result;
    293         req->base.complete = priv->complete;
    294         req->base.data = priv->data;
    295         req->priv = NULL;
    296 
    297         /* Free the req->priv.priv from the ADJUSTED request. */
    298         kzfree(priv);
    299 }
    300 
    301 static void ahash_op_unaligned_finish(struct ahash_request *req, int err)
    302 {
    303         struct ahash_request_priv *priv = req->priv;
    304 
    305         if (err == -EINPROGRESS)
    306                 return;
    307293
    308294        if (!err)
     
    310296                       crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
    311297
    312         ahash_restore_req(req);
     298        /* Restore the original crypto request. */
     299        req->result = priv->result;
     300
     301        ahash_request_set_callback(req, priv->flags,
     302                                   priv->complete, priv->data);
     303        req->priv = NULL;
     304
     305        /* Free the req->priv.priv from the ADJUSTED request. */
     306        kzfree(priv);
     307}
     308
     309static void ahash_notify_einprogress(struct ahash_request *req)
     310{
     311        struct ahash_request_priv *priv = req->priv;
     312        struct crypto_async_request oreq;
     313
     314        oreq.data = priv->data;
     315
     316        priv->complete(&oreq, -EINPROGRESS);
    313317}
    314318
     
    316320{
    317321        struct ahash_request *areq = req->data;
     322
     323        if (err == -EINPROGRESS) {
     324                ahash_notify_einprogress(areq);
     325                return;
     326        }
    318327
    319328        /*
     
    327336
    328337        /* First copy req->result into req->priv.result */
    329         ahash_op_unaligned_finish(areq, err);
     338        ahash_restore_req(areq, err);
    330339
    331340        /* Complete the ORIGINAL request. */
     
    343352
    344353        err = op(req);
    345         ahash_op_unaligned_finish(req, err);
     354        if (err == -EINPROGRESS ||
     355            (err == -EBUSY && (ahash_request_flags(req) &
     356                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     357                return err;
     358
     359        ahash_restore_req(req, err);
    346360
    347361        return err;
     
    378392EXPORT_SYMBOL_GPL(crypto_ahash_digest);
    379393
    380 static void ahash_def_finup_finish2(struct ahash_request *req, int err)
    381 {
    382         struct ahash_request_priv *priv = req->priv;
     394static void ahash_def_finup_done2(struct crypto_async_request *req, int err)
     395{
     396        struct ahash_request *areq = req->data;
    383397
    384398        if (err == -EINPROGRESS)
    385399                return;
    386400
    387         if (!err)
    388                 memcpy(priv->result, req->result,
    389                        crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
    390 
    391         ahash_restore_req(req);
    392 }
    393 
    394 static void ahash_def_finup_done2(struct crypto_async_request *req, int err)
    395 {
    396         struct ahash_request *areq = req->data;
    397 
    398         ahash_def_finup_finish2(areq, err);
     401        ahash_restore_req(areq, err);
    399402
    400403        areq->base.complete(&areq->base, err);
     
    407410
    408411        req->base.complete = ahash_def_finup_done2;
    409         req->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
     412
    410413        err = crypto_ahash_reqtfm(req)->final(req);
     414        if (err == -EINPROGRESS ||
     415            (err == -EBUSY && (ahash_request_flags(req) &
     416                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     417                return err;
    411418
    412419out:
    413         ahash_def_finup_finish2(req, err);
     420        ahash_restore_req(req, err);
    414421        return err;
    415422}
     
    419426        struct ahash_request *areq = req->data;
    420427
     428        if (err == -EINPROGRESS) {
     429                ahash_notify_einprogress(areq);
     430                return;
     431        }
     432
     433        areq->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
     434
    421435        err = ahash_def_finup_finish1(areq, err);
     436        if (areq->priv)
     437                return;
    422438
    423439        areq->base.complete(&areq->base, err);
     
    434450
    435451        err = tfm->update(req);
     452        if (err == -EINPROGRESS ||
     453            (err == -EBUSY && (ahash_request_flags(req) &
     454                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     455                return err;
     456
    436457        return ahash_def_finup_finish1(req, err);
    437458}
Note: See TracChangeset for help on using the changeset viewer.