crypto/zuc: do not append digest

[dpdk.git] / drivers / crypto / zuc / rte_zuc_pmd.c

diff --git a/drivers/crypto/zuc/rte_zuc_pmd.c b/drivers/crypto/zuc/rte_zuc_pmd.c
index 951f1f4..f1f9291 100644 (file)
--- a/drivers/crypto/zuc/rte_zuc_pmd.c
+++ b/drivers/crypto/zuc/rte_zuc_pmd.c
@@ -42,7 +42,6 @@
 
 #include "rte_zuc_pmd_private.h"
 
-#define ZUC_DIGEST_LENGTH 4
 #define ZUC_MAX_BURST 8
 #define BYTE_LEN 8
 
@@ -110,13 +109,13 @@ zuc_set_session_parameters(struct zuc_session *sess,
        case ZUC_OP_NOT_SUPPORTED:
        default:
                ZUC_LOG_ERR("Unsupported operation chain order parameter");
-               return -EINVAL;
+               return -ENOTSUP;
        }
 
        if (cipher_xform) {
                /* Only ZUC EEA3 supported */
                if (cipher_xform->cipher.algo != RTE_CRYPTO_CIPHER_ZUC_EEA3)
-                       return -EINVAL;
+                       return -ENOTSUP;
 
                if (cipher_xform->cipher.iv.length != ZUC_IV_KEY_LENGTH) {
                        ZUC_LOG_ERR("Wrong IV length");
@@ -132,7 +131,7 @@ zuc_set_session_parameters(struct zuc_session *sess,
        if (auth_xform) {
                /* Only ZUC EIA3 supported */
                if (auth_xform->auth.algo != RTE_CRYPTO_AUTH_ZUC_EIA3)
-                       return -EINVAL;
+                       return -ENOTSUP;
 
                if (auth_xform->auth.digest_length != ZUC_DIGEST_LENGTH) {
                        ZUC_LOG_ERR("Wrong digest length");
@@ -162,23 +161,40 @@ zuc_set_session_parameters(struct zuc_session *sess,
 static struct zuc_session *
 zuc_get_session(struct zuc_qp *qp, struct rte_crypto_op *op)
 {
-       struct zuc_session *sess;
+       struct zuc_session *sess = NULL;
 
        if (op->sess_type == RTE_CRYPTO_OP_WITH_SESSION) {
-               sess = (struct zuc_session *)op->sym->session->_private;
-       } else  {
-               struct rte_cryptodev_sym_session *c_sess = NULL;
+               if (likely(op->sym->session != NULL))
+                       sess = (struct zuc_session *)get_session_private_data(
+                                       op->sym->session,
+                                       cryptodev_driver_id);
+       } else {
+               void *_sess = NULL;
+               void *_sess_private_data = NULL;
+
+               if (rte_mempool_get(qp->sess_mp, (void **)&_sess))
+                       return NULL;
 
-               if (rte_mempool_get(qp->sess_mp, (void **)&c_sess))
+               if (rte_mempool_get(qp->sess_mp, (void **)&_sess_private_data))
                        return NULL;
 
-               sess = (struct zuc_session *)c_sess->_private;
+               sess = (struct zuc_session *)_sess_private_data;
 
                if (unlikely(zuc_set_session_parameters(sess,
-                               op->sym->xform) != 0))
-                       return NULL;
+                               op->sym->xform) != 0)) {
+                       rte_mempool_put(qp->sess_mp, _sess);
+                       rte_mempool_put(qp->sess_mp, _sess_private_data);
+                       sess = NULL;
+               }
+               op->sym->session = (struct rte_cryptodev_sym_session *)_sess;
+               set_session_private_data(op->sym->session, cryptodev_driver_id,
+                       _sess_private_data);
        }
 
+       if (unlikely(sess == NULL))
+               op->status = RTE_CRYPTO_OP_STATUS_INVALID_SESSION;
+
+
        return sess;
 }
 
@@ -241,7 +257,7 @@ process_zuc_cipher_op(struct rte_crypto_op **ops,
 
 /** Generate/verify hash from mbufs with same hash key. */
 static int
-process_zuc_hash_op(struct rte_crypto_op **ops,
+process_zuc_hash_op(struct zuc_qp *qp, struct rte_crypto_op **ops,
                struct zuc_session *session,
                uint8_t num_ops)
 {
@@ -268,8 +284,7 @@ process_zuc_hash_op(struct rte_crypto_op **ops,
                                session->auth_iv_offset);
 
                if (session->auth_op == RTE_CRYPTO_AUTH_OP_VERIFY) {
-                       dst = (uint32_t *)rte_pktmbuf_append(ops[i]->sym->m_src,
-                                       ZUC_DIGEST_LENGTH);
+                       dst = (uint32_t *)qp->temp_digest;
 
                        sso_zuc_eia3_1_buffer(session->pKey_hash,
                                        iv, src,
@@ -278,10 +293,6 @@ process_zuc_hash_op(struct rte_crypto_op **ops,
                        if (memcmp(dst, ops[i]->sym->auth.digest.data,
                                        ZUC_DIGEST_LENGTH) != 0)
                                ops[i]->status = RTE_CRYPTO_OP_STATUS_AUTH_FAILED;
-
-                       /* Trim area used for digest from mbuf. */
-                       rte_pktmbuf_trim(ops[i]->sym->m_src,
-                                       ZUC_DIGEST_LENGTH);
                } else  {
                        dst = (uint32_t *)ops[i]->sym->auth.digest.data;
 
@@ -310,16 +321,16 @@ process_ops(struct rte_crypto_op **ops, struct zuc_session *session,
                                session, num_ops);
                break;
        case ZUC_OP_ONLY_AUTH:
-               processed_ops = process_zuc_hash_op(ops, session,
+               processed_ops = process_zuc_hash_op(qp, ops, session,
                                num_ops);
                break;
        case ZUC_OP_CIPHER_AUTH:
                processed_ops = process_zuc_cipher_op(ops, session,
                                num_ops);
-               process_zuc_hash_op(ops, session, processed_ops);
+               process_zuc_hash_op(qp, ops, session, processed_ops);
                break;
        case ZUC_OP_AUTH_CIPHER:
-               processed_ops = process_zuc_hash_op(ops, session,
+               processed_ops = process_zuc_hash_op(qp, ops, session,
                                num_ops);
                process_zuc_cipher_op(ops, session, processed_ops);
                break;
@@ -337,6 +348,10 @@ process_ops(struct rte_crypto_op **ops, struct zuc_session *session,
                        ops[i]->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
                /* Free session if a session-less crypto op. */
                if (ops[i]->sess_type == RTE_CRYPTO_OP_SESSIONLESS) {
+                       memset(session, 0, sizeof(struct zuc_session));
+                       memset(ops[i]->sym->session, 0,
+                                       rte_cryptodev_get_header_session_size());
+                       rte_mempool_put(qp->sess_mp, session);
                        rte_mempool_put(qp->sess_mp, ops[i]->sym->session);
                        ops[i]->sym->session = NULL;
                }
@@ -544,9 +559,12 @@ static struct rte_vdev_driver cryptodev_zuc_pmd_drv = {
        .remove = cryptodev_zuc_remove
 };
 
+static struct cryptodev_driver zuc_crypto_drv;
+
 RTE_PMD_REGISTER_VDEV(CRYPTODEV_NAME_ZUC_PMD, cryptodev_zuc_pmd_drv);
 RTE_PMD_REGISTER_PARAM_STRING(CRYPTODEV_NAME_ZUC_PMD,
        "max_nb_queue_pairs=<int> "
        "max_nb_sessions=<int> "
        "socket_id=<int>");
-RTE_PMD_REGISTER_CRYPTO_DRIVER(cryptodev_zuc_pmd_drv, cryptodev_driver_id);
+RTE_PMD_REGISTER_CRYPTO_DRIVER(zuc_crypto_drv, cryptodev_zuc_pmd_drv,
+               cryptodev_driver_id);