+#define ll_crypto_hash_blocksize(tfm) crypto_hash_blocksize(tfm)
+#define ll_crypto_hash_digestsize(tfm) crypto_hash_digestsize(tfm)
+#define ll_crypto_blkcipher_ivsize(tfm) crypto_blkcipher_ivsize(tfm)
+#define ll_crypto_blkcipher_blocksize(tfm) crypto_blkcipher_blocksize(tfm)
+#define ll_crypto_free_hash(tfm) crypto_free_hash(tfm)
+#define ll_crypto_free_blkcipher(tfm) crypto_free_blkcipher(tfm)
+#else /* HAVE_ASYNC_BLOCK_CIPHER */
+#include <linux/scatterlist.h>
+#define ll_crypto_hash crypto_tfm
+#define ll_crypto_cipher crypto_tfm
+#ifndef HAVE_STRUCT_HASH_DESC
+struct hash_desc {
+ struct ll_crypto_hash *tfm;
+ u32 flags;
+};
+#endif
+#ifndef HAVE_STRUCT_BLKCIPHER_DESC
+struct blkcipher_desc {
+ struct ll_crypto_cipher *tfm;
+ void *info;
+ u32 flags;
+};
+#endif
+#define ll_crypto_blkcipher_setkey(tfm, key, keylen) \
+ crypto_cipher_setkey(tfm, key, keylen)
+#define ll_crypto_blkcipher_set_iv(tfm, src, len) \
+ crypto_cipher_set_iv(tfm, src, len)
+#define ll_crypto_blkcipher_get_iv(tfm, dst, len) \
+ crypto_cipher_get_iv(tfm, dst, len)
+#define ll_crypto_blkcipher_encrypt(desc, dst, src, bytes) \
+ crypto_cipher_encrypt((desc)->tfm, dst, src, bytes)
+#define ll_crypto_blkcipher_decrypt(desc, dst, src, bytes) \
+ crypto_cipher_decrypt((desc)->tfm, dst, src, bytes)
+#define ll_crypto_blkcipher_decrypt_iv(desc, dst, src, bytes) \
+ crypto_cipher_decrypt_iv((desc)->tfm, dst, src, bytes, (desc)->info)
+#define ll_crypto_blkcipher_encrypt_iv(desc, dst, src, bytes) \
+ crypto_cipher_encrypt_iv((desc)->tfm, dst, src, bytes, (desc)->info)
+
+static inline
+struct ll_crypto_cipher *ll_crypto_alloc_blkcipher(const char * algname,
+ u32 type, u32 mask)
+{
+ struct ll_crypto_cipher *rtn;
+ char buf[CRYPTO_MAX_ALG_NAME + 1];
+ const char *pan = algname;
+ u32 flag = 0;
+
+ if (strncmp("cbc(", algname, 4) == 0)
+ flag |= CRYPTO_TFM_MODE_CBC;
+ else if (strncmp("ecb(", algname, 4) == 0)
+ flag |= CRYPTO_TFM_MODE_ECB;
+ if (flag) {
+ char *vp = strnchr(algname, CRYPTO_MAX_ALG_NAME, ')');
+ if (vp) {
+ memcpy(buf, algname + 4, vp - algname - 4);
+ buf[vp - algname - 4] = '\0';
+ pan = buf;
+ } else {
+ flag = 0;
+ }
+ }
+ rtn = crypto_alloc_tfm(pan, flag);
+ return (rtn == NULL ? ERR_PTR(-ENOMEM) : rtn);
+}
+
+static inline
+struct ll_crypto_hash *ll_crypto_alloc_hash(const char *alg, u32 type, u32 mask)
+{
+ char buf[CRYPTO_MAX_ALG_NAME + 1];
+ const char *pan = alg;
+
+ if (strncmp("hmac(", alg, 5) == 0) {
+ char *vp = strnchr(alg, CRYPTO_MAX_ALG_NAME, ')');
+ if (vp) {
+ memcpy(buf, alg+ 5, vp - alg- 5);
+ buf[vp - alg - 5] = 0x00;
+ pan = buf;
+ }
+ }
+ return crypto_alloc_tfm(pan, 0);
+}
+static inline int ll_crypto_hash_init(struct hash_desc *desc)
+{
+ crypto_digest_init(desc->tfm); return 0;
+}
+static inline int ll_crypto_hash_update(struct hash_desc *desc,
+ struct scatterlist *sg,
+ unsigned int nbytes)
+{
+ struct scatterlist *sl = sg;
+ unsigned int count;
+ /*
+ * This way is very weakness. We must ensure that
+ * the sum of sg[0..i]->length isn't greater than nbytes.
+ * In the upstream kernel the crypto_hash_update() also
+ * via the nbytes computed the count of sg[...].
+ * The old style is more safely. but it gone.
+ */
+ for (count = 0; nbytes > 0; count ++, sl ++) {
+ nbytes -= sl->length;
+ }
+ crypto_digest_update(desc->tfm, sg, count); return 0;
+}
+static inline int ll_crypto_hash_final(struct hash_desc *desc, u8 *out)
+{
+ crypto_digest_final(desc->tfm, out); return 0;
+}
+static inline int ll_crypto_hmac(struct crypto_tfm *tfm,
+ u8 *key, unsigned int *keylen,
+ struct scatterlist *sg,
+ unsigned int nbytes,
+ u8 *out)
+{
+ struct scatterlist *sl = sg;
+ int count;
+ for (count = 0; nbytes > 0; count ++, sl ++) {
+ nbytes -= sl->length;
+ }
+ crypto_hmac(tfm, key, keylen, sg, count, out);
+ return 0;
+}
+
+#define ll_crypto_hash_setkey(tfm, key, keylen) crypto_digest_setkey(tfm, key, keylen)
+#define ll_crypto_blkcipher_blocksize(tfm) crypto_tfm_alg_blocksize(tfm)
+#define ll_crypto_blkcipher_ivsize(tfm) crypto_tfm_alg_ivsize(tfm)
+#define ll_crypto_hash_digestsize(tfm) crypto_tfm_alg_digestsize(tfm)
+#define ll_crypto_hash_blocksize(tfm) crypto_tfm_alg_blocksize(tfm)
+#define ll_crypto_free_hash(tfm) crypto_free_tfm(tfm)
+#define ll_crypto_free_blkcipher(tfm) crypto_free_tfm(tfm)
+#define ll_crypto_tfm_alg_min_keysize crypto_tfm_alg_min_keysize
+#define ll_crypto_tfm_alg_max_keysize crypto_tfm_alg_max_keysize
+#endif /* HAVE_ASYNC_BLOCK_CIPHER */
+
+#ifdef HAVE_SECURITY_PLUG
+#define ll_vfs_rmdir(dir,entry,mnt) vfs_rmdir(dir,entry,mnt)
+#define ll_vfs_mkdir(inode,dir,mnt,mode) vfs_mkdir(inode,dir,mnt,mode)
+#define ll_vfs_link(old,mnt,dir,new,mnt1) vfs_link(old,mnt,dir,new,mnt1)
+#define ll_vfs_unlink(inode,entry,mnt) vfs_unlink(inode,entry,mnt)
+#define ll_vfs_mknod(dir,entry,mnt,mode,dev) \
+ vfs_mknod(dir,entry,mnt,mode,dev)
+#define ll_security_inode_unlink(dir,entry,mnt) \
+ security_inode_unlink(dir,entry,mnt)
+#define ll_vfs_rename(old,old_dir,mnt,new,new_dir,mnt1) \
+ vfs_rename(old,old_dir,mnt,new,new_dir,mnt1)
+#else
+#define ll_vfs_rmdir(dir,entry,mnt) vfs_rmdir(dir,entry)
+#define ll_vfs_mkdir(inode,dir,mnt,mode) vfs_mkdir(inode,dir,mode)
+#define ll_vfs_link(old,mnt,dir,new,mnt1) vfs_link(old,dir,new)
+#define ll_vfs_unlink(inode,entry,mnt) vfs_unlink(inode,entry)
+#define ll_vfs_mknod(dir,entry,mnt,mode,dev) vfs_mknod(dir,entry,mode,dev)
+#define ll_security_inode_unlink(dir,entry,mnt) security_inode_unlink(dir,entry)
+#define ll_vfs_rename(old,old_dir,mnt,new,new_dir,mnt1) \
+ vfs_rename(old,old_dir,new,new_dir)
+#endif /* HAVE_SECURITY_PLUG */
+
+#ifdef for_each_possible_cpu
+#define cfs_for_each_possible_cpu(cpu) for_each_possible_cpu(cpu)
+#elif defined(for_each_cpu)
+#define cfs_for_each_possible_cpu(cpu) for_each_cpu(cpu)