refactor dual checksum support.

[fs/lustre-release.git] / lustre / ptlrpc / sec_bulk.c

diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c
index c7f41f7..22ed4ff 100644 (file)
--- a/lustre/ptlrpc/sec_bulk.c
+++ b/lustre/ptlrpc/sec_bulk.c
@@ -29,13 +29,12 @@
 #ifndef __KERNEL__
 #include <liblustre.h>
 #include <libcfs/list.h>
-#include <zlib.h>
 #else
 #include <linux/crypto.h>
-#include <linux/zutil.h>
 #endif
 
 #include <obd.h>
+#include <obd_cksum.h>
 #include <obd_class.h>
 #include <obd_support.h>
 #include <lustre_net.h>
@@ -854,6 +853,7 @@ EXPORT_SYMBOL(bulk_sec_desc_unpack);
 
 #ifdef __KERNEL__
 
+#ifdef HAVE_ADLER
 static int do_bulk_checksum_adler32(struct ptlrpc_bulk_desc *desc, void *buf)
 {
         struct page    *page;
@@ -877,6 +877,7 @@ static int do_bulk_checksum_adler32(struct ptlrpc_bulk_desc *desc, void *buf)
         memcpy(buf, &adler32, sizeof(adler32));
         return 0;
 }
+#endif
 
 static int do_bulk_checksum_crc32(struct ptlrpc_bulk_desc *desc, void *buf)
 {
@@ -904,23 +905,31 @@ static int do_bulk_checksum_crc32(struct ptlrpc_bulk_desc *desc, void *buf)
 
 static int do_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u32 alg, void *buf)
 {
-        struct crypto_tfm *tfm;
+        struct hash_desc    hdesc;
         struct scatterlist *sl;
-        int i, rc = 0;
+        int i, rc = 0, bytes = 0;
 
         LASSERT(alg > BULK_HASH_ALG_NULL &&
                 alg < BULK_HASH_ALG_MAX);
 
-        if (alg == BULK_HASH_ALG_ADLER32)
+        switch (alg) {
+        case BULK_HASH_ALG_ADLER32:
+#ifdef HAVE_ADLER
                 return do_bulk_checksum_adler32(desc, buf);
-        if (alg == BULK_HASH_ALG_CRC32)
+#else
+                CERROR("Adler32 not supported\n");
+                return -EINVAL;
+#endif
+        case BULK_HASH_ALG_CRC32:
                 return do_bulk_checksum_crc32(desc, buf);
+        }
 
-        tfm = crypto_alloc_tfm(hash_types[alg].sht_tfm_name, 0);
-        if (tfm == NULL) {
+        hdesc.tfm = ll_crypto_alloc_hash(hash_types[alg].sht_tfm_name, 0, 0);
+        if (hdesc.tfm == NULL) {
                 CERROR("Unable to allocate TFM %s\n", hash_types[alg].sht_name);
                 return -ENOMEM;
         }
+        hdesc.flags = 0;
 
         OBD_ALLOC(sl, sizeof(*sl) * desc->bd_iov_count);
         if (sl == NULL) {
@@ -932,16 +941,17 @@ static int do_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u32 alg, void *buf)
                 sl[i].page = desc->bd_iov[i].kiov_page;
                 sl[i].offset = desc->bd_iov[i].kiov_offset & ~CFS_PAGE_MASK;
                 sl[i].length = desc->bd_iov[i].kiov_len;
+                bytes += desc->bd_iov[i].kiov_len;
         }
 
-        crypto_digest_init(tfm);
-        crypto_digest_update(tfm, sl, desc->bd_iov_count);
-        crypto_digest_final(tfm, buf);
+        ll_crypto_hash_init(&hdesc);
+        ll_crypto_hash_update(&hdesc, sl, bytes);
+        ll_crypto_hash_final(&hdesc, buf);
 
         OBD_FREE(sl, sizeof(*sl) * desc->bd_iov_count);
 
 out_tfm:
-        crypto_free_tfm(tfm);
+        ll_crypto_free_hash(hdesc.tfm);
         return rc;
 }
 
@@ -949,7 +959,7 @@ out_tfm:
 
 static int do_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u32 alg, void *buf)
 {
-        __u32   csum32 = ~0;
+        __u32   csum32;
         int     i;
 
         LASSERT(alg == BULK_HASH_ALG_ADLER32 || alg == BULK_HASH_ALG_CRC32);
@@ -963,17 +973,27 @@ static int do_bulk_checksum(struct ptlrpc_bulk_desc *desc, __u32 alg, void *buf)
                 char *ptr = desc->bd_iov[i].iov_base;
                 int len = desc->bd_iov[i].iov_len;
 
-                if (alg == BULK_HASH_ALG_ADLER32)
+                switch (alg) {
+                case BULK_HASH_ALG_ADLER32:
+#ifdef HAVE_ADLER
                         csum32 = zlib_adler32(csum32, ptr, len);
-                else
+#else
+                        CERROR("Adler32 not supported\n");
+                        return -EINVAL;
+#endif
+                        break;
+                case BULK_HASH_ALG_CRC32:
                         csum32 = crc32_le(csum32, ptr, len);
+                        break;
+                }
         }
 
-        *((__u32 *) buf) = csum32;
+        csum32 = cpu_to_le32(csum32);
+        memcpy(buf, &csum32, sizeof(csum32));
         return 0;
 }
 
-#endif
+#endif /* __KERNEL__ */
 
 /*
  * perform algorithm @alg checksum on @desc, store result in @buf.
@@ -1250,28 +1270,28 @@ static struct sptlrpc_ciph_type cipher_types[] = {
                 "null",         "null",       0,                   0,  0
         },
         [BULK_CIPH_ALG_ARC4]    = {
-                "arc4",         "arc4",       CRYPTO_TFM_MODE_ECB, 0,  16
+                "arc4",         "ecb(arc4)",       0, 0,  16
         },
         [BULK_CIPH_ALG_AES128]  = {
-                "aes128",       "aes",        CRYPTO_TFM_MODE_CBC, 16, 16
+                "aes128",       "cbc(aes)",        0, 16, 16
         },
         [BULK_CIPH_ALG_AES192]  = {
-                "aes192",       "aes",        CRYPTO_TFM_MODE_CBC, 16, 24
+                "aes192",       "cbc(aes)",        0, 16, 24
         },
         [BULK_CIPH_ALG_AES256]  = {
-                "aes256",       "aes",        CRYPTO_TFM_MODE_CBC, 16, 32
+                "aes256",       "cbc(aes)",        0, 16, 32
         },
         [BULK_CIPH_ALG_CAST128] = {
-                "cast128",      "cast5",      CRYPTO_TFM_MODE_CBC, 8,  16
+                "cast128",      "cbc(cast5)",      0, 8,  16
         },
         [BULK_CIPH_ALG_CAST256] = {
-                "cast256",      "cast6",      CRYPTO_TFM_MODE_CBC, 16, 32
+                "cast256",      "cbc(cast6)",      0, 16, 32
         },
         [BULK_CIPH_ALG_TWOFISH128] = {
-                "twofish128",   "twofish",    CRYPTO_TFM_MODE_CBC, 16, 16
+                "twofish128",   "cbc(twofish)",    0, 16, 16
         },
         [BULK_CIPH_ALG_TWOFISH256] = {
-                "twofish256",   "twofish",    CRYPTO_TFM_MODE_CBC, 16, 32
+                "twofish256",   "cbc(twofish)",    0, 16, 32
         },
 };