Merge master.kernel.org:/pub/scm/linux/kernel/git/herbert/crypto-2.6 (9f75e1ef) · Commits · e / devices / android_kernel_teracube_emerald

crypto/api.c

+4 −1

Original line number	Diff line number	Diff line
		@@ -215,7 +215,10 @@ int crypto_register_alg(struct crypto_alg *alg)
		if (alg->cra_alignmask & (alg->cra_alignmask + 1))
		return -EINVAL;

		if (alg->cra_alignmask > PAGE_SIZE)
		if (alg->cra_alignmask & alg->cra_blocksize)
		return -EINVAL;

		if (alg->cra_blocksize > PAGE_SIZE)
		return -EINVAL;

		down_write(&crypto_alg_sem);

crypto/hmac.c

+5 −14

Original line number	Diff line number	Diff line
		@@ -18,18 +18,15 @@
		#include <linux/mm.h>
		#include <linux/highmem.h>
		#include <linux/slab.h>
		#include <asm/scatterlist.h>
		#include <linux/scatterlist.h>
		#include "internal.h"

		static void hash_key(struct crypto_tfm tfm, u8 key, unsigned int keylen)
		{
		struct scatterlist tmp;

		tmp.page = virt_to_page(key);
		tmp.offset = offset_in_page(key);
		tmp.length = keylen;
		sg_set_buf(&tmp, key, keylen);
		crypto_digest_digest(tfm, &tmp, 1, key);

		}

		int crypto_alloc_hmac_block(struct crypto_tfm *tfm)
		@@ -69,9 +66,7 @@ void crypto_hmac_init(struct crypto_tfm tfm, u8 key, unsigned int *keylen)
		for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
		ipad[i] ^= 0x36;

		tmp.page = virt_to_page(ipad);
		tmp.offset = offset_in_page(ipad);
		tmp.length = crypto_tfm_alg_blocksize(tfm);
		sg_set_buf(&tmp, ipad, crypto_tfm_alg_blocksize(tfm));

		crypto_digest_init(tfm);
		crypto_digest_update(tfm, &tmp, 1);
		@@ -103,16 +98,12 @@ void crypto_hmac_final(struct crypto_tfm tfm, u8 key,
		for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
		opad[i] ^= 0x5c;

		tmp.page = virt_to_page(opad);
		tmp.offset = offset_in_page(opad);
		tmp.length = crypto_tfm_alg_blocksize(tfm);
		sg_set_buf(&tmp, opad, crypto_tfm_alg_blocksize(tfm));

		crypto_digest_init(tfm);
		crypto_digest_update(tfm, &tmp, 1);

		tmp.page = virt_to_page(out);
		tmp.offset = offset_in_page(out);
		tmp.length = crypto_tfm_alg_digestsize(tfm);
		sg_set_buf(&tmp, out, crypto_tfm_alg_digestsize(tfm));

		crypto_digest_update(tfm, &tmp, 1);
		crypto_digest_final(tfm, out);

crypto/tcrypt.c

+17 −39

Original line number	Diff line number	Diff line
		@@ -21,7 +21,7 @@
		#include <linux/module.h>
		#include <linux/mm.h>
		#include <linux/slab.h>
		#include <asm/scatterlist.h>
		#include <linux/scatterlist.h>
		#include <linux/string.h>
		#include <linux/crypto.h>
		#include <linux/highmem.h>
		@@ -86,7 +86,6 @@ static void hexdump(unsigned char *buf, unsigned int len)
		static void test_hash(char algo, struct hash_testvec template,
		unsigned int tcount)
		{
		char *p;
		unsigned int i, j, k, temp;
		struct scatterlist sg[8];
		char result[64];
		@@ -116,10 +115,7 @@ static void test_hash(char algo, struct hash_testvec template,
		printk("test %u:\n", i + 1);
		memset(result, 0, 64);

		p = hash_tv[i].plaintext;
		sg[0].page = virt_to_page(p);
		sg[0].offset = offset_in_page(p);
		sg[0].length = hash_tv[i].psize;
		sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);

		crypto_digest_init(tfm);
		if (tfm->crt_u.digest.dit_setkey) {
		@@ -154,10 +150,8 @@ static void test_hash(char algo, struct hash_testvec template,
		hash_tv[i].plaintext + temp,
		hash_tv[i].tap[k]);
		temp += hash_tv[i].tap[k];
		p = &xbuf[IDX[k]];
		sg[k].page = virt_to_page(p);
		sg[k].offset = offset_in_page(p);
		sg[k].length = hash_tv[i].tap[k];
		sg_set_buf(&sg[k], &xbuf[IDX[k]],
		hash_tv[i].tap[k]);
		}

		crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
		@@ -179,7 +173,6 @@ static void test_hash(char algo, struct hash_testvec template,
		static void test_hmac(char algo, struct hmac_testvec template,
		unsigned int tcount)
		{
		char *p;
		unsigned int i, j, k, temp;
		struct scatterlist sg[8];
		char result[64];
		@@ -210,11 +203,8 @@ static void test_hmac(char algo, struct hmac_testvec template,
		printk("test %u:\n", i + 1);
		memset(result, 0, sizeof (result));

		p = hmac_tv[i].plaintext;
		klen = hmac_tv[i].ksize;
		sg[0].page = virt_to_page(p);
		sg[0].offset = offset_in_page(p);
		sg[0].length = hmac_tv[i].psize;
		sg_set_buf(&sg[0], hmac_tv[i].plaintext, hmac_tv[i].psize);

		crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);

		@@ -243,10 +233,8 @@ static void test_hmac(char algo, struct hmac_testvec template,
		hmac_tv[i].plaintext + temp,
		hmac_tv[i].tap[k]);
		temp += hmac_tv[i].tap[k];
		p = &xbuf[IDX[k]];
		sg[k].page = virt_to_page(p);
		sg[k].offset = offset_in_page(p);
		sg[k].length = hmac_tv[i].tap[k];
		sg_set_buf(&sg[k], &xbuf[IDX[k]],
		hmac_tv[i].tap[k]);
		}

		crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
		@@ -270,7 +258,7 @@ static void test_cipher(char *algo, int mode, int enc,
		{
		unsigned int ret, i, j, k, temp;
		unsigned int tsize;
		char p, q;
		char *q;
		struct crypto_tfm *tfm;
		char *key;
		struct cipher_testvec *cipher_tv;
		@@ -330,10 +318,8 @@ static void test_cipher(char *algo, int mode, int enc,
		goto out;
		}

		p = cipher_tv[i].input;
		sg[0].page = virt_to_page(p);
		sg[0].offset = offset_in_page(p);
		sg[0].length = cipher_tv[i].ilen;
		sg_set_buf(&sg[0], cipher_tv[i].input,
		cipher_tv[i].ilen);

		if (!mode) {
		crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
		@@ -389,10 +375,8 @@ static void test_cipher(char *algo, int mode, int enc,
		cipher_tv[i].input + temp,
		cipher_tv[i].tap[k]);
		temp += cipher_tv[i].tap[k];
		p = &xbuf[IDX[k]];
		sg[k].page = virt_to_page(p);
		sg[k].offset = offset_in_page(p);
		sg[k].length = cipher_tv[i].tap[k];
		sg_set_buf(&sg[k], &xbuf[IDX[k]],
		cipher_tv[i].tap[k]);
		}

		if (!mode) {
		@@ -431,14 +415,12 @@ static void test_cipher(char *algo, int mode, int enc,
		static int test_cipher_jiffies(struct crypto_tfm tfm, int enc, char p,
		int blen, int sec)
		{
		struct scatterlist sg[8];
		struct scatterlist sg[1];
		unsigned long start, end;
		int bcount;
		int ret;

		sg[0].page = virt_to_page(p);
		sg[0].offset = offset_in_page(p);
		sg[0].length = blen;
		sg_set_buf(sg, p, blen);

		for (start = jiffies, end = start + sec * HZ, bcount = 0;
		time_before(jiffies, end); bcount++) {
		@@ -459,14 +441,12 @@ static int test_cipher_jiffies(struct crypto_tfm tfm, int enc, char p,
		static int test_cipher_cycles(struct crypto_tfm tfm, int enc, char p,
		int blen)
		{
		struct scatterlist sg[8];
		struct scatterlist sg[1];
		unsigned long cycles = 0;
		int ret = 0;
		int i;

		sg[0].page = virt_to_page(p);
		sg[0].offset = offset_in_page(p);
		sg[0].length = blen;
		sg_set_buf(sg, p, blen);

		local_bh_disable();
		local_irq_disable();
		@@ -709,9 +689,7 @@ static void test_crc32c(void)
		for (i = 0; i < NUMVEC; i++) {
		for (j = 0; j < VECSIZE; j++)
		test_vec[i][j] = ++b;
		sg[i].page = virt_to_page(test_vec[i]);
		sg[i].offset = offset_in_page(test_vec[i]);
		sg[i].length = VECSIZE;
		sg_set_buf(&sg[i], test_vec[i], VECSIZE);
		}

		seed = SEEDTESTVAL;

drivers/md/dm-crypt.c

+4 −8

Original line number	Diff line number	Diff line
		@@ -15,7 +15,7 @@
		#include <linux/crypto.h>
		#include <linux/workqueue.h>
		#include <asm/atomic.h>
		#include <asm/scatterlist.h>
		#include <linux/scatterlist.h>
		#include <asm/page.h>

		#include "dm.h"
		@@ -164,9 +164,7 @@ static int crypt_iv_essiv_ctr(struct crypt_config cc, struct dm_target ti,
		return -ENOMEM;
		}

		sg.page = virt_to_page(cc->key);
		sg.offset = offset_in_page(cc->key);
		sg.length = cc->key_size;
		sg_set_buf(&sg, cc->key, cc->key_size);
		crypto_digest_digest(hash_tfm, &sg, 1, salt);
		crypto_free_tfm(hash_tfm);

		@@ -207,14 +205,12 @@ static void crypt_iv_essiv_dtr(struct crypt_config *cc)

		static int crypt_iv_essiv_gen(struct crypt_config cc, u8 iv, sector_t sector)
		{
		struct scatterlist sg = { NULL, };
		struct scatterlist sg;

		memset(iv, 0, cc->iv_size);
		(u64 )iv = cpu_to_le64(sector);

		sg.page = virt_to_page(iv);
		sg.offset = offset_in_page(iv);
		sg.length = cc->iv_size;
		sg_set_buf(&sg, iv, cc->iv_size);
		crypto_cipher_encrypt((struct crypto_tfm *)cc->iv_gen_private,
		&sg, &sg, cc->iv_size);

drivers/net/wireless/airo.c

+3 −4

Original line number	Diff line number	Diff line
		@@ -35,6 +35,7 @@
		#include <linux/interrupt.h>
		#include <linux/in.h>
		#include <linux/bitops.h>
		#include <linux/scatterlist.h>
		#include <asm/io.h>
		#include <asm/system.h>

		@@ -1590,11 +1591,9 @@ static void emmh32_setseed(emmh32_context context, u8 pkey, int keylen, struct
		aes_counter[12] = (u8)(counter >> 24);
		counter++;
		memcpy (plain, aes_counter, 16);
		sg[0].page = virt_to_page(plain);
		sg[0].offset = ((long) plain & ~PAGE_MASK);
		sg[0].length = 16;
		sg_set_buf(sg, plain, 16);
		crypto_cipher_encrypt(tfm, sg, sg, 16);
		cipher = kmap(sg[0].page) + sg[0].offset;
		cipher = kmap(sg->page) + sg->offset;
		for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {
		context->coeff[i++] = ntohl((u32 )&cipher[j]);
		j += 4;