PWN-Hunter/android_kernel_xiaomi_sdm845
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6

Browse Source
This commit is contained in:
Linus Torvalds 2005-06-22 23:11:50 -07:00
commit 060de20e82
17 changed files with 919 additions and 480 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

578
crypto/tcrypt.c
View File

@ -1,4 +1,4 @@
/* /*
* Quick & dirty crypto testing module. * Quick & dirty crypto testing module.
* *
* This will only exist until we have a better testing mechanism * This will only exist until we have a better testing mechanism
@ -9,11 +9,12 @@
* *
* This program is free software; you can redistribute it and/or modify it * This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free * under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option) * Software Foundation; either version 2 of the License, or (at your option)
* any later version. * any later version.
* *
* 14 - 09 - 2003 * 2004-08-09 Added cipher speed tests (Reyk Floeter <reyk@vantronix.net>)
* Rewritten by Kartikey Mahendra Bhatt * 2003-09-14 Rewritten by Kartikey Mahendra Bhatt
*
*/ */
#include <linux/init.h> #include <linux/init.h>
@ -25,12 +26,15 @@
#include <linux/crypto.h> #include <linux/crypto.h>
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <linux/jiffies.h>
#include <linux/timex.h>
#include <linux/interrupt.h>
#include "tcrypt.h" #include "tcrypt.h"
/* /*
* Need to kmalloc() memory for testing kmap(). * Need to kmalloc() memory for testing kmap().
*/ */
#define TVMEMSIZE 4096 #define TVMEMSIZE 16384
#define XBUFSIZE 32768 #define XBUFSIZE 32768
/* /*
@ -55,19 +59,23 @@
static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 }; static unsigned int IDX[8] = { IDX1, IDX2, IDX3, IDX4, IDX5, IDX6, IDX7, IDX8 };
/*
* Used by test_cipher_speed()
*/
static unsigned int sec;
static int mode; static int mode;
static char *xbuf; static char *xbuf;
static char *tvmem; static char *tvmem;
static char *check[] = { static char *check[] = {
"des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish", "des", "md5", "des3_ede", "rot13", "sha1", "sha256", "blowfish",
"twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6", "twofish", "serpent", "sha384", "sha512", "md4", "aes", "cast6",
"arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea", "arc4", "michael_mic", "deflate", "crc32c", "tea", "xtea",
"khazad", "wp512", "wp384", "wp256", "tnepres", NULL "khazad", "wp512", "wp384", "wp256", "tnepres", NULL
}; };
static void static void hexdump(unsigned char *buf, unsigned int len)
hexdump(unsigned char *buf, unsigned int len)
{ {
while (len--) while (len--)
printk("%02x", *buf++); printk("%02x", *buf++);
@ -75,29 +83,29 @@ hexdump(unsigned char *buf, unsigned int len)
printk("\n"); printk("\n");
} }
static void static void test_hash(char *algo, struct hash_testvec *template,
test_hash (char * algo, struct hash_testvec * template, unsigned int tcount) unsigned int tcount)
{ {
char *p; char *p;
unsigned int i, j, k, temp; unsigned int i, j, k, temp;
struct scatterlist sg[8]; struct scatterlist sg[8];
char result[64]; char result[64];
struct crypto_tfm *tfm; struct crypto_tfm *tfm;
struct hash_testvec *hash_tv; struct hash_testvec *hash_tv;
unsigned int tsize; unsigned int tsize;
printk("\ntesting %s\n", algo);
tsize = sizeof (struct hash_testvec); printk("\ntesting %s\n", algo);
tsize = sizeof(struct hash_testvec);
tsize *= tcount; tsize *= tcount;
if (tsize > TVMEMSIZE) { if (tsize > TVMEMSIZE) {
printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE); printk("template (%u) too big for tvmem (%u)\n", tsize, TVMEMSIZE);
return; return;
} }
memcpy(tvmem, template, tsize); memcpy(tvmem, template, tsize);
hash_tv = (void *) tvmem; hash_tv = (void *)tvmem;
tfm = crypto_alloc_tfm(algo, 0); tfm = crypto_alloc_tfm(algo, 0);
if (tfm == NULL) { if (tfm == NULL) {
printk("failed to load transform for %s\n", algo); printk("failed to load transform for %s\n", algo);
@ -105,70 +113,71 @@ test_hash (char * algo, struct hash_testvec * template, unsigned int tcount)
} }
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
printk ("test %u:\n", i + 1); printk("test %u:\n", i + 1);
memset (result, 0, 64); memset(result, 0, 64);
p = hash_tv[i].plaintext; p = hash_tv[i].plaintext;
sg[0].page = virt_to_page (p); sg[0].page = virt_to_page(p);
sg[0].offset = offset_in_page (p); sg[0].offset = offset_in_page(p);
sg[0].length = hash_tv[i].psize; sg[0].length = hash_tv[i].psize;
crypto_digest_init (tfm); crypto_digest_init(tfm);
if (tfm->crt_u.digest.dit_setkey) { if (tfm->crt_u.digest.dit_setkey) {
crypto_digest_setkey (tfm, hash_tv[i].key, crypto_digest_setkey(tfm, hash_tv[i].key,
hash_tv[i].ksize); hash_tv[i].ksize);
} }
crypto_digest_update (tfm, sg, 1); crypto_digest_update(tfm, sg, 1);
crypto_digest_final (tfm, result); crypto_digest_final(tfm, result);
hexdump (result, crypto_tfm_alg_digestsize (tfm)); hexdump(result, crypto_tfm_alg_digestsize(tfm));
printk("%s\n", printk("%s\n",
memcmp(result, hash_tv[i].digest, memcmp(result, hash_tv[i].digest,
crypto_tfm_alg_digestsize(tfm)) ? "fail" : crypto_tfm_alg_digestsize(tfm)) ?
"pass"); "fail" : "pass");
} }
printk ("testing %s across pages\n", algo); printk("testing %s across pages\n", algo);
/* setup the dummy buffer first */ /* setup the dummy buffer first */
memset(xbuf, 0, XBUFSIZE); memset(xbuf, 0, XBUFSIZE);
j = 0; j = 0;
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
if (hash_tv[i].np) { if (hash_tv[i].np) {
j++; j++;
printk ("test %u:\n", j); printk("test %u:\n", j);
memset (result, 0, 64); memset(result, 0, 64);
temp = 0; temp = 0;
for (k = 0; k < hash_tv[i].np; k++) { for (k = 0; k < hash_tv[i].np; k++) {
memcpy (&xbuf[IDX[k]], hash_tv[i].plaintext + temp, memcpy(&xbuf[IDX[k]],
hash_tv[i].tap[k]); hash_tv[i].plaintext + temp,
hash_tv[i].tap[k]);
temp += hash_tv[i].tap[k]; temp += hash_tv[i].tap[k];
p = &xbuf[IDX[k]]; p = &xbuf[IDX[k]];
sg[k].page = virt_to_page (p); sg[k].page = virt_to_page(p);
sg[k].offset = offset_in_page (p); sg[k].offset = offset_in_page(p);
sg[k].length = hash_tv[i].tap[k]; sg[k].length = hash_tv[i].tap[k];
} }
crypto_digest_digest (tfm, sg, hash_tv[i].np, result); crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
hexdump (result, crypto_tfm_alg_digestsize (tfm)); hexdump(result, crypto_tfm_alg_digestsize(tfm));
printk("%s\n", printk("%s\n",
memcmp(result, hash_tv[i].digest, memcmp(result, hash_tv[i].digest,
crypto_tfm_alg_digestsize(tfm)) ? "fail" : crypto_tfm_alg_digestsize(tfm)) ?
"pass"); "fail" : "pass");
} }
} }
crypto_free_tfm (tfm); crypto_free_tfm(tfm);
} }
#ifdef CONFIG_CRYPTO_HMAC #ifdef CONFIG_CRYPTO_HMAC
static void static void test_hmac(char *algo, struct hmac_testvec *template,
test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount) unsigned int tcount)
{ {
char *p; char *p;
unsigned int i, j, k, temp; unsigned int i, j, k, temp;
@ -185,8 +194,8 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
} }
printk("\ntesting hmac_%s\n", algo); printk("\ntesting hmac_%s\n", algo);
tsize = sizeof (struct hmac_testvec); tsize = sizeof(struct hmac_testvec);
tsize *= tcount; tsize *= tcount;
if (tsize > TVMEMSIZE) { if (tsize > TVMEMSIZE) {
printk("template (%u) too big for tvmem (%u)\n", tsize, printk("template (%u) too big for tvmem (%u)\n", tsize,
@ -195,7 +204,7 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
} }
memcpy(tvmem, template, tsize); memcpy(tvmem, template, tsize);
hmac_tv = (void *) tvmem; hmac_tv = (void *)tvmem;
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
printk("test %u:\n", i + 1); printk("test %u:\n", i + 1);
@ -219,34 +228,35 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
printk("\ntesting hmac_%s across pages\n", algo); printk("\ntesting hmac_%s across pages\n", algo);
memset(xbuf, 0, XBUFSIZE); memset(xbuf, 0, XBUFSIZE);
j = 0; j = 0;
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
if (hmac_tv[i].np) { if (hmac_tv[i].np) {
j++; j++;
printk ("test %u:\n",j); printk("test %u:\n",j);
memset (result, 0, 64); memset(result, 0, 64);
temp = 0; temp = 0;
klen = hmac_tv[i].ksize; klen = hmac_tv[i].ksize;
for (k = 0; k < hmac_tv[i].np; k++) { for (k = 0; k < hmac_tv[i].np; k++) {
memcpy (&xbuf[IDX[k]], hmac_tv[i].plaintext + temp, memcpy(&xbuf[IDX[k]],
hmac_tv[i].tap[k]); hmac_tv[i].plaintext + temp,
hmac_tv[i].tap[k]);
temp += hmac_tv[i].tap[k]; temp += hmac_tv[i].tap[k];
p = &xbuf[IDX[k]]; p = &xbuf[IDX[k]];
sg[k].page = virt_to_page (p); sg[k].page = virt_to_page(p);
sg[k].offset = offset_in_page (p); sg[k].offset = offset_in_page(p);
sg[k].length = hmac_tv[i].tap[k]; sg[k].length = hmac_tv[i].tap[k];
} }
crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, hmac_tv[i].np, crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
result); hmac_tv[i].np, result);
hexdump(result, crypto_tfm_alg_digestsize(tfm)); hexdump(result, crypto_tfm_alg_digestsize(tfm));
printk("%s\n", printk("%s\n",
memcmp(result, hmac_tv[i].digest, memcmp(result, hmac_tv[i].digest,
crypto_tfm_alg_digestsize(tfm)) ? "fail" : crypto_tfm_alg_digestsize(tfm)) ?
"pass"); "fail" : "pass");
} }
} }
out: out:
@ -255,8 +265,8 @@ test_hmac(char *algo, struct hmac_testvec * template, unsigned int tcount)
#endif /* CONFIG_CRYPTO_HMAC */ #endif /* CONFIG_CRYPTO_HMAC */
static void static void test_cipher(char *algo, int mode, int enc,
test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, unsigned int tcount) struct cipher_testvec *template, unsigned int tcount)
{ {
unsigned int ret, i, j, k, temp; unsigned int ret, i, j, k, temp;
unsigned int tsize; unsigned int tsize;
@ -265,22 +275,22 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
char *key; char *key;
struct cipher_testvec *cipher_tv; struct cipher_testvec *cipher_tv;
struct scatterlist sg[8]; struct scatterlist sg[8];
char e[11], m[4]; const char *e, *m;
if (enc == ENCRYPT) if (enc == ENCRYPT)
strncpy(e, "encryption", 11); e = "encryption";
else else
strncpy(e, "decryption", 11); e = "decryption";
if (mode == MODE_ECB) if (mode == MODE_ECB)
strncpy(m, "ECB", 4); m = "ECB";
else else
strncpy(m, "CBC", 4); m = "CBC";
printk("\ntesting %s %s %s \n", algo, m, e); printk("\ntesting %s %s %s\n", algo, m, e);
tsize = sizeof (struct cipher_testvec); tsize = sizeof (struct cipher_testvec);
tsize *= tcount; tsize *= tcount;
if (tsize > TVMEMSIZE) { if (tsize > TVMEMSIZE) {
printk("template (%u) too big for tvmem (%u)\n", tsize, printk("template (%u) too big for tvmem (%u)\n", tsize,
TVMEMSIZE); TVMEMSIZE);
@ -288,112 +298,113 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
} }
memcpy(tvmem, template, tsize); memcpy(tvmem, template, tsize);
cipher_tv = (void *) tvmem; cipher_tv = (void *)tvmem;
if (mode)
tfm = crypto_alloc_tfm(algo, 0);
else
tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
if (mode)
tfm = crypto_alloc_tfm (algo, 0);
else
tfm = crypto_alloc_tfm (algo, CRYPTO_TFM_MODE_CBC);
if (tfm == NULL) { if (tfm == NULL) {
printk("failed to load transform for %s %s\n", algo, m); printk("failed to load transform for %s %s\n", algo, m);
return; return;
} }
j = 0; j = 0;
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
if (!(cipher_tv[i].np)) { if (!(cipher_tv[i].np)) {
j++; j++;
printk("test %u (%d bit key):\n", printk("test %u (%d bit key):\n",
j, cipher_tv[i].klen * 8); j, cipher_tv[i].klen * 8);
tfm->crt_flags = 0; tfm->crt_flags = 0;
if (cipher_tv[i].wk) if (cipher_tv[i].wk)
tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
key = cipher_tv[i].key; key = cipher_tv[i].key;
ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
if (ret) { if (ret) {
printk("setkey() failed flags=%x\n", tfm->crt_flags); printk("setkey() failed flags=%x\n", tfm->crt_flags);
if (!cipher_tv[i].fail) if (!cipher_tv[i].fail)
goto out; goto out;
} }
p = cipher_tv[i].input; p = cipher_tv[i].input;
sg[0].page = virt_to_page(p); sg[0].page = virt_to_page(p);
sg[0].offset = offset_in_page(p); sg[0].offset = offset_in_page(p);
sg[0].length = cipher_tv[i].ilen; sg[0].length = cipher_tv[i].ilen;
if (!mode) { if (!mode) {
crypto_cipher_set_iv(tfm, cipher_tv[i].iv, crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
crypto_tfm_alg_ivsize (tfm)); crypto_tfm_alg_ivsize(tfm));
} }
if (enc) if (enc)
ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
else else
ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
if (ret) { if (ret) {
printk("%s () failed flags=%x\n", e, tfm->crt_flags); printk("%s () failed flags=%x\n", e, tfm->crt_flags);
goto out; goto out;
} }
q = kmap(sg[0].page) + sg[0].offset; q = kmap(sg[0].page) + sg[0].offset;
hexdump(q, cipher_tv[i].rlen); hexdump(q, cipher_tv[i].rlen);
printk("%s\n", printk("%s\n",
memcmp(q, cipher_tv[i].result, cipher_tv[i].rlen) ? "fail" : memcmp(q, cipher_tv[i].result,
"pass"); cipher_tv[i].rlen) ? "fail" : "pass");
} }
} }
printk("\ntesting %s %s %s across pages (chunking) \n", algo, m, e); printk("\ntesting %s %s %s across pages (chunking)\n", algo, m, e);
memset(xbuf, 0, XBUFSIZE); memset(xbuf, 0, XBUFSIZE);
j = 0; j = 0;
for (i = 0; i < tcount; i++) { for (i = 0; i < tcount; i++) {
if (cipher_tv[i].np) { if (cipher_tv[i].np) {
j++; j++;
printk("test %u (%d bit key):\n", printk("test %u (%d bit key):\n",
j, cipher_tv[i].klen * 8); j, cipher_tv[i].klen * 8);
tfm->crt_flags = 0; tfm->crt_flags = 0;
if (cipher_tv[i].wk) if (cipher_tv[i].wk)
tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY; tfm->crt_flags |= CRYPTO_TFM_REQ_WEAK_KEY;
key = cipher_tv[i].key; key = cipher_tv[i].key;
ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen); ret = crypto_cipher_setkey(tfm, key, cipher_tv[i].klen);
if (ret) { if (ret) {
printk("setkey() failed flags=%x\n", tfm->crt_flags); printk("setkey() failed flags=%x\n", tfm->crt_flags);
if (!cipher_tv[i].fail) if (!cipher_tv[i].fail)
goto out; goto out;
} }
temp = 0; temp = 0;
for (k = 0; k < cipher_tv[i].np; k++) { for (k = 0; k < cipher_tv[i].np; k++) {
memcpy (&xbuf[IDX[k]], cipher_tv[i].input + temp, memcpy(&xbuf[IDX[k]],
cipher_tv[i].tap[k]); cipher_tv[i].input + temp,
cipher_tv[i].tap[k]);
temp += cipher_tv[i].tap[k]; temp += cipher_tv[i].tap[k];
p = &xbuf[IDX[k]]; p = &xbuf[IDX[k]];
sg[k].page = virt_to_page (p); sg[k].page = virt_to_page(p);
sg[k].offset = offset_in_page (p); sg[k].offset = offset_in_page(p);
sg[k].length = cipher_tv[i].tap[k]; sg[k].length = cipher_tv[i].tap[k];
} }
if (!mode) { if (!mode) {
crypto_cipher_set_iv(tfm, cipher_tv[i].iv, crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
crypto_tfm_alg_ivsize (tfm)); crypto_tfm_alg_ivsize(tfm));
} }
if (enc) if (enc)
ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen); ret = crypto_cipher_encrypt(tfm, sg, sg, cipher_tv[i].ilen);
else else
ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen); ret = crypto_cipher_decrypt(tfm, sg, sg, cipher_tv[i].ilen);
if (ret) { if (ret) {
printk("%s () failed flags=%x\n", e, tfm->crt_flags); printk("%s () failed flags=%x\n", e, tfm->crt_flags);
goto out; goto out;
@ -404,9 +415,9 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
printk("page %u\n", k); printk("page %u\n", k);
q = kmap(sg[k].page) + sg[k].offset; q = kmap(sg[k].page) + sg[k].offset;
hexdump(q, cipher_tv[i].tap[k]); hexdump(q, cipher_tv[i].tap[k]);
printk("%s\n", printk("%s\n",
memcmp(q, cipher_tv[i].result + temp, memcmp(q, cipher_tv[i].result + temp,
cipher_tv[i].tap[k]) ? "fail" : cipher_tv[i].tap[k]) ? "fail" :
"pass"); "pass");
temp += cipher_tv[i].tap[k]; temp += cipher_tv[i].tap[k];
} }
@ -417,8 +428,169 @@ test_cipher(char * algo, int mode, int enc, struct cipher_testvec * template, un
crypto_free_tfm(tfm); crypto_free_tfm(tfm);
} }
static void static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
test_deflate(void) int blen, int sec)
{
struct scatterlist sg[8];
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;
for (start = jiffies, end = start + sec * HZ, bcount = 0;
time_before(jiffies, end); bcount++) {
if (enc)
ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
else
ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
if (ret)
return ret;
}
printk("%d operations in %d seconds (%ld bytes)\n",
bcount, sec, (long)bcount * blen);
return 0;
}
static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
int blen)
{
struct scatterlist sg[8];
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;
local_bh_disable();
local_irq_disable();
/* Warm-up run. */
for (i = 0; i < 4; i++) {
if (enc)
ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
else
ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
if (ret)
goto out;
}
/* The real thing. */
for (i = 0; i < 8; i++) {
cycles_t start, end;
start = get_cycles();
if (enc)
ret = crypto_cipher_encrypt(tfm, sg, sg, blen);
else
ret = crypto_cipher_decrypt(tfm, sg, sg, blen);
end = get_cycles();
if (ret)
goto out;
cycles += end - start;
}
out:
local_irq_enable();
local_bh_enable();
if (ret == 0)
printk("1 operation in %lu cycles (%d bytes)\n",
(cycles + 4) / 8, blen);
return ret;
}
static void test_cipher_speed(char *algo, int mode, int enc, unsigned int sec,
struct cipher_testvec *template,
unsigned int tcount, struct cipher_speed *speed)
{
unsigned int ret, i, j, iv_len;
unsigned char *key, *p, iv[128];
struct crypto_tfm *tfm;
const char *e, *m;
if (enc == ENCRYPT)
e = "encryption";
else
e = "decryption";
if (mode == MODE_ECB)
m = "ECB";
else
m = "CBC";
printk("\ntesting speed of %s %s %s\n", algo, m, e);
if (mode)
tfm = crypto_alloc_tfm(algo, 0);
else
tfm = crypto_alloc_tfm(algo, CRYPTO_TFM_MODE_CBC);
if (tfm == NULL) {
printk("failed to load transform for %s %s\n", algo, m);
return;
}
for (i = 0; speed[i].klen != 0; i++) {
if ((speed[i].blen + speed[i].klen) > TVMEMSIZE) {
printk("template (%u) too big for tvmem (%u)\n",
speed[i].blen + speed[i].klen, TVMEMSIZE);
goto out;
}
printk("test %u (%d bit key, %d byte blocks): ", i,
speed[i].klen * 8, speed[i].blen);
memset(tvmem, 0xff, speed[i].klen + speed[i].blen);
/* set key, plain text and IV */
key = (unsigned char *)tvmem;
for (j = 0; j < tcount; j++) {
if (template[j].klen == speed[i].klen) {
key = template[j].key;
break;
}
}
p = (unsigned char *)tvmem + speed[i].klen;
ret = crypto_cipher_setkey(tfm, key, speed[i].klen);
if (ret) {
printk("setkey() failed flags=%x\n", tfm->crt_flags);
goto out;
}
if (!mode) {
iv_len = crypto_tfm_alg_ivsize(tfm);
memset(&iv, 0xff, iv_len);
crypto_cipher_set_iv(tfm, iv, iv_len);
}
if (sec)
ret = test_cipher_jiffies(tfm, enc, p, speed[i].blen,
sec);
else
ret = test_cipher_cycles(tfm, enc, p, speed[i].blen);
if (ret) {
printk("%s() failed flags=%x\n", e, tfm->crt_flags);
break;
}
}
out:
crypto_free_tfm(tfm);
}
static void test_deflate(void)
{ {
unsigned int i; unsigned int i;
char result[COMP_BUF_SIZE]; char result[COMP_BUF_SIZE];
@ -436,7 +608,7 @@ test_deflate(void)
} }
memcpy(tvmem, deflate_comp_tv_template, tsize); memcpy(tvmem, deflate_comp_tv_template, tsize);
tv = (void *) tvmem; tv = (void *)tvmem;
tfm = crypto_alloc_tfm("deflate", 0); tfm = crypto_alloc_tfm("deflate", 0);
if (tfm == NULL) { if (tfm == NULL) {
@ -446,7 +618,7 @@ test_deflate(void)
for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) { for (i = 0; i < DEFLATE_COMP_TEST_VECTORS; i++) {
int ilen, ret, dlen = COMP_BUF_SIZE; int ilen, ret, dlen = COMP_BUF_SIZE;
printk("test %u:\n", i + 1); printk("test %u:\n", i + 1);
memset(result, 0, sizeof (result)); memset(result, 0, sizeof (result));
@ -473,11 +645,11 @@ test_deflate(void)
} }
memcpy(tvmem, deflate_decomp_tv_template, tsize); memcpy(tvmem, deflate_decomp_tv_template, tsize);
tv = (void *) tvmem; tv = (void *)tvmem;
for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) { for (i = 0; i < DEFLATE_DECOMP_TEST_VECTORS; i++) {
int ilen, ret, dlen = COMP_BUF_SIZE; int ilen, ret, dlen = COMP_BUF_SIZE;
printk("test %u:\n", i + 1); printk("test %u:\n", i + 1);
memset(result, 0, sizeof (result)); memset(result, 0, sizeof (result));
@ -497,8 +669,7 @@ test_deflate(void)
crypto_free_tfm(tfm); crypto_free_tfm(tfm);
} }
static void static void test_crc32c(void)
test_crc32c(void)
{ {
#define NUMVEC 6 #define NUMVEC 6
#define VECSIZE 40 #define VECSIZE 40
@ -511,7 +682,7 @@ test_crc32c(void)
0xd579c862, 0xba979ad0, 0x2b29d913 0xd579c862, 0xba979ad0, 0x2b29d913
}; };
static u32 tot_vec_results = 0x24c5d375; static u32 tot_vec_results = 0x24c5d375;
struct scatterlist sg[NUMVEC]; struct scatterlist sg[NUMVEC];
struct crypto_tfm *tfm; struct crypto_tfm *tfm;
char *fmtdata = "testing crc32c initialized to %08x: %s\n"; char *fmtdata = "testing crc32c initialized to %08x: %s\n";
@ -525,18 +696,18 @@ test_crc32c(void)
printk("failed to load transform for crc32c\n"); printk("failed to load transform for crc32c\n");
return; return;
} }
crypto_digest_init(tfm); crypto_digest_init(tfm);
crypto_digest_final(tfm, (u8*)&crc); crypto_digest_final(tfm, (u8*)&crc);
printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR"); printk(fmtdata, crc, (crc == 0) ? "pass" : "ERROR");
/* /*
* stuff test_vec with known values, simple incrementing * stuff test_vec with known values, simple incrementing
* byte values. * byte values.
*/ */
b = 0; b = 0;
for (i = 0; i < NUMVEC; i++) { for (i = 0; i < NUMVEC; i++) {
for (j = 0; j < VECSIZE; j++) for (j = 0; j < VECSIZE; j++)
test_vec[i][j] = ++b; test_vec[i][j] = ++b;
sg[i].page = virt_to_page(test_vec[i]); sg[i].page = virt_to_page(test_vec[i]);
sg[i].offset = offset_in_page(test_vec[i]); sg[i].offset = offset_in_page(test_vec[i]);
@ -548,11 +719,11 @@ test_crc32c(void)
crypto_digest_final(tfm, (u8*)&crc); crypto_digest_final(tfm, (u8*)&crc);
printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ? printk("testing crc32c setkey returns %08x : %s\n", crc, (crc == (SEEDTESTVAL ^ ~(u32)0)) ?
"pass" : "ERROR"); "pass" : "ERROR");
printk("testing crc32c using update/final:\n"); printk("testing crc32c using update/final:\n");
pass = 1; /* assume all is well */ pass = 1; /* assume all is well */
for (i = 0; i < NUMVEC; i++) { for (i = 0; i < NUMVEC; i++) {
seed = ~(u32)0; seed = ~(u32)0;
(void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32)); (void)crypto_digest_setkey(tfm, (const u8*)&seed, sizeof(u32));
@ -591,66 +762,64 @@ test_crc32c(void)
printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results); printk(" %08x:BAD, wanted %08x\n", crc, tot_vec_results);
pass = 0; pass = 0;
} }
printk("\n%s\n", pass ? "pass" : "ERROR"); printk("\n%s\n", pass ? "pass" : "ERROR");
crypto_free_tfm(tfm); crypto_free_tfm(tfm);
printk("crc32c test complete\n"); printk("crc32c test complete\n");
} }
static void static void test_available(void)
test_available(void)
{ {
char **name = check; char **name = check;
while (*name) { while (*name) {
printk("alg %s ", *name); printk("alg %s ", *name);
printk((crypto_alg_available(*name, 0)) ? printk((crypto_alg_available(*name, 0)) ?
"found\n" : "not found\n"); "found\n" : "not found\n");
name++; name++;
} }
} }
static void static void do_test(void)
do_test(void)
{ {
switch (mode) { switch (mode) {
case 0: case 0:
test_hash("md5", md5_tv_template, MD5_TEST_VECTORS); test_hash("md5", md5_tv_template, MD5_TEST_VECTORS);
test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS); test_hash("sha1", sha1_tv_template, SHA1_TEST_VECTORS);
//DES //DES
test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS); test_cipher ("des", MODE_ECB, ENCRYPT, des_enc_tv_template, DES_ENC_TEST_VECTORS);
test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS); test_cipher ("des", MODE_ECB, DECRYPT, des_dec_tv_template, DES_DEC_TEST_VECTORS);
test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS); test_cipher ("des", MODE_CBC, ENCRYPT, des_cbc_enc_tv_template, DES_CBC_ENC_TEST_VECTORS);
test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS); test_cipher ("des", MODE_CBC, DECRYPT, des_cbc_dec_tv_template, DES_CBC_DEC_TEST_VECTORS);
//DES3_EDE //DES3_EDE
test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
//BLOWFISH //BLOWFISH
test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS); test_cipher ("blowfish", MODE_CBC, ENCRYPT, bf_cbc_enc_tv_template, BF_CBC_ENC_TEST_VECTORS);
test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS); test_cipher ("blowfish", MODE_CBC, DECRYPT, bf_cbc_dec_tv_template, BF_CBC_DEC_TEST_VECTORS);
//TWOFISH //TWOFISH
test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS); test_cipher ("twofish", MODE_ECB, ENCRYPT, tf_enc_tv_template, TF_ENC_TEST_VECTORS);
test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS); test_cipher ("twofish", MODE_ECB, DECRYPT, tf_dec_tv_template, TF_DEC_TEST_VECTORS);
test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
//SERPENT //SERPENT
test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
//TNEPRES //TNEPRES
test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS); test_cipher ("tnepres", MODE_ECB, ENCRYPT, tnepres_enc_tv_template, TNEPRES_ENC_TEST_VECTORS);
test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS); test_cipher ("tnepres", MODE_ECB, DECRYPT, tnepres_dec_tv_template, TNEPRES_DEC_TEST_VECTORS);
@ -662,7 +831,7 @@ do_test(void)
//CAST5 //CAST5
test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS); test_cipher ("cast5", MODE_ECB, ENCRYPT, cast5_enc_tv_template, CAST5_ENC_TEST_VECTORS);
test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS); test_cipher ("cast5", MODE_ECB, DECRYPT, cast5_dec_tv_template, CAST5_DEC_TEST_VECTORS);
//CAST6 //CAST6
test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS); test_cipher ("cast6", MODE_ECB, ENCRYPT, cast6_enc_tv_template, CAST6_ENC_TEST_VECTORS);
test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS); test_cipher ("cast6", MODE_ECB, DECRYPT, cast6_dec_tv_template, CAST6_DEC_TEST_VECTORS);
@ -702,9 +871,9 @@ do_test(void)
test_crc32c(); test_crc32c();
#ifdef CONFIG_CRYPTO_HMAC #ifdef CONFIG_CRYPTO_HMAC
test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
#endif #endif
test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS); test_hash("michael_mic", michael_mic_tv_template, MICHAEL_MIC_TEST_VECTORS);
break; break;
@ -726,17 +895,17 @@ do_test(void)
case 4: case 4:
test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS); test_cipher ("des3_ede", MODE_ECB, ENCRYPT, des3_ede_enc_tv_template, DES3_EDE_ENC_TEST_VECTORS);
test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS); test_cipher ("des3_ede", MODE_ECB, DECRYPT, des3_ede_dec_tv_template, DES3_EDE_DEC_TEST_VECTORS);
break; break;
case 5: case 5:
test_hash("md4", md4_tv_template, MD4_TEST_VECTORS); test_hash("md4", md4_tv_template, MD4_TEST_VECTORS);
break; break;
case 6: case 6:
test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS); test_hash("sha256", sha256_tv_template, SHA256_TEST_VECTORS);
break; break;
case 7: case 7:
test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS); test_cipher ("blowfish", MODE_ECB, ENCRYPT, bf_enc_tv_template, BF_ENC_TEST_VECTORS);
test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS); test_cipher ("blowfish", MODE_ECB, DECRYPT, bf_dec_tv_template, BF_DEC_TEST_VECTORS);
@ -750,7 +919,7 @@ do_test(void)
test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS); test_cipher ("twofish", MODE_CBC, ENCRYPT, tf_cbc_enc_tv_template, TF_CBC_ENC_TEST_VECTORS);
test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS); test_cipher ("twofish", MODE_CBC, DECRYPT, tf_cbc_dec_tv_template, TF_CBC_DEC_TEST_VECTORS);
break; break;
case 9: case 9:
test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS); test_cipher ("serpent", MODE_ECB, ENCRYPT, serpent_enc_tv_template, SERPENT_ENC_TEST_VECTORS);
test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS); test_cipher ("serpent", MODE_ECB, DECRYPT, serpent_dec_tv_template, SERPENT_DEC_TEST_VECTORS);
@ -758,13 +927,13 @@ do_test(void)
case 10: case 10:
test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS); test_cipher ("aes", MODE_ECB, ENCRYPT, aes_enc_tv_template, AES_ENC_TEST_VECTORS);
test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS); test_cipher ("aes", MODE_ECB, DECRYPT, aes_dec_tv_template, AES_DEC_TEST_VECTORS);
break; break;
case 11: case 11:
test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS); test_hash("sha384", sha384_tv_template, SHA384_TEST_VECTORS);
break; break;
case 12: case 12:
test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS); test_hash("sha512", sha512_tv_template, SHA512_TEST_VECTORS);
break; break;
@ -852,21 +1021,84 @@ do_test(void)
case 100: case 100:
test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS); test_hmac("md5", hmac_md5_tv_template, HMAC_MD5_TEST_VECTORS);
break; break;
case 101: case 101:
test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS); test_hmac("sha1", hmac_sha1_tv_template, HMAC_SHA1_TEST_VECTORS);
break; break;
case 102: case 102:
test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS); test_hmac("sha256", hmac_sha256_tv_template, HMAC_SHA256_TEST_VECTORS);
break; break;
#endif #endif
case 200:
test_cipher_speed("aes", MODE_ECB, ENCRYPT, sec, NULL, 0,
aes_speed_template);
test_cipher_speed("aes", MODE_ECB, DECRYPT, sec, NULL, 0,
aes_speed_template);
test_cipher_speed("aes", MODE_CBC, ENCRYPT, sec, NULL, 0,
aes_speed_template);
test_cipher_speed("aes", MODE_CBC, DECRYPT, sec, NULL, 0,
aes_speed_template);
break;
case 201:
test_cipher_speed("des3_ede", MODE_ECB, ENCRYPT, sec,
des3_ede_enc_tv_template,
DES3_EDE_ENC_TEST_VECTORS,
des3_ede_speed_template);
test_cipher_speed("des3_ede", MODE_ECB, DECRYPT, sec,
des3_ede_dec_tv_template,
DES3_EDE_DEC_TEST_VECTORS,
des3_ede_speed_template);
test_cipher_speed("des3_ede", MODE_CBC, ENCRYPT, sec,
des3_ede_enc_tv_template,
DES3_EDE_ENC_TEST_VECTORS,
des3_ede_speed_template);
test_cipher_speed("des3_ede", MODE_CBC, DECRYPT, sec,
des3_ede_dec_tv_template,
DES3_EDE_DEC_TEST_VECTORS,
des3_ede_speed_template);
break;
case 202:
test_cipher_speed("twofish", MODE_ECB, ENCRYPT, sec, NULL, 0,
twofish_speed_template);
test_cipher_speed("twofish", MODE_ECB, DECRYPT, sec, NULL, 0,
twofish_speed_template);
test_cipher_speed("twofish", MODE_CBC, ENCRYPT, sec, NULL, 0,
twofish_speed_template);
test_cipher_speed("twofish", MODE_CBC, DECRYPT, sec, NULL, 0,
twofish_speed_template);
break;
case 203:
test_cipher_speed("blowfish", MODE_ECB, ENCRYPT, sec, NULL, 0,
blowfish_speed_template);
test_cipher_speed("blowfish", MODE_ECB, DECRYPT, sec, NULL, 0,
blowfish_speed_template);
test_cipher_speed("blowfish", MODE_CBC, ENCRYPT, sec, NULL, 0,
blowfish_speed_template);
test_cipher_speed("blowfish", MODE_CBC, DECRYPT, sec, NULL, 0,
blowfish_speed_template);
break;
case 204:
test_cipher_speed("des", MODE_ECB, ENCRYPT, sec, NULL, 0,
des_speed_template);
test_cipher_speed("des", MODE_ECB, DECRYPT, sec, NULL, 0,
des_speed_template);
test_cipher_speed("des", MODE_CBC, ENCRYPT, sec, NULL, 0,
des_speed_template);
test_cipher_speed("des", MODE_CBC, DECRYPT, sec, NULL, 0,
des_speed_template);
break;
case 1000: case 1000:
test_available(); test_available();
break; break;
default: default:
/* useful for debugging */ /* useful for debugging */
printk("not testing anything\n"); printk("not testing anything\n");
@ -874,8 +1106,7 @@ do_test(void)
} }
} }
static int __init static int __init init(void)
init(void)
{ {
tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL); tvmem = kmalloc(TVMEMSIZE, GFP_KERNEL);
if (tvmem == NULL) if (tvmem == NULL)
@ -904,6 +1135,9 @@ module_init(init);
module_exit(fini); module_exit(fini);
module_param(mode, int, 0); module_param(mode, int, 0);
module_param(sec, uint, 0);
MODULE_PARM_DESC(sec, "Length in seconds of speed tests "
"(defaults to zero which uses CPU cycles instead)");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Quick & dirty crypto testing module"); MODULE_DESCRIPTION("Quick & dirty crypto testing module");

449
crypto/tcrypt.h
View File

File diff suppressed because it is too large Load Diff

6
drivers/net/appletalk/ltpc.c
View File

@ -1109,8 +1109,7 @@ struct net_device * __init ltpc_probe(void)
inb_p(io+1); inb_p(io+1);
inb_p(io+3); inb_p(io+3);
set_current_state(TASK_UNINTERRUPTIBLE); msleep(20);
schedule_timeout(2*HZ/100);
inb_p(io+0); inb_p(io+0);
inb_p(io+2); inb_p(io+2);
@ -1120,8 +1119,7 @@ struct net_device * __init ltpc_probe(void)
inb_p(io+5); /* enable dma */ inb_p(io+5); /* enable dma */
inb_p(io+6); /* tri-state interrupt line */ inb_p(io+6); /* tri-state interrupt line */
set_current_state(TASK_UNINTERRUPTIBLE); ssleep(1);
schedule_timeout(HZ);
/* now, figure out which dma channel we're using, unless it's /* now, figure out which dma channel we're using, unless it's
already been specified */ already been specified */

4
include/linux/netdevice.h
View File

@ -41,7 +41,7 @@
struct divert_blk; struct divert_blk;
struct vlan_group; struct vlan_group;
struct ethtool_ops; struct ethtool_ops;
struct netpoll; struct netpoll_info;
/* source back-compat hooks */ /* source back-compat hooks */
#define SET_ETHTOOL_OPS(netdev,ops) \ #define SET_ETHTOOL_OPS(netdev,ops) \
( (netdev)->ethtool_ops = (ops) ) ( (netdev)->ethtool_ops = (ops) )
@ -468,7 +468,7 @@ struct net_device
unsigned char *haddr); unsigned char *haddr);
int (*neigh_setup)(struct net_device *dev, struct neigh_parms *); int (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
#ifdef CONFIG_NETPOLL #ifdef CONFIG_NETPOLL
struct netpoll *np; struct netpoll_info *npinfo;
#endif #endif
#ifdef CONFIG_NET_POLL_CONTROLLER #ifdef CONFIG_NET_POLL_CONTROLLER
void (*poll_controller)(struct net_device *dev); void (*poll_controller)(struct net_device *dev);

3
include/linux/netfilter_ipv4/ipt_CLUSTERIP.h
View File

@ -18,7 +18,6 @@ struct clusterip_config;
struct ipt_clusterip_tgt_info { struct ipt_clusterip_tgt_info {
u_int32_t flags; u_int32_t flags;
struct clusterip_config *config;
/* only relevant for new ones */ /* only relevant for new ones */
u_int8_t clustermac[6]; u_int8_t clustermac[6];
@ -27,6 +26,8 @@ struct ipt_clusterip_tgt_info {
u_int16_t local_nodes[CLUSTERIP_MAX_NODES]; u_int16_t local_nodes[CLUSTERIP_MAX_NODES];
enum clusterip_hashmode hash_mode; enum clusterip_hashmode hash_mode;
u_int32_t hash_initval; u_int32_t hash_initval;
struct clusterip_config *config;
}; };
#endif /*_IPT_CLUSTERIP_H_target*/ #endif /*_IPT_CLUSTERIP_H_target*/

34
include/linux/netpoll.h
View File

@ -16,14 +16,19 @@ struct netpoll;
struct netpoll { struct netpoll {
struct net_device *dev; struct net_device *dev;
char dev_name[16], *name; char dev_name[16], *name;
int rx_flags;
void (*rx_hook)(struct netpoll *, int, char *, int); void (*rx_hook)(struct netpoll *, int, char *, int);
void (*drop)(struct sk_buff *skb); void (*drop)(struct sk_buff *skb);
u32 local_ip, remote_ip; u32 local_ip, remote_ip;
u16 local_port, remote_port; u16 local_port, remote_port;
unsigned char local_mac[6], remote_mac[6]; unsigned char local_mac[6], remote_mac[6];
};
struct netpoll_info {
spinlock_t poll_lock; spinlock_t poll_lock;
int poll_owner; int poll_owner;
int rx_flags;
spinlock_t rx_lock;
struct netpoll *rx_np; /* netpoll that registered an rx_hook */
}; };
void netpoll_poll(struct netpoll *np); void netpoll_poll(struct netpoll *np);
@ -39,22 +44,35 @@ void netpoll_queue(struct sk_buff *skb);
#ifdef CONFIG_NETPOLL #ifdef CONFIG_NETPOLL
static inline int netpoll_rx(struct sk_buff *skb) static inline int netpoll_rx(struct sk_buff *skb)
{ {
return skb->dev->np && skb->dev->np->rx_flags && __netpoll_rx(skb); struct netpoll_info *npinfo = skb->dev->npinfo;
unsigned long flags;
int ret = 0;
if (!npinfo || (!npinfo->rx_np && !npinfo->rx_flags))
return 0;
spin_lock_irqsave(&npinfo->rx_lock, flags);
/* check rx_flags again with the lock held */
if (npinfo->rx_flags && __netpoll_rx(skb))
ret = 1;
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
return ret;
} }
static inline void netpoll_poll_lock(struct net_device *dev) static inline void netpoll_poll_lock(struct net_device *dev)
{ {
if (dev->np) { if (dev->npinfo) {
spin_lock(&dev->np->poll_lock); spin_lock(&dev->npinfo->poll_lock);
dev->np->poll_owner = smp_processor_id(); dev->npinfo->poll_owner = smp_processor_id();
} }
} }
static inline void netpoll_poll_unlock(struct net_device *dev) static inline void netpoll_poll_unlock(struct net_device *dev)
{ {
if (dev->np) { if (dev->npinfo) {
spin_unlock(&dev->np->poll_lock); dev->npinfo->poll_owner = -1;
dev->np->poll_owner = -1; spin_unlock(&dev->npinfo->poll_lock);
} }
} }

12
include/linux/x25.h
View File

@ -4,6 +4,8 @@
* History * History
* mar/20/00 Daniela Squassoni Disabling/enabling of facilities * mar/20/00 Daniela Squassoni Disabling/enabling of facilities
* negotiation. * negotiation.
* apr/02/05 Shaun Pereira Selective sub address matching with
* call user data
*/ */
#ifndef X25_KERNEL_H #ifndef X25_KERNEL_H
@ -16,6 +18,9 @@
#define SIOCX25GCALLUSERDATA (SIOCPROTOPRIVATE + 4) #define SIOCX25GCALLUSERDATA (SIOCPROTOPRIVATE + 4)
#define SIOCX25SCALLUSERDATA (SIOCPROTOPRIVATE + 5) #define SIOCX25SCALLUSERDATA (SIOCPROTOPRIVATE + 5)
#define SIOCX25GCAUSEDIAG (SIOCPROTOPRIVATE + 6) #define SIOCX25GCAUSEDIAG (SIOCPROTOPRIVATE + 6)
#define SIOCX25SCUDMATCHLEN (SIOCPROTOPRIVATE + 7)
#define SIOCX25CALLACCPTAPPRV (SIOCPROTOPRIVATE + 8)
#define SIOCX25SENDCALLACCPT (SIOCPROTOPRIVATE + 9)
/* /*
* Values for {get,set}sockopt. * Values for {get,set}sockopt.
@ -109,4 +114,11 @@ struct x25_causediag {
unsigned char diagnostic; unsigned char diagnostic;
}; };
/*
* Further optional call user data match length selection
*/
struct x25_subaddr {
unsigned int cudmatchlength;
};
#endif #endif

9
include/net/x25.h
View File

@ -79,6 +79,8 @@ enum {
#define X25_DEFAULT_PACKET_SIZE X25_PS128 /* Default Packet Size */ #define X25_DEFAULT_PACKET_SIZE X25_PS128 /* Default Packet Size */
#define X25_DEFAULT_THROUGHPUT 0x0A /* Deafult Throughput */ #define X25_DEFAULT_THROUGHPUT 0x0A /* Deafult Throughput */
#define X25_DEFAULT_REVERSE 0x00 /* Default Reverse Charging */ #define X25_DEFAULT_REVERSE 0x00 /* Default Reverse Charging */
#define X25_DENY_ACCPT_APPRV 0x01 /* Default value */
#define X25_ALLOW_ACCPT_APPRV 0x00 /* Control enabled */
#define X25_SMODULUS 8 #define X25_SMODULUS 8
#define X25_EMODULUS 128 #define X25_EMODULUS 128
@ -94,7 +96,7 @@ enum {
#define X25_FAC_CLASS_C 0x80 #define X25_FAC_CLASS_C 0x80
#define X25_FAC_CLASS_D 0xC0 #define X25_FAC_CLASS_D 0xC0
#define X25_FAC_REVERSE 0x01 #define X25_FAC_REVERSE 0x01 /* also fast select */
#define X25_FAC_THROUGHPUT 0x02 #define X25_FAC_THROUGHPUT 0x02
#define X25_FAC_PACKET_SIZE 0x42 #define X25_FAC_PACKET_SIZE 0x42
#define X25_FAC_WINDOW_SIZE 0x43 #define X25_FAC_WINDOW_SIZE 0x43
@ -134,8 +136,8 @@ struct x25_sock {
struct sock sk; struct sock sk;
struct x25_address source_addr, dest_addr; struct x25_address source_addr, dest_addr;
struct x25_neigh *neighbour; struct x25_neigh *neighbour;
unsigned int lci; unsigned int lci, cudmatchlength;
unsigned char state, condition, qbitincl, intflag; unsigned char state, condition, qbitincl, intflag, accptapprv;
unsigned short vs, vr, va, vl; unsigned short vs, vr, va, vl;
unsigned long t2, t21, t22, t23; unsigned long t2, t21, t22, t23;
unsigned short fraglen; unsigned short fraglen;
@ -242,7 +244,6 @@ extern int x25_validate_nr(struct sock *, unsigned short);
extern void x25_write_internal(struct sock *, int); extern void x25_write_internal(struct sock *, int);
extern int x25_decode(struct sock *, struct sk_buff *, int *, int *, int *, int *, int *); extern int x25_decode(struct sock *, struct sk_buff *, int *, int *, int *, int *, int *);
extern void x25_disconnect(struct sock *, int, unsigned char, unsigned char); extern void x25_disconnect(struct sock *, int, unsigned char, unsigned char);
extern int x25_check_calluserdata(struct x25_calluserdata *,struct x25_calluserdata *);
/* x25_timer.c */ /* x25_timer.c */
extern void x25_start_heartbeat(struct sock *); extern void x25_start_heartbeat(struct sock *);

7
net/appletalk/aarp.c
View File

@ -35,6 +35,7 @@
#include <net/datalink.h> #include <net/datalink.h>
#include <net/psnap.h> #include <net/psnap.h>
#include <linux/atalk.h> #include <linux/atalk.h>
#include <linux/delay.h>
#include <linux/init.h> #include <linux/init.h>
#include <linux/proc_fs.h> #include <linux/proc_fs.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
@ -462,8 +463,7 @@ void aarp_probe_network(struct atalk_iface *atif)
aarp_send_probe(atif->dev, &atif->address); aarp_send_probe(atif->dev, &atif->address);
/* Defer 1/10th */ /* Defer 1/10th */
current->state = TASK_INTERRUPTIBLE; msleep(100);
schedule_timeout(HZ / 10);
if (atif->status & ATIF_PROBE_FAIL) if (atif->status & ATIF_PROBE_FAIL)
break; break;
@ -510,9 +510,8 @@ int aarp_proxy_probe_network(struct atalk_iface *atif, struct atalk_addr *sa)
aarp_send_probe(atif->dev, sa); aarp_send_probe(atif->dev, sa);
/* Defer 1/10th */ /* Defer 1/10th */
current->state = TASK_INTERRUPTIBLE;
write_unlock_bh(&aarp_lock); write_unlock_bh(&aarp_lock);
schedule_timeout(HZ / 10); msleep(100);
write_lock_bh(&aarp_lock); write_lock_bh(&aarp_lock);
if (entry->status & ATIF_PROBE_FAIL) if (entry->status & ATIF_PROBE_FAIL)

21
net/bridge/netfilter/ebtables.c
View File

@ -859,8 +859,7 @@ static int translate_table(struct ebt_replace *repl,
if (repl->valid_hooks & (1 << i)) if (repl->valid_hooks & (1 << i))
if (check_chainloops(newinfo->hook_entry[i], if (check_chainloops(newinfo->hook_entry[i],
cl_s, udc_cnt, i, newinfo->entries)) { cl_s, udc_cnt, i, newinfo->entries)) {
if (cl_s) vfree(cl_s);
vfree(cl_s);
return -EINVAL; return -EINVAL;
} }
@ -883,8 +882,7 @@ static int translate_table(struct ebt_replace *repl,
EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size, EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size,
ebt_cleanup_entry, &i); ebt_cleanup_entry, &i);
} }
if (cl_s) vfree(cl_s);
vfree(cl_s);
return ret; return ret;
} }
@ -1030,8 +1028,7 @@ static int do_replace(void __user *user, unsigned int len)
} }
vfree(table); vfree(table);
if (counterstmp) vfree(counterstmp);
vfree(counterstmp);
return ret; return ret;
free_unlock: free_unlock:
@ -1040,8 +1037,7 @@ static int do_replace(void __user *user, unsigned int len)
EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size, EBT_ENTRY_ITERATE(newinfo->entries, newinfo->entries_size,
ebt_cleanup_entry, NULL); ebt_cleanup_entry, NULL);
free_counterstmp: free_counterstmp:
if (counterstmp) vfree(counterstmp);
vfree(counterstmp);
/* can be initialized in translate_table() */ /* can be initialized in translate_table() */
if (newinfo->chainstack) { if (newinfo->chainstack) {
for (i = 0; i < num_possible_cpus(); i++) for (i = 0; i < num_possible_cpus(); i++)
@ -1049,11 +1045,9 @@ static int do_replace(void __user *user, unsigned int len)
vfree(newinfo->chainstack); vfree(newinfo->chainstack);
} }
free_entries: free_entries:
if (newinfo->entries) vfree(newinfo->entries);
vfree(newinfo->entries);
free_newinfo: free_newinfo:
if (newinfo) vfree(newinfo);
vfree(newinfo);
return ret; return ret;
} }
@ -1213,8 +1207,7 @@ void ebt_unregister_table(struct ebt_table *table)
down(&ebt_mutex); down(&ebt_mutex);
LIST_DELETE(&ebt_tables, table); LIST_DELETE(&ebt_tables, table);
up(&ebt_mutex); up(&ebt_mutex);
if (table->private->entries) vfree(table->private->entries);
vfree(table->private->entries);
if (table->private->chainstack) { if (table->private->chainstack) {
for (i = 0; i < num_possible_cpus(); i++) for (i = 0; i < num_possible_cpus(); i++)
vfree(table->private->chainstack[i]); vfree(table->private->chainstack[i]);

80
net/core/netpoll.c
View File

@ -130,19 +130,20 @@ static int checksum_udp(struct sk_buff *skb, struct udphdr *uh,
*/ */
static void poll_napi(struct netpoll *np) static void poll_napi(struct netpoll *np)
{ {
struct netpoll_info *npinfo = np->dev->npinfo;
int budget = 16; int budget = 16;
if (test_bit(__LINK_STATE_RX_SCHED, &np->dev->state) && if (test_bit(__LINK_STATE_RX_SCHED, &np->dev->state) &&
np->poll_owner != smp_processor_id() && npinfo->poll_owner != smp_processor_id() &&
spin_trylock(&np->poll_lock)) { spin_trylock(&npinfo->poll_lock)) {
np->rx_flags |= NETPOLL_RX_DROP; npinfo->rx_flags |= NETPOLL_RX_DROP;
atomic_inc(&trapped); atomic_inc(&trapped);
np->dev->poll(np->dev, &budget); np->dev->poll(np->dev, &budget);
atomic_dec(&trapped); atomic_dec(&trapped);
np->rx_flags &= ~NETPOLL_RX_DROP; npinfo->rx_flags &= ~NETPOLL_RX_DROP;
spin_unlock(&np->poll_lock); spin_unlock(&npinfo->poll_lock);
} }
} }
@ -245,6 +246,7 @@ static struct sk_buff * find_skb(struct netpoll *np, int len, int reserve)
static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb) static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
{ {
int status; int status;
struct netpoll_info *npinfo;
repeat: repeat:
if(!np || !np->dev || !netif_running(np->dev)) { if(!np || !np->dev || !netif_running(np->dev)) {
@ -253,8 +255,9 @@ static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
} }
/* avoid recursion */ /* avoid recursion */
if(np->poll_owner == smp_processor_id() || npinfo = np->dev->npinfo;
np->dev->xmit_lock_owner == smp_processor_id()) { if (npinfo->poll_owner == smp_processor_id() ||
np->dev->xmit_lock_owner == smp_processor_id()) {
if (np->drop) if (np->drop)
np->drop(skb); np->drop(skb);
else else
@ -341,14 +344,22 @@ void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
static void arp_reply(struct sk_buff *skb) static void arp_reply(struct sk_buff *skb)
{ {
struct netpoll_info *npinfo = skb->dev->npinfo;
struct arphdr *arp; struct arphdr *arp;
unsigned char *arp_ptr; unsigned char *arp_ptr;
int size, type = ARPOP_REPLY, ptype = ETH_P_ARP; int size, type = ARPOP_REPLY, ptype = ETH_P_ARP;
u32 sip, tip; u32 sip, tip;
unsigned long flags;
struct sk_buff *send_skb; struct sk_buff *send_skb;
struct netpoll *np = skb->dev->np; struct netpoll *np = NULL;
if (!np) return; spin_lock_irqsave(&npinfo->rx_lock, flags);
if (npinfo->rx_np && npinfo->rx_np->dev == skb->dev)
np = npinfo->rx_np;
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
if (!np)
return;
/* No arp on this interface */ /* No arp on this interface */
if (skb->dev->flags & IFF_NOARP) if (skb->dev->flags & IFF_NOARP)
@ -429,9 +440,9 @@ int __netpoll_rx(struct sk_buff *skb)
int proto, len, ulen; int proto, len, ulen;
struct iphdr *iph; struct iphdr *iph;
struct udphdr *uh; struct udphdr *uh;
struct netpoll *np = skb->dev->np; struct netpoll *np = skb->dev->npinfo->rx_np;
if (!np->rx_hook) if (!np)
goto out; goto out;
if (skb->dev->type != ARPHRD_ETHER) if (skb->dev->type != ARPHRD_ETHER)
goto out; goto out;
@ -611,9 +622,8 @@ int netpoll_setup(struct netpoll *np)
{ {
struct net_device *ndev = NULL; struct net_device *ndev = NULL;
struct in_device *in_dev; struct in_device *in_dev;
struct netpoll_info *npinfo;
np->poll_lock = SPIN_LOCK_UNLOCKED; unsigned long flags;
np->poll_owner = -1;
if (np->dev_name) if (np->dev_name)
ndev = dev_get_by_name(np->dev_name); ndev = dev_get_by_name(np->dev_name);
@ -624,7 +634,17 @@ int netpoll_setup(struct netpoll *np)
} }
np->dev = ndev; np->dev = ndev;
ndev->np = np; if (!ndev->npinfo) {
npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
if (!npinfo)
goto release;
npinfo->rx_np = NULL;
npinfo->poll_lock = SPIN_LOCK_UNLOCKED;
npinfo->poll_owner = -1;
npinfo->rx_lock = SPIN_LOCK_UNLOCKED;
} else
npinfo = ndev->npinfo;
if (!ndev->poll_controller) { if (!ndev->poll_controller) {
printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n", printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n",
@ -692,13 +712,20 @@ int netpoll_setup(struct netpoll *np)
np->name, HIPQUAD(np->local_ip)); np->name, HIPQUAD(np->local_ip));
} }
if(np->rx_hook) if (np->rx_hook) {
np->rx_flags = NETPOLL_RX_ENABLED; spin_lock_irqsave(&npinfo->rx_lock, flags);
npinfo->rx_flags |= NETPOLL_RX_ENABLED;
npinfo->rx_np = np;
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
}
/* last thing to do is link it to the net device structure */
ndev->npinfo = npinfo;
return 0; return 0;
release: release:
ndev->np = NULL; if (!ndev->npinfo)
kfree(npinfo);
np->dev = NULL; np->dev = NULL;
dev_put(ndev); dev_put(ndev);
return -1; return -1;
@ -706,9 +733,20 @@ int netpoll_setup(struct netpoll *np)
void netpoll_cleanup(struct netpoll *np) void netpoll_cleanup(struct netpoll *np)
{ {
if (np->dev) struct netpoll_info *npinfo;
np->dev->np = NULL; unsigned long flags;
dev_put(np->dev);
if (np->dev) {
npinfo = np->dev->npinfo;
if (npinfo && npinfo->rx_np == np) {
spin_lock_irqsave(&npinfo->rx_lock, flags);
npinfo->rx_np = NULL;
npinfo->rx_flags &= ~NETPOLL_RX_ENABLED;
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
}
dev_put(np->dev);
}
np->dev = NULL; np->dev = NULL;
} }

2
net/ipv4/netfilter/ipt_CLUSTERIP.c
View File

@ -339,7 +339,7 @@ target(struct sk_buff **pskb,
* error messages (RELATED) and information requests (see below) */ * error messages (RELATED) and information requests (see below) */
if ((*pskb)->nh.iph->protocol == IPPROTO_ICMP if ((*pskb)->nh.iph->protocol == IPPROTO_ICMP
&& (ctinfo == IP_CT_RELATED && (ctinfo == IP_CT_RELATED
|| ctinfo == IP_CT_IS_REPLY+IP_CT_IS_REPLY)) || ctinfo == IP_CT_RELATED+IP_CT_IS_REPLY))
return IPT_CONTINUE; return IPT_CONTINUE;
/* ip_conntrack_icmp guarantees us that we only have ICMP_ECHO, /* ip_conntrack_icmp guarantees us that we only have ICMP_ECHO,

8
net/ipv4/route.c
View File

@ -1767,7 +1767,7 @@ static inline int ip_mkroute_input_def(struct sk_buff *skb,
struct in_device *in_dev, struct in_device *in_dev,
u32 daddr, u32 saddr, u32 tos) u32 daddr, u32 saddr, u32 tos)
{ {
struct rtable* rth; struct rtable* rth = NULL;
int err; int err;
unsigned hash; unsigned hash;
@ -1794,7 +1794,7 @@ static inline int ip_mkroute_input(struct sk_buff *skb,
u32 daddr, u32 saddr, u32 tos) u32 daddr, u32 saddr, u32 tos)
{ {
#ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED #ifdef CONFIG_IP_ROUTE_MULTIPATH_CACHED
struct rtable* rth; struct rtable* rth = NULL;
unsigned char hop, hopcount, lasthop; unsigned char hop, hopcount, lasthop;
int err = -EINVAL; int err = -EINVAL;
unsigned int hash; unsigned int hash;
@ -2239,7 +2239,7 @@ static inline int ip_mkroute_output_def(struct rtable **rp,
struct net_device *dev_out, struct net_device *dev_out,
unsigned flags) unsigned flags)
{ {
struct rtable *rth; struct rtable *rth = NULL;
int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags); int err = __mkroute_output(&rth, res, fl, oldflp, dev_out, flags);
unsigned hash; unsigned hash;
if (err == 0) { if (err == 0) {
@ -2267,7 +2267,7 @@ static inline int ip_mkroute_output(struct rtable** rp,
unsigned char hop; unsigned char hop;
unsigned hash; unsigned hash;
int err = -EINVAL; int err = -EINVAL;
struct rtable *rth; struct rtable *rth = NULL;
if (res->fi && res->fi->fib_nhs > 1) { if (res->fi && res->fi->fib_nhs > 1) {
unsigned char hopcount = res->fi->fib_nhs; unsigned char hopcount = res->fi->fib_nhs;

3
net/socket.c
View File

@ -383,9 +383,8 @@ int sock_map_fd(struct socket *sock)
goto out; goto out;
} }
sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino); this.len = sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
this.name = name; this.name = name;
this.len = strlen(name);
this.hash = SOCK_INODE(sock)->i_ino; this.hash = SOCK_INODE(sock)->i_ino;
file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this); file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);

108
net/x25/af_x25.c
View File

@ -29,6 +29,10 @@
* 2000-11-14 Henner Eisen Closing datalink from NETDEV_GOING_DOWN * 2000-11-14 Henner Eisen Closing datalink from NETDEV_GOING_DOWN
* 2002-10-06 Arnaldo C. Melo Get rid of cli/sti, move proc stuff to * 2002-10-06 Arnaldo C. Melo Get rid of cli/sti, move proc stuff to
* x25_proc.c, using seq_file * x25_proc.c, using seq_file
* 2005-04-02 Shaun Pereira Selective sub address matching
* with call user data
* 2005-04-15 Shaun Pereira Fast select with no restriction on
* response
*/ */
#include <linux/config.h> #include <linux/config.h>
@ -219,7 +223,8 @@ static void x25_insert_socket(struct sock *sk)
* Note: if a listening socket has cud set it must only get calls * Note: if a listening socket has cud set it must only get calls
* with matching cud. * with matching cud.
*/ */
static struct sock *x25_find_listener(struct x25_address *addr, struct x25_calluserdata *calluserdata) static struct sock *x25_find_listener(struct x25_address *addr,
struct sk_buff *skb)
{ {
struct sock *s; struct sock *s;
struct sock *next_best; struct sock *next_best;
@ -230,22 +235,23 @@ static struct sock *x25_find_listener(struct x25_address *addr, struct x25_callu
sk_for_each(s, node, &x25_list) sk_for_each(s, node, &x25_list)
if ((!strcmp(addr->x25_addr, if ((!strcmp(addr->x25_addr,
x25_sk(s)->source_addr.x25_addr) || x25_sk(s)->source_addr.x25_addr) ||
!strcmp(addr->x25_addr, !strcmp(addr->x25_addr,
null_x25_address.x25_addr)) && null_x25_address.x25_addr)) &&
s->sk_state == TCP_LISTEN) { s->sk_state == TCP_LISTEN) {
/* /*
* Found a listening socket, now check the incoming * Found a listening socket, now check the incoming
* call user data vs this sockets call user data * call user data vs this sockets call user data
*/ */
if (x25_check_calluserdata(&x25_sk(s)->calluserdata, calluserdata)) { if(skb->len > 0 && x25_sk(s)->cudmatchlength > 0) {
sock_hold(s); if((memcmp(x25_sk(s)->calluserdata.cuddata,
goto found; skb->data,
} x25_sk(s)->cudmatchlength)) == 0) {
if (x25_sk(s)->calluserdata.cudlength == 0) { sock_hold(s);
goto found;
}
} else
next_best = s; next_best = s;
}
} }
if (next_best) { if (next_best) {
s = next_best; s = next_best;
@ -497,6 +503,9 @@ static int x25_create(struct socket *sock, int protocol)
x25->t23 = sysctl_x25_clear_request_timeout; x25->t23 = sysctl_x25_clear_request_timeout;
x25->t2 = sysctl_x25_ack_holdback_timeout; x25->t2 = sysctl_x25_ack_holdback_timeout;
x25->state = X25_STATE_0; x25->state = X25_STATE_0;
x25->cudmatchlength = 0;
x25->accptapprv = X25_DENY_ACCPT_APPRV; /* normally no cud */
/* on call accept */
x25->facilities.winsize_in = X25_DEFAULT_WINDOW_SIZE; x25->facilities.winsize_in = X25_DEFAULT_WINDOW_SIZE;
x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE; x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE;
@ -545,6 +554,8 @@ static struct sock *x25_make_new(struct sock *osk)
x25->t2 = ox25->t2; x25->t2 = ox25->t2;
x25->facilities = ox25->facilities; x25->facilities = ox25->facilities;
x25->qbitincl = ox25->qbitincl; x25->qbitincl = ox25->qbitincl;
x25->cudmatchlength = ox25->cudmatchlength;
x25->accptapprv = ox25->accptapprv;
x25_init_timers(sk); x25_init_timers(sk);
out: out:
@ -822,7 +833,6 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
struct x25_sock *makex25; struct x25_sock *makex25;
struct x25_address source_addr, dest_addr; struct x25_address source_addr, dest_addr;
struct x25_facilities facilities; struct x25_facilities facilities;
struct x25_calluserdata calluserdata;
int len, rc; int len, rc;
/* /*
@ -844,20 +854,11 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
len = skb->data[0] + 1; len = skb->data[0] + 1;
skb_pull(skb,len); skb_pull(skb,len);
/*
* Incoming Call User Data.
*/
if (skb->len >= 0) {
memcpy(calluserdata.cuddata, skb->data, skb->len);
calluserdata.cudlength = skb->len;
}
skb_push(skb,len);
/* /*
* Find a listener for the particular address/cud pair. * Find a listener for the particular address/cud pair.
*/ */
sk = x25_find_listener(&source_addr,&calluserdata); sk = x25_find_listener(&source_addr,skb);
skb_push(skb,len);
/* /*
* We can't accept the Call Request. * We can't accept the Call Request.
@ -900,11 +901,23 @@ int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
makex25->neighbour = nb; makex25->neighbour = nb;
makex25->facilities = facilities; makex25->facilities = facilities;
makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask; makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask;
makex25->calluserdata = calluserdata; /* ensure no reverse facil on accept */
makex25->vc_facil_mask &= ~X25_MASK_REVERSE;
makex25->cudmatchlength = x25_sk(sk)->cudmatchlength;
x25_write_internal(make, X25_CALL_ACCEPTED); /* Normally all calls are accepted immediatly */
if(makex25->accptapprv & X25_DENY_ACCPT_APPRV) {
x25_write_internal(make, X25_CALL_ACCEPTED);
makex25->state = X25_STATE_3;
}
makex25->state = X25_STATE_3; /*
* Incoming Call User Data.
*/
if (skb->len >= 0) {
memcpy(makex25->calluserdata.cuddata, skb->data, skb->len);
makex25->calluserdata.cudlength = skb->len;
}
sk->sk_ack_backlog++; sk->sk_ack_backlog++;
@ -1288,7 +1301,8 @@ static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
if (facilities.throughput < 0x03 || if (facilities.throughput < 0x03 ||
facilities.throughput > 0xDD) facilities.throughput > 0xDD)
break; break;
if (facilities.reverse && facilities.reverse != 1) if (facilities.reverse &&
(facilities.reverse | 0x81)!= 0x81)
break; break;
x25->facilities = facilities; x25->facilities = facilities;
rc = 0; rc = 0;
@ -1325,6 +1339,44 @@ static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
break; break;
} }
case SIOCX25SCUDMATCHLEN: {
struct x25_subaddr sub_addr;
rc = -EINVAL;
if(sk->sk_state != TCP_CLOSE)
break;
rc = -EFAULT;
if (copy_from_user(&sub_addr, argp,
sizeof(sub_addr)))
break;
rc = -EINVAL;
if(sub_addr.cudmatchlength > X25_MAX_CUD_LEN)
break;
x25->cudmatchlength = sub_addr.cudmatchlength;
rc = 0;
break;
}
case SIOCX25CALLACCPTAPPRV: {
rc = -EINVAL;
if (sk->sk_state != TCP_CLOSE)
break;
x25->accptapprv = X25_ALLOW_ACCPT_APPRV;
rc = 0;
break;
}
case SIOCX25SENDCALLACCPT: {
rc = -EINVAL;
if (sk->sk_state != TCP_ESTABLISHED)
break;
if (x25->accptapprv) /* must call accptapprv above */
break;
x25_write_internal(sk, X25_CALL_ACCEPTED);
x25->state = X25_STATE_3;
rc = 0;
break;
}
default: default:
rc = dev_ioctl(cmd, argp); rc = dev_ioctl(cmd, argp);
break; break;

34
net/x25/x25_facilities.c
View File

@ -17,6 +17,8 @@
* X.25 001 Split from x25_subr.c * X.25 001 Split from x25_subr.c
* mar/20/00 Daniela Squassoni Disabling/enabling of facilities * mar/20/00 Daniela Squassoni Disabling/enabling of facilities
* negotiation. * negotiation.
* apr/14/05 Shaun Pereira - Allow fast select with no restriction
* on response.
*/ */
#include <linux/kernel.h> #include <linux/kernel.h>
@ -43,9 +45,31 @@ int x25_parse_facilities(struct sk_buff *skb,
case X25_FAC_CLASS_A: case X25_FAC_CLASS_A:
switch (*p) { switch (*p) {
case X25_FAC_REVERSE: case X25_FAC_REVERSE:
facilities->reverse = p[1] & 0x01; if((p[1] & 0x81) == 0x81) {
*vc_fac_mask |= X25_MASK_REVERSE; facilities->reverse = p[1] & 0x81;
break; *vc_fac_mask |= X25_MASK_REVERSE;
break;
}
if((p[1] & 0x01) == 0x01) {
facilities->reverse = p[1] & 0x01;
*vc_fac_mask |= X25_MASK_REVERSE;
break;
}
if((p[1] & 0x80) == 0x80) {
facilities->reverse = p[1] & 0x80;
*vc_fac_mask |= X25_MASK_REVERSE;
break;
}
if(p[1] == 0x00) {
facilities->reverse
= X25_DEFAULT_REVERSE;
*vc_fac_mask |= X25_MASK_REVERSE;
break;
}
case X25_FAC_THROUGHPUT: case X25_FAC_THROUGHPUT:
facilities->throughput = p[1]; facilities->throughput = p[1];
*vc_fac_mask |= X25_MASK_THROUGHPUT; *vc_fac_mask |= X25_MASK_THROUGHPUT;
@ -122,7 +146,7 @@ int x25_create_facilities(unsigned char *buffer,
if (facilities->reverse && (facil_mask & X25_MASK_REVERSE)) { if (facilities->reverse && (facil_mask & X25_MASK_REVERSE)) {
*p++ = X25_FAC_REVERSE; *p++ = X25_FAC_REVERSE;
*p++ = !!facilities->reverse; *p++ = facilities->reverse;
} }
if (facilities->throughput && (facil_mask & X25_MASK_THROUGHPUT)) { if (facilities->throughput && (facil_mask & X25_MASK_THROUGHPUT)) {
@ -171,7 +195,7 @@ int x25_negotiate_facilities(struct sk_buff *skb, struct sock *sk,
/* /*
* They want reverse charging, we won't accept it. * They want reverse charging, we won't accept it.
*/ */
if (theirs.reverse && ours->reverse) { if ((theirs.reverse & 0x01 ) && (ours->reverse & 0x01)) {
SOCK_DEBUG(sk, "X.25: rejecting reverse charging request"); SOCK_DEBUG(sk, "X.25: rejecting reverse charging request");
return -1; return -1;
} }

41
net/x25/x25_subr.c
View File

@ -19,6 +19,8 @@
* mar/20/00 Daniela Squassoni Disabling/enabling of facilities * mar/20/00 Daniela Squassoni Disabling/enabling of facilities
* negotiation. * negotiation.
* jun/24/01 Arnaldo C. Melo use skb_queue_purge, cleanups * jun/24/01 Arnaldo C. Melo use skb_queue_purge, cleanups
* apr/04/15 Shaun Pereira Fast select with no
* restriction on response.
*/ */
#include <linux/kernel.h> #include <linux/kernel.h>
@ -127,8 +129,12 @@ void x25_write_internal(struct sock *sk, int frametype)
len += 1 + X25_ADDR_LEN + X25_MAX_FAC_LEN + len += 1 + X25_ADDR_LEN + X25_MAX_FAC_LEN +
X25_MAX_CUD_LEN; X25_MAX_CUD_LEN;
break; break;
case X25_CALL_ACCEPTED: case X25_CALL_ACCEPTED: /* fast sel with no restr on resp */
len += 1 + X25_MAX_FAC_LEN + X25_MAX_CUD_LEN; if(x25->facilities.reverse & 0x80) {
len += 1 + X25_MAX_FAC_LEN + X25_MAX_CUD_LEN;
} else {
len += 1 + X25_MAX_FAC_LEN;
}
break; break;
case X25_CLEAR_REQUEST: case X25_CLEAR_REQUEST:
case X25_RESET_REQUEST: case X25_RESET_REQUEST:
@ -203,9 +209,16 @@ void x25_write_internal(struct sock *sk, int frametype)
x25->vc_facil_mask); x25->vc_facil_mask);
dptr = skb_put(skb, len); dptr = skb_put(skb, len);
memcpy(dptr, facilities, len); memcpy(dptr, facilities, len);
dptr = skb_put(skb, x25->calluserdata.cudlength);
memcpy(dptr, x25->calluserdata.cuddata, /* fast select with no restriction on response
x25->calluserdata.cudlength); allows call user data. Userland must
ensure it is ours and not theirs */
if(x25->facilities.reverse & 0x80) {
dptr = skb_put(skb,
x25->calluserdata.cudlength);
memcpy(dptr, x25->calluserdata.cuddata,
x25->calluserdata.cudlength);
}
x25->calluserdata.cudlength = 0; x25->calluserdata.cudlength = 0;
break; break;
@ -354,21 +367,3 @@ void x25_check_rbuf(struct sock *sk)
} }
} }
/*
* Compare 2 calluserdata structures, used to find correct listening sockets
* when call user data is used.
*/
int x25_check_calluserdata(struct x25_calluserdata *ours, struct x25_calluserdata *theirs)
{
int i;
if (ours->cudlength != theirs->cudlength)
return 0;
for (i=0;i<ours->cudlength;i++) {
if (ours->cuddata[i] != theirs->cuddata[i]) {
return 0;
}
}
return 1;
}