LU-8602 gss: get rid of cfs_crypto_hash_desc

[fs/lustre-release.git] / libcfs / libcfs / linux / linux-crypto.c

diff --git a/libcfs/libcfs/linux/linux-crypto.c b/libcfs/libcfs/linux/linux-crypto.c
index 4aab16e..dce1734 100644 (file)
--- a/libcfs/libcfs/linux/linux-crypto.c
+++ b/libcfs/libcfs/linux/linux-crypto.c
@@ -207,10 +207,10 @@ EXPORT_SYMBOL(cfs_crypto_hash_digest);
  *                     use default initial value
  * \param[in] key_len  length of \a key in bytes
  *
- * \retval             pointer to descriptor of hash instance
+ * \retval             pointer to ahash request
  * \retval             ERR_PTR(errno) in case of error
  */
-struct cfs_crypto_hash_desc *
+struct ahash_request *
        cfs_crypto_hash_init(enum cfs_crypto_hash_alg hash_alg,
                             unsigned char *key, unsigned int key_len)
 {
@@ -221,14 +221,14 @@ struct cfs_crypto_hash_desc *
        err = cfs_crypto_hash_alloc(hash_alg, &type, &req, key, key_len);
        if (err)
                return ERR_PTR(err);
-       return (struct cfs_crypto_hash_desc *)req;
+       return req;
 }
 EXPORT_SYMBOL(cfs_crypto_hash_init);
 
 /**
  * Update hash digest computed on data within the given \a page
  *
- * \param[in] hdesc    hash state descriptor
+ * \param[in] req      ahash request
  * \param[in] page     data page on which to compute the hash
  * \param[in] offset   offset within \a page at which to start hash
  * \param[in] len      length of data on which to compute hash
@@ -236,11 +236,10 @@ EXPORT_SYMBOL(cfs_crypto_hash_init);
  * \retval             0 for success
  * \retval             negative errno on failure
  */
-int cfs_crypto_hash_update_page(struct cfs_crypto_hash_desc *hdesc,
+int cfs_crypto_hash_update_page(struct ahash_request *req,
                                struct page *page, unsigned int offset,
                                unsigned int len)
 {
-       struct ahash_request *req = (void *)hdesc;
        struct scatterlist sl;
 
        sg_init_table(&sl, 1);
@@ -254,17 +253,16 @@ EXPORT_SYMBOL(cfs_crypto_hash_update_page);
 /**
  * Update hash digest computed on the specified data
  *
- * \param[in] hdesc    hash state descriptor
+ * \param[in] req      ahash request
  * \param[in] buf      data buffer on which to compute the hash
  * \param[in] buf_len  length of \buf on which to compute hash
  *
  * \retval             0 for success
  * \retval             negative errno on failure
  */
-int cfs_crypto_hash_update(struct cfs_crypto_hash_desc *hdesc,
+int cfs_crypto_hash_update(struct ahash_request *req,
                           const void *buf, unsigned int buf_len)
 {
-       struct ahash_request *req = (void *)hdesc;
        struct scatterlist sl;
 
        sg_init_one(&sl, (void *)buf, buf_len);
@@ -277,7 +275,7 @@ EXPORT_SYMBOL(cfs_crypto_hash_update);
 /**
  * Finish hash calculation, copy hash digest to buffer, clean up hash descriptor
  *
- * \param[in]  hdesc           hash descriptor
+ * \param[in]  req             ahash request
  * \param[out] hash            pointer to hash buffer to store hash digest
  * \param[in,out] hash_len     pointer to hash buffer size, if \a hash == NULL
  *                             or hash_len == NULL only free \a hdesc instead
@@ -287,10 +285,9 @@ EXPORT_SYMBOL(cfs_crypto_hash_update);
  * \retval             -EOVERFLOW if hash_len is too small for the hash digest
  * \retval             negative errno for other errors from lower layers
  */
-int cfs_crypto_hash_final(struct cfs_crypto_hash_desc *hdesc,
+int cfs_crypto_hash_final(struct ahash_request *req,
                          unsigned char *hash, unsigned int *hash_len)
 {
-       struct ahash_request *req = (void *)hdesc;
        int size = crypto_ahash_digestsize(crypto_ahash_reqtfm(req));
        int err;
 
@@ -355,23 +352,23 @@ static void cfs_crypto_performance_test(enum cfs_crypto_hash_alg hash_alg)
 
        for (start = jiffies, end = start + msecs_to_jiffies(MSEC_PER_SEC / 4),
             bcount = 0; time_before(jiffies, end) && err == 0; bcount++) {
-               struct cfs_crypto_hash_desc *hdesc;
+               struct ahash_request *req;
                int i;
 
-               hdesc = cfs_crypto_hash_init(hash_alg, NULL, 0);
-               if (IS_ERR(hdesc)) {
-                       err = PTR_ERR(hdesc);
+               req = cfs_crypto_hash_init(hash_alg, NULL, 0);
+               if (IS_ERR(req)) {
+                       err = PTR_ERR(req);
                        break;
                }
 
                for (i = 0; i < buf_len / PAGE_SIZE; i++) {
-                       err = cfs_crypto_hash_update_page(hdesc, page, 0,
+                       err = cfs_crypto_hash_update_page(req, page, 0,
                                                          PAGE_SIZE);
                        if (err != 0)
                                break;
                }
 
-               err = cfs_crypto_hash_final(hdesc, hash, &hash_len);
+               err = cfs_crypto_hash_final(req, hash, &hash_len);
                if (err != 0)
                        break;
        }