d/numam-dpdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

crypto/qat: support session-less for asym ops

Browse Source 
This patch adds option to use asymmetric crypto pmd with
session-less support.

Signed-off-by: Arek Kusztal <arkadiuszx.kusztal@intel.com>
Acked-by: Fiona Trahe <fiona.trahe@intel.com>
This commit is contained in:
Arek Kusztal 2019-10-22 16:04:25 +02:00 committed by Akhil Goyal
parent 3a97a35bea
commit e1ed5a73cd
5 changed files with 271 additions and 217 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
doc/guides/cryptodevs/features/qat.ini
View File

@ -13,6 +13,7 @@ OOP SGL In LB Out = Y
OOP LB In SGL Out = Y
OOP LB In LB Out = Y
Digest encrypted = Y
Asymmetric sessionless = Y
;
; Supported crypto algorithms of the 'qat' crypto driver.

4
doc/guides/rel_notes/release_19_11.rst
View File

@ -125,6 +125,10 @@ New Features
classic 2-pass mode when running on QAT GEN3, significantly improving
the performance of AES GCM operations.
* **Updated the Intel QuickAssist Technology (QAT) asymmetric crypto PMD.**
* Added support for asymmetric session-less operations.
* **Updated the Intel QuickAssist Technology (QAT) compression PMD.**
Added stateful decompression support in the Intel QuickAssist Technology PMD.

454
drivers/crypto/qat/qat_asym.c
View File

@ -26,38 +26,23 @@ static int qat_asym_get_sz_and_func_id(const uint32_t arr[][2],
return -1;
}
static void qat_asym_build_req_tmpl(void *sess_private_data,
struct rte_crypto_asym_xform *xform)
static inline void qat_fill_req_tmpl(struct icp_qat_fw_pke_request *qat_req)
{
struct icp_qat_fw_pke_request *qat_req;
struct qat_asym_session *session = sess_private_data;
qat_req = &session->req_tmpl;
memset(qat_req, 0, sizeof(*qat_req));
qat_req->pke_hdr.service_type = ICP_QAT_FW_COMN_REQ_CPM_FW_PKE;
qat_req->pke_hdr.hdr_flags =
ICP_QAT_FW_COMN_HDR_FLAGS_BUILD
(ICP_QAT_FW_COMN_REQ_FLAG_SET);
qat_req->pke_hdr.comn_req_flags = 0;
qat_req->pke_hdr.resrvd1 = 0;
qat_req->pke_hdr.resrvd2 = 0;
qat_req->pke_hdr.kpt_mask = 0;
qat_req->pke_hdr.kpt_rn_mask = 0;
qat_req->pke_hdr.cd_pars.content_desc_addr = 0;
qat_req->pke_hdr.cd_pars.content_desc_resrvd = 0;
qat_req->resrvd1 = 0;
qat_req->resrvd2 = 0;
qat_req->next_req_adr = 0;
}
if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) {
qat_req->output_param_count = 1;
qat_req->input_param_count = 3;
} else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
qat_req->output_param_count = 1;
qat_req->input_param_count = 2;
}
static inline void qat_asym_build_req_tmpl(void *sess_private_data)
{
struct icp_qat_fw_pke_request *qat_req;
struct qat_asym_session *session = sess_private_data;
qat_req = &session->req_tmpl;
qat_fill_req_tmpl(qat_req);
}
static size_t max_of(int n, ...)
@ -90,6 +75,19 @@ static void qat_clear_arrays(struct qat_asym_op_cookie *cookie,
memset(cookie->output_array[i], 0x0, out_size);
}
static void qat_clear_arrays_by_alg(struct qat_asym_op_cookie *cookie,
enum rte_crypto_asym_xform_type alg, int in_size, int out_size)
{
if (alg == RTE_CRYPTO_ASYM_XFORM_MODEX)
qat_clear_arrays(cookie, QAT_ASYM_MODEXP_NUM_IN_PARAMS,
QAT_ASYM_MODEXP_NUM_OUT_PARAMS, in_size,
out_size);
else if (alg == RTE_CRYPTO_ASYM_XFORM_MODINV)
qat_clear_arrays(cookie, QAT_ASYM_MODINV_NUM_IN_PARAMS,
QAT_ASYM_MODINV_NUM_OUT_PARAMS, in_size,
out_size);
}
static int qat_asym_check_nonzero(rte_crypto_param n)
{
if (n.length < 8) {
@ -103,7 +101,7 @@ static int qat_asym_check_nonzero(rte_crypto_param n)
if (n.data[i] != 0x0)
break;
if (i == n.length - 1)
return QAT_ASYM_ERROR_INVALID_PARAM;
return -(EINVAL);
}
} else if (*(uint64_t *)&n.data[
n.length - 8] == 0) {
@ -114,12 +112,129 @@ static int qat_asym_check_nonzero(rte_crypto_param n)
if (n.data[i] != 0x0)
break;
if (i == n.length - 8)
return QAT_ASYM_ERROR_INVALID_PARAM;
return -(EINVAL);
}
return 0;
}
static int
qat_asym_fill_arrays(struct rte_crypto_asym_op *asym_op,
struct icp_qat_fw_pke_request *qat_req,
struct qat_asym_op_cookie *cookie,
struct rte_crypto_asym_xform *xform)
{
int err = 0;
size_t alg_size;
size_t alg_size_in_bytes;
uint32_t func_id = 0;
if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) {
err = qat_asym_check_nonzero(xform->modex.modulus);
if (err) {
QAT_LOG(ERR, "Empty modulus in modular exponentiation,"
" aborting this operation");
return err;
}
alg_size_in_bytes = max_of(3, asym_op->modex.base.length,
xform->modex.exponent.length,
xform->modex.modulus.length);
alg_size = alg_size_in_bytes << 3;
if (qat_asym_get_sz_and_func_id(MOD_EXP_SIZE,
sizeof(MOD_EXP_SIZE)/sizeof(*MOD_EXP_SIZE),
&alg_size, &func_id)) {
return -(EINVAL);
}
alg_size_in_bytes = alg_size >> 3;
rte_memcpy(cookie->input_array[0] + alg_size_in_bytes -
asym_op->modex.base.length
, asym_op->modex.base.data,
asym_op->modex.base.length);
rte_memcpy(cookie->input_array[1] + alg_size_in_bytes -
xform->modex.exponent.length
, xform->modex.exponent.data,
xform->modex.exponent.length);
rte_memcpy(cookie->input_array[2] + alg_size_in_bytes -
xform->modex.modulus.length,
xform->modex.modulus.data,
xform->modex.modulus.length);
cookie->alg_size = alg_size;
qat_req->pke_hdr.cd_pars.func_id = func_id;
qat_req->input_param_count = QAT_ASYM_MODEXP_NUM_IN_PARAMS;
qat_req->output_param_count = QAT_ASYM_MODEXP_NUM_OUT_PARAMS;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "ModExp base",
cookie->input_array[0],
alg_size_in_bytes);
QAT_DP_HEXDUMP_LOG(DEBUG, "ModExp exponent",
cookie->input_array[1],
alg_size_in_bytes);
QAT_DP_HEXDUMP_LOG(DEBUG, " ModExpmodulus",
cookie->input_array[2],
alg_size_in_bytes);
#endif
} else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
err = qat_asym_check_nonzero(xform->modinv.modulus);
if (err) {
QAT_LOG(ERR, "Empty modulus in modular multiplicative"
" inverse, aborting this operation");
return err;
}
alg_size_in_bytes = max_of(2, asym_op->modinv.base.length,
xform->modinv.modulus.length);
alg_size = alg_size_in_bytes << 3;
if (xform->modinv.modulus.data[
xform->modinv.modulus.length - 1] & 0x01) {
if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_ODD,
sizeof(MOD_INV_IDS_ODD)/
sizeof(*MOD_INV_IDS_ODD),
&alg_size, &func_id)) {
return -(EINVAL);
}
} else {
if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_EVEN,
sizeof(MOD_INV_IDS_EVEN)/
sizeof(*MOD_INV_IDS_EVEN),
&alg_size, &func_id)) {
return -(EINVAL);
}
}
alg_size_in_bytes = alg_size >> 3;
rte_memcpy(cookie->input_array[0] + alg_size_in_bytes -
asym_op->modinv.base.length
, asym_op->modinv.base.data,
asym_op->modinv.base.length);
rte_memcpy(cookie->input_array[1] + alg_size_in_bytes -
xform->modinv.modulus.length
, xform->modinv.modulus.data,
xform->modinv.modulus.length);
cookie->alg_size = alg_size;
qat_req->pke_hdr.cd_pars.func_id = func_id;
qat_req->input_param_count =
QAT_ASYM_MODINV_NUM_IN_PARAMS;
qat_req->output_param_count =
QAT_ASYM_MODINV_NUM_OUT_PARAMS;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "ModInv base",
cookie->input_array[0],
alg_size_in_bytes);
QAT_DP_HEXDUMP_LOG(DEBUG, "ModInv modulus",
cookie->input_array[1],
alg_size_in_bytes);
#endif
} else {
QAT_LOG(ERR, "Invalid asymmetric crypto xform");
return -(EINVAL);
}
return 0;
}
int
qat_asym_build_request(void *in_op,
uint8_t *out_msg,
@ -133,124 +248,56 @@ qat_asym_build_request(void *in_op,
(struct icp_qat_fw_pke_request *)out_msg;
struct qat_asym_op_cookie *cookie =
(struct qat_asym_op_cookie *)op_cookie;
int err = 0;
uint64_t err = 0;
size_t alg_size;
size_t alg_size_in_bytes;
uint32_t func_id;
ctx = (struct qat_asym_session *)get_asym_session_private_data(
op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
ctx = (struct qat_asym_session *)
get_asym_session_private_data(
op->asym->session, cryptodev_qat_asym_driver_id);
rte_mov64((uint8_t *)qat_req, (const uint8_t *)&(ctx->req_tmpl));
qat_req->pke_mid.opaque = (uint64_t)(uintptr_t)op;
if (unlikely(ctx == NULL)) {
QAT_LOG(ERR, "Session has not been created for this device");
goto error;
}
rte_mov64((uint8_t *)qat_req, (const uint8_t *)&(ctx->req_tmpl));
err = qat_asym_fill_arrays(asym_op, qat_req, cookie, ctx->xform);
if (err) {
op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
goto error;
}
} else if (op->sess_type == RTE_CRYPTO_OP_SESSIONLESS) {
qat_fill_req_tmpl(qat_req);
err = qat_asym_fill_arrays(asym_op, qat_req, cookie,
op->asym->xform);
if (err) {
op->status = RTE_CRYPTO_OP_STATUS_INVALID_ARGS;
goto error;
}
} else {
QAT_DP_LOG(ERR, "Invalid session/xform settings");
op->status = RTE_CRYPTO_OP_STATUS_INVALID_SESSION;
goto error;
}
qat_req->pke_mid.opaque = (uint64_t)(uintptr_t)op;
qat_req->pke_mid.src_data_addr = cookie->input_addr;
qat_req->pke_mid.dest_data_addr = cookie->output_addr;
if (ctx->alg == QAT_PKE_MODEXP) {
err = qat_asym_check_nonzero(ctx->sess_alg_params.mod_exp.n);
if (err) {
QAT_LOG(ERR, "Empty modulus in modular exponentiation,"
" aborting this operation");
goto error;
}
alg_size_in_bytes = max_of(3, asym_op->modex.base.length,
ctx->sess_alg_params.mod_exp.e.length,
ctx->sess_alg_params.mod_exp.n.length);
alg_size = alg_size_in_bytes << 3;
if (qat_asym_get_sz_and_func_id(MOD_EXP_SIZE,
sizeof(MOD_EXP_SIZE)/sizeof(*MOD_EXP_SIZE),
&alg_size, &func_id)) {
err = QAT_ASYM_ERROR_INVALID_PARAM;
goto error;
}
alg_size_in_bytes = alg_size >> 3;
rte_memcpy(cookie->input_array[0] + alg_size_in_bytes -
asym_op->modex.base.length
, asym_op->modex.base.data,
asym_op->modex.base.length);
rte_memcpy(cookie->input_array[1] + alg_size_in_bytes -
ctx->sess_alg_params.mod_exp.e.length
, ctx->sess_alg_params.mod_exp.e.data,
ctx->sess_alg_params.mod_exp.e.length);
rte_memcpy(cookie->input_array[2] + alg_size_in_bytes -
ctx->sess_alg_params.mod_exp.n.length,
ctx->sess_alg_params.mod_exp.n.data,
ctx->sess_alg_params.mod_exp.n.length);
cookie->alg_size = alg_size;
qat_req->pke_hdr.cd_pars.func_id = func_id;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "base",
cookie->input_array[0],
alg_size_in_bytes);
QAT_DP_HEXDUMP_LOG(DEBUG, "exponent",
cookie->input_array[1],
alg_size_in_bytes);
QAT_DP_HEXDUMP_LOG(DEBUG, "modulus",
cookie->input_array[2],
alg_size_in_bytes);
#endif
} else if (ctx->alg == QAT_PKE_MODINV) {
err = qat_asym_check_nonzero(ctx->sess_alg_params.mod_inv.n);
if (err) {
QAT_LOG(ERR, "Empty modulus in modular multiplicative"
" inverse, aborting this operation");
goto error;
}
alg_size_in_bytes = max_of(2, asym_op->modinv.base.length,
ctx->sess_alg_params.mod_inv.n.length);
alg_size = alg_size_in_bytes << 3;
if (ctx->sess_alg_params.mod_inv.n.data[
ctx->sess_alg_params.mod_inv.n.length - 1] & 0x01) {
if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_ODD,
sizeof(MOD_INV_IDS_ODD)/
sizeof(*MOD_INV_IDS_ODD),
&alg_size, &func_id)) {
err = QAT_ASYM_ERROR_INVALID_PARAM;
goto error;
}
} else {
if (qat_asym_get_sz_and_func_id(MOD_INV_IDS_EVEN,
sizeof(MOD_INV_IDS_EVEN)/
sizeof(*MOD_INV_IDS_EVEN),
&alg_size, &func_id)) {
err = QAT_ASYM_ERROR_INVALID_PARAM;
goto error;
}
}
alg_size_in_bytes = alg_size >> 3;
rte_memcpy(cookie->input_array[0] + alg_size_in_bytes -
asym_op->modinv.base.length
, asym_op->modinv.base.data,
asym_op->modinv.base.length);
rte_memcpy(cookie->input_array[1] + alg_size_in_bytes -
ctx->sess_alg_params.mod_inv.n.length
, ctx->sess_alg_params.mod_inv.n.data,
ctx->sess_alg_params.mod_inv.n.length);
cookie->alg_size = alg_size;
qat_req->pke_hdr.cd_pars.func_id = func_id;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "base",
cookie->input_array[0],
alg_size_in_bytes);
QAT_DP_HEXDUMP_LOG(DEBUG, "modulus",
cookie->input_array[1],
alg_size_in_bytes);
#endif
}
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "qat_req:", qat_req,
sizeof(struct icp_qat_fw_pke_request));
#endif
return 0;
error:
qat_req->pke_mid.opaque = (uint64_t)(uintptr_t)op;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "qat_req:", qat_req,
sizeof(struct icp_qat_fw_pke_request));
#endif
qat_req->output_param_count = 0;
qat_req->input_param_count = 0;
qat_req->pke_hdr.service_type = ICP_QAT_FW_COMN_REQ_NULL;
@ -259,6 +306,59 @@ qat_asym_build_request(void *in_op,
return 0;
}
static void qat_asym_collect_response(struct rte_crypto_op *rx_op,
struct qat_asym_op_cookie *cookie,
struct rte_crypto_asym_xform *xform)
{
size_t alg_size, alg_size_in_bytes = 0;
struct rte_crypto_asym_op *asym_op = rx_op->asym;
if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) {
rte_crypto_param n = xform->modex.modulus;
alg_size = cookie->alg_size;
alg_size_in_bytes = alg_size >> 3;
uint8_t *modexp_result = asym_op->modex.result.data;
if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) {
rte_memcpy(modexp_result +
(asym_op->modex.result.length -
n.length),
cookie->output_array[0] + alg_size_in_bytes
- n.length, n.length
);
rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "ModExp result",
cookie->output_array[0],
alg_size_in_bytes);
#endif
}
} else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
rte_crypto_param n = xform->modinv.modulus;
alg_size = cookie->alg_size;
alg_size_in_bytes = alg_size >> 3;
uint8_t *modinv_result = asym_op->modinv.result.data;
if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) {
rte_memcpy(modinv_result + (asym_op->modinv.result.length
- n.length),
cookie->output_array[0] + alg_size_in_bytes
- n.length, n.length);
rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "ModInv result",
cookie->output_array[0],
alg_size_in_bytes);
#endif
}
}
qat_clear_arrays_by_alg(cookie, xform->xform_type, alg_size_in_bytes,
alg_size_in_bytes);
}
void
qat_asym_process_response(void **op, uint8_t *resp,
void *op_cookie)
@ -268,75 +368,37 @@ qat_asym_process_response(void **op, uint8_t *resp,
(struct icp_qat_fw_pke_resp *)resp;
struct rte_crypto_op *rx_op = (struct rte_crypto_op *)(uintptr_t)
(resp_msg->opaque);
struct rte_crypto_asym_op *asym_op = rx_op->asym;
struct qat_asym_op_cookie *cookie = op_cookie;
size_t alg_size, alg_size_in_bytes;
ctx = (struct qat_asym_session *)get_asym_session_private_data(
rx_op->asym->session, cryptodev_qat_asym_driver_id);
*op = rx_op;
rx_op->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
if (cookie->error) {
cookie->error = 0;
rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED)
rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
QAT_DP_LOG(ERR, "Cookie status returned error");
} else {
if (ICP_QAT_FW_PKE_RESP_PKE_STAT_GET(
resp_msg->pke_resp_hdr.resp_status.pke_resp_flags)) {
rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
QAT_DP_LOG(ERR, "Asymmetric response status returned error");
if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED)
rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
QAT_DP_LOG(ERR, "Asymmetric response status"
" returned error");
}
if (resp_msg->pke_resp_hdr.resp_status.comn_err_code) {
rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
QAT_DP_LOG(ERR, "Asymmetric common status returned error");
if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED)
rx_op->status = RTE_CRYPTO_OP_STATUS_ERROR;
QAT_DP_LOG(ERR, "Asymmetric common status"
" returned error");
}
}
if (ctx->alg == QAT_PKE_MODEXP) {
alg_size = cookie->alg_size;
alg_size_in_bytes = alg_size >> 3;
uint8_t *modexp_result = asym_op->modex.result.data;
if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) {
rte_memcpy(modexp_result +
(asym_op->modex.result.length -
ctx->sess_alg_params.mod_exp.n.length),
cookie->output_array[0] + alg_size_in_bytes
- ctx->sess_alg_params.mod_exp.n.length,
ctx->sess_alg_params.mod_exp.n.length
);
rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "modexp_result",
cookie->output_array[0],
alg_size_in_bytes);
#endif
}
qat_clear_arrays(cookie, 3, 1, alg_size_in_bytes,
alg_size_in_bytes);
} else if (ctx->alg == QAT_PKE_MODINV) {
alg_size = cookie->alg_size;
alg_size_in_bytes = alg_size >> 3;
uint8_t *modinv_result = asym_op->modinv.result.data;
if (rx_op->status == RTE_CRYPTO_OP_STATUS_NOT_PROCESSED) {
rte_memcpy(modinv_result + (asym_op->modinv.result.length
- ctx->sess_alg_params.mod_inv.n.length),
cookie->output_array[0] + alg_size_in_bytes
- ctx->sess_alg_params.mod_inv.n.length,
ctx->sess_alg_params.mod_inv.n.length);
rx_op->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "modinv_result",
cookie->output_array[0],
alg_size_in_bytes);
#endif
}
qat_clear_arrays(cookie, 2, 1, alg_size_in_bytes,
alg_size_in_bytes);
if (rx_op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
ctx = (struct qat_asym_session *)get_asym_session_private_data(
rx_op->asym->session, cryptodev_qat_asym_driver_id);
qat_asym_collect_response(rx_op, cookie, ctx->xform);
} else if (rx_op->sess_type == RTE_CRYPTO_OP_SESSIONLESS) {
qat_asym_collect_response(rx_op, cookie, rx_op->asym->xform);
}
*op = rx_op;
#if RTE_LOG_DP_LEVEL >= RTE_LOG_DEBUG
QAT_DP_HEXDUMP_LOG(DEBUG, "resp_msg:", resp_msg,
@ -362,10 +424,6 @@ qat_asym_session_configure(struct rte_cryptodev *dev,
session = sess_private_data;
if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODEX) {
session->sess_alg_params.mod_exp.e = xform->modex.exponent;
session->sess_alg_params.mod_exp.n = xform->modex.modulus;
session->alg = QAT_PKE_MODEXP;
if (xform->modex.exponent.length == 0 ||
xform->modex.modulus.length == 0) {
QAT_LOG(ERR, "Invalid mod exp input parameter");
@ -373,20 +431,24 @@ qat_asym_session_configure(struct rte_cryptodev *dev,
goto error;
}
} else if (xform->xform_type == RTE_CRYPTO_ASYM_XFORM_MODINV) {
session->sess_alg_params.mod_inv.n = xform->modinv.modulus;
session->alg = QAT_PKE_MODINV;
if (xform->modinv.modulus.length == 0) {
QAT_LOG(ERR, "Invalid mod inv input parameter");
err = -EINVAL;
goto error;
}
} else {
} else if (xform->xform_type >= RTE_CRYPTO_ASYM_XFORM_TYPE_LIST_END
|| xform->xform_type <= RTE_CRYPTO_ASYM_XFORM_NONE) {
QAT_LOG(ERR, "Invalid asymmetric crypto xform");
err = -EINVAL;
goto error;
} else {
QAT_LOG(ERR, "Asymmetric crypto xform not implemented");
err = -EINVAL;
goto error;
}
qat_asym_build_req_tmpl(sess_private_data, xform);
session->xform = xform;
qat_asym_build_req_tmpl(sess_private_data);
set_asym_session_private_data(sess, dev->driver_id,
sess_private_data);

26
drivers/crypto/qat/qat_asym.h
View File

@ -17,7 +17,11 @@ typedef uint64_t large_int_ptr;
#define QAT_PKE_MAX_LN_SIZE 512
#define _PKE_ALIGN_ __attribute__((__aligned__(8)))
#define QAT_ASYM_ERROR_INVALID_PARAM 0x01
#define QAT_ASYM_MAX_PARAMS 8
#define QAT_ASYM_MODINV_NUM_IN_PARAMS 2
#define QAT_ASYM_MODINV_NUM_OUT_PARAMS 1
#define QAT_ASYM_MODEXP_NUM_IN_PARAMS 3
#define QAT_ASYM_MODEXP_NUM_OUT_PARAMS 1
struct qat_asym_op_cookie {
size_t alg_size;
@ -33,27 +37,9 @@ struct qat_asym_op_cookie {
uint8_t output_array[MAX_PKE_PARAMS][QAT_PKE_MAX_LN_SIZE] _PKE_ALIGN_;
} _PKE_ALIGN_;
enum qat_asym_alg {
QAT_PKE_RSA,
QAT_PKE_DH,
QAT_PKE_DSA,
QAT_PKE_MODEXP,
QAT_PKE_MODINV,
};
struct qat_asym_session {
enum qat_asym_alg alg;
struct icp_qat_fw_pke_request req_tmpl;
uint64_t flags;
union {
struct {
rte_crypto_param n;
rte_crypto_param e;
} mod_exp;
struct {
rte_crypto_param n;
} mod_inv;
} sess_alg_params;
struct rte_crypto_asym_xform *xform;
};
int

3
drivers/crypto/qat/qat_asym_pmd.c
View File

@ -270,7 +270,8 @@ qat_asym_dev_create(struct qat_pci_device *qat_pci_dev)
cryptodev->dequeue_burst = qat_asym_pmd_dequeue_op_burst;
cryptodev->feature_flags = RTE_CRYPTODEV_FF_ASYMMETRIC_CRYPTO |
RTE_CRYPTODEV_FF_HW_ACCELERATED;
RTE_CRYPTODEV_FF_HW_ACCELERATED |
RTE_CRYPTODEV_FF_ASYM_SESSIONLESS;
internals = cryptodev->data->dev_private;
internals->qat_dev = qat_pci_dev;
qat_pci_dev->asym_dev = internals;