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-3.18/crypto/ahash.c

    r29844 r31885  
    3232        void *data;
    3333        u8 *result;
     34        u32 flags;
    3435        void *ubuf[] CRYPTO_MINALIGN_ATTR;
    3536};
     
    270271        priv->complete = req->base.complete;
    271272        priv->data = req->base.data;
     273        priv->flags = req->base.flags;
     274
    272275        /*
    273276         * WARNING: We do not backup req->priv here! The req->priv
     
    284287}
    285288
    286 static void ahash_restore_req(struct ahash_request *req)
     289static void ahash_restore_req(struct ahash_request *req, int err)
    287290{
    288291        struct ahash_request_priv *priv = req->priv;
    289 
    290         /* Restore the original crypto request. */
    291         req->result = priv->result;
    292         req->base.complete = priv->complete;
    293         req->base.data = priv->data;
    294         req->priv = NULL;
    295 
    296         /* Free the req->priv.priv from the ADJUSTED request. */
    297         kzfree(priv);
    298 }
    299 
    300 static void ahash_op_unaligned_finish(struct ahash_request *req, int err)
    301 {
    302         struct ahash_request_priv *priv = req->priv;
    303 
    304         if (err == -EINPROGRESS)
    305                 return;
    306292
    307293        if (!err)
     
    309295                       crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
    310296
    311         ahash_restore_req(req);
     297        /* Restore the original crypto request. */
     298        req->result = priv->result;
     299
     300        ahash_request_set_callback(req, priv->flags,
     301                                   priv->complete, priv->data);
     302        req->priv = NULL;
     303
     304        /* Free the req->priv.priv from the ADJUSTED request. */
     305        kzfree(priv);
     306}
     307
     308static void ahash_notify_einprogress(struct ahash_request *req)
     309{
     310        struct ahash_request_priv *priv = req->priv;
     311        struct crypto_async_request oreq;
     312
     313        oreq.data = priv->data;
     314
     315        priv->complete(&oreq, -EINPROGRESS);
    312316}
    313317
     
    315319{
    316320        struct ahash_request *areq = req->data;
     321
     322        if (err == -EINPROGRESS) {
     323                ahash_notify_einprogress(areq);
     324                return;
     325        }
    317326
    318327        /*
     
    326335
    327336        /* First copy req->result into req->priv.result */
    328         ahash_op_unaligned_finish(areq, err);
     337        ahash_restore_req(areq, err);
    329338
    330339        /* Complete the ORIGINAL request. */
     
    342351
    343352        err = op(req);
    344         ahash_op_unaligned_finish(req, err);
     353        if (err == -EINPROGRESS ||
     354            (err == -EBUSY && (ahash_request_flags(req) &
     355                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     356                return err;
     357
     358        ahash_restore_req(req, err);
    345359
    346360        return err;
     
    377391EXPORT_SYMBOL_GPL(crypto_ahash_digest);
    378392
    379 static void ahash_def_finup_finish2(struct ahash_request *req, int err)
    380 {
    381         struct ahash_request_priv *priv = req->priv;
     393static void ahash_def_finup_done2(struct crypto_async_request *req, int err)
     394{
     395        struct ahash_request *areq = req->data;
    382396
    383397        if (err == -EINPROGRESS)
    384398                return;
    385399
    386         if (!err)
    387                 memcpy(priv->result, req->result,
    388                        crypto_ahash_digestsize(crypto_ahash_reqtfm(req)));
    389 
    390         ahash_restore_req(req);
    391 }
    392 
    393 static void ahash_def_finup_done2(struct crypto_async_request *req, int err)
    394 {
    395         struct ahash_request *areq = req->data;
    396 
    397         ahash_def_finup_finish2(areq, err);
     400        ahash_restore_req(areq, err);
    398401
    399402        areq->base.complete(&areq->base, err);
     
    406409
    407410        req->base.complete = ahash_def_finup_done2;
    408         req->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
     411
    409412        err = crypto_ahash_reqtfm(req)->final(req);
     413        if (err == -EINPROGRESS ||
     414            (err == -EBUSY && (ahash_request_flags(req) &
     415                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     416                return err;
    410417
    411418out:
    412         ahash_def_finup_finish2(req, err);
     419        ahash_restore_req(req, err);
    413420        return err;
    414421}
     
    418425        struct ahash_request *areq = req->data;
    419426
     427        if (err == -EINPROGRESS) {
     428                ahash_notify_einprogress(areq);
     429                return;
     430        }
     431
     432        areq->base.flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP;
     433
    420434        err = ahash_def_finup_finish1(areq, err);
     435        if (areq->priv)
     436                return;
    421437
    422438        areq->base.complete(&areq->base, err);
     
    433449
    434450        err = tfm->update(req);
     451        if (err == -EINPROGRESS ||
     452            (err == -EBUSY && (ahash_request_flags(req) &
     453                               CRYPTO_TFM_REQ_MAY_BACKLOG)))
     454                return err;
     455
    435456        return ahash_def_finup_finish1(req, err);
    436457}
Note: See TracChangeset for help on using the changeset viewer.