qiurui
/
Centos-kernel-stream-9
mirror of https://gitlab.com/redhat/centos-stream/src/kernel/centos-stream-9.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

crypto: engine - Remove prepare/unprepare request 

JIRA: https://issues.redhat.com/browse/RHEL-83268

Conflicts:
	crypto/crypto_engine.c code change in crypto_pump_requests
	Different name of variable due to different order of kernel
	backports. Upstream commit e5e7eb023f24 (crypto: engine - Move
	crypto_engine_ops from request into crypto_alg) was merged
	without backporting this patch.

commit bcd6e41d983621954dfc3f1f64249a55838b3e6a
Author: Herbert Xu <herbert@gondor.apana.org.au>
Date: Sun, 13 Aug 2023 14:54:32 +0800

    The callbacks for prepare and unprepare request in crypto_engine
    is superfluous.  They can be done directly from do_one_request.

    Move the code into do_one_request and remove the unused callbacks.

    Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

Signed-off-by: Marcin Juszkiewicz <mjuszkiewicz@redhat.com>
This commit is contained in:
Marcin Juszkiewicz 2025-04-17 12:49:19 +02:00
parent 302e852098
commit 3267525538
2 changed files with 1 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
crypto/crypto_engine.c
View File

@ -41,9 +41,6 @@ static void crypto_finalize_request(struct crypto_engine *engine,
struct crypto_async_request *req, int err)
{
unsigned long flags;
bool finalize_req = false;
int ret;
struct crypto_engine_ctx *enginectx;
/*
* If hardware cannot enqueue more requests
@ -53,21 +50,11 @@ static void crypto_finalize_request(struct crypto_engine *engine,
if (!engine->retry_support) {
spin_lock_irqsave(&engine->queue_lock, flags);
if (engine->cur_req == req) {
finalize_req = true;
engine->cur_req = NULL;
}
spin_unlock_irqrestore(&engine->queue_lock, flags);
}
if (finalize_req || engine->retry_support) {
enginectx = crypto_tfm_ctx(req->tfm);
if (enginectx->op.prepare_request &&
enginectx->op.unprepare_request) {
ret = enginectx->op.unprepare_request(engine, req);
if (ret)
dev_err(engine->dev, "failed to unprepare request\n");
}
}
req->complete(req, err);
kthread_queue_work(engine->kworker, &engine->pump_requests);
@ -160,7 +147,7 @@ start_request:
ret = engine->prepare_crypt_hardware(engine);
if (ret) {
dev_err(engine->dev, "failed to prepare crypt hardware\n");
goto req_err_2;
goto req_err_1;
}
}
@ -170,16 +157,7 @@ start_request:
op = &alg->op;
} else {
enginectx = crypto_tfm_ctx(async_req->tfm);
op = &enginectx->op;
if (op->prepare_request) {
ret = op->prepare_request(engine, async_req);
if (ret) {
dev_err(engine->dev, "failed to prepare request: %d\n",
ret);
goto req_err_2;
}
}
if (!op->do_one_request) {
dev_err(engine->dev, "failed to do request\n");
ret = -EINVAL;
@ -203,18 +181,6 @@ start_request:
ret);
goto req_err_1;
}
/*
* If retry mechanism is supported,
* unprepare current request and
* enqueue it back into crypto-engine queue.
*/
if (enginectx->op.unprepare_request) {
ret = enginectx->op.unprepare_request(engine,
async_req);
if (ret)
dev_err(engine->dev,
"failed to unprepare request\n");
}
spin_lock_irqsave(&engine->queue_lock, flags);
/*
* If hardware was unable to execute request, enqueue it
@ -230,13 +196,6 @@ start_request:
goto retry;
req_err_1:
if (enginectx->op.unprepare_request) {
ret = enginectx->op.unprepare_request(engine, async_req);
if (ret)
dev_err(engine->dev, "failed to unprepare request\n");
}
req_err_2:
async_req->complete(async_req, ret);
retry:

6
include/crypto/engine.h
View File

@ -19,15 +19,9 @@ struct device;
/*
* struct crypto_engine_op - crypto hardware engine operations
* @prepare__request: do some prepare if need before handle the current request
* @unprepare_request: undo any work done by prepare_request()
* @do_one_request: do encryption for current request
*/
struct crypto_engine_op {
int (*prepare_request)(struct crypto_engine *engine,
void *areq);
int (*unprepare_request)(struct crypto_engine *engine,
void *areq);
int (*do_one_request)(struct crypto_engine *engine,
void *areq);
};