From afd9925b5a10f58eb6e9dd0c645d88dcae85e851 Mon Sep 17 00:00:00 2001 From: jacob Date: Tue, 2 Nov 2004 00:00:06 +0000 Subject: [PATCH] - update rhel series from chaos - add some module compile fixes --- .../kernel-2.4.21-rhel-2.4-i686-smp.config | 1 + .../kernel-2.4.21-rhel-2.4-i686.config | 1 + .../patches/compile-fixes-2.4.21-rhel.patch | 94 + .../patches/small_scatterlist-2.4.21-rhel.patch | 4287 ++++++++++++++++++++ lustre/kernel_patches/series/rhel-2.4.21 | 6 + 5 files changed, 4389 insertions(+) create mode 100644 lustre/kernel_patches/patches/compile-fixes-2.4.21-rhel.patch create mode 100644 lustre/kernel_patches/patches/small_scatterlist-2.4.21-rhel.patch diff --git a/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686-smp.config b/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686-smp.config index 185854d..87b3e6e 100644 --- a/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686-smp.config +++ b/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686-smp.config @@ -567,6 +567,7 @@ CONFIG_SCSI=m # CONFIG_BLK_DEV_SD=m CONFIG_SD_EXTRA_DEVS=256 +CONFIG_SD_IOSTATS=y CONFIG_SCSI_DUMP=m CONFIG_CHR_DEV_ST=m CONFIG_CHR_DEV_OSST=m diff --git a/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686.config b/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686.config index 185854d..87b3e6e 100644 --- a/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686.config +++ b/lustre/kernel_patches/kernel_configs/kernel-2.4.21-rhel-2.4-i686.config @@ -567,6 +567,7 @@ CONFIG_SCSI=m # CONFIG_BLK_DEV_SD=m CONFIG_SD_EXTRA_DEVS=256 +CONFIG_SD_IOSTATS=y CONFIG_SCSI_DUMP=m CONFIG_CHR_DEV_ST=m CONFIG_CHR_DEV_OSST=m diff --git a/lustre/kernel_patches/patches/compile-fixes-2.4.21-rhel.patch b/lustre/kernel_patches/patches/compile-fixes-2.4.21-rhel.patch new file mode 100644 index 0000000..e56ded0 --- /dev/null +++ b/lustre/kernel_patches/patches/compile-fixes-2.4.21-rhel.patch @@ -0,0 +1,94 @@ +Index: linux-2.4.21/drivers/i2c/i2c-ali1535.c +=================================================================== +--- linux-2.4.21.orig/drivers/i2c/i2c-ali1535.c 2004-09-11 10:16:33.000000000 -0400 ++++ linux-2.4.21/drivers/i2c/i2c-ali1535.c 2004-11-01 18:12:53.000000000 -0500 +@@ -672,8 +672,8 @@ + #ifdef MODULE + + MODULE_AUTHOR +- ("Frodo Looijaard , Philip Edelbrock , +- Mark D. Studebaker and Dan Eaton "); ++ ("Frodo Looijaard , Philip Edelbrock , " ++ "Mark D. Studebaker and Dan Eaton "); + MODULE_DESCRIPTION("ALI1535 SMBus driver"); + + int init_module(void) +Index: linux-2.4.21/drivers/sensors/lm87.c +=================================================================== +--- linux-2.4.21.orig/drivers/sensors/lm87.c 2004-09-11 10:16:33.000000000 -0400 ++++ linux-2.4.21/drivers/sensors/lm87.c 2004-11-01 18:16:08.000000000 -0500 +@@ -1060,10 +1060,10 @@ + #endif + + MODULE_AUTHOR +- ("Frodo Looijaard , +- Philip Edelbrock , +- Mark Studebaker , +- and Stephen Rousset "); ++ ("Frodo Looijaard , " ++ "Philip Edelbrock , " ++ "Mark Studebaker , " ++ "and Stephen Rousset "); + + MODULE_DESCRIPTION("LM87 driver"); + +Index: linux-2.4.21/drivers/net/wan/sbni.c +=================================================================== +--- linux-2.4.21.orig/drivers/net/wan/sbni.c 2004-11-01 18:27:56.000000000 -0500 ++++ linux-2.4.21/drivers/net/wan/sbni.c 2004-11-01 18:28:16.000000000 -0500 +@@ -1552,13 +1552,13 @@ + static u32 + calc_crc32( u32 crc, u8 *p, u32 len ) + { +- register u32 _crc __asm ( "ax" ); ++ register u32 _crc; + _crc = crc; + + __asm __volatile ( + "xorl %%ebx, %%ebx\n" +- "movl %1, %%esi\n" +- "movl %2, %%ecx\n" ++ "movl %2, %%esi\n" ++ "movl %3, %%ecx\n" + "movl $crc32tab, %%edi\n" + "shrl $2, %%ecx\n" + "jz 1f\n" +@@ -1594,7 +1594,7 @@ + "jnz 0b\n" + + "1:\n" +- "movl %2, %%ecx\n" ++ "movl %3, %%ecx\n" + "andl $3, %%ecx\n" + "jz 2f\n" + +@@ -1619,9 +1619,9 @@ + "xorb 2(%%esi), %%bl\n" + "xorl (%%edi,%%ebx,4), %%eax\n" + "2:\n" +- : +- : "a" (_crc), "g" (p), "g" (len) +- : "ax", "bx", "cx", "dx", "si", "di" ++ : "=a" (_crc) ++ : "0" (_crc), "g" (p), "g" (len) ++ : "bx", "cx", "dx", "si", "di" + ); + + return _crc; +Index: linux-2.4.21/drivers/net/pcmcia/wvlan_cs.c +=================================================================== +--- linux-2.4.21.orig/drivers/net/pcmcia/wvlan_cs.c 2004-11-01 18:28:53.000000000 -0500 ++++ linux-2.4.21/drivers/net/pcmcia/wvlan_cs.c 2004-11-01 18:29:11.000000000 -0500 +@@ -1084,9 +1084,9 @@ + /* This is a PrismII card. It is is *very* similar + * to the Lucent, and the driver work 95%, + * therefore, we attempt to support it... */ +- printk(KERN_NOTICE "%s: This is a PrismII card, not a Wavelan IEEE card :-( +-You may want report firmare revision (0x%X) and what the card support. +-I will try to make it work, but you should look for a better driver.\n", dev_info, firmware); ++ printk(KERN_NOTICE "%s: This is a PrismII card, not a Wavelan IEEE card :-(\n" ++"You may want report firmare revision (0x%X) and what the card support.\n" ++"I will try to make it work, but you should look for a better driver.\n", dev_info, firmware); + local->has_port3 = 1; + local->has_ibssid = 0; + local->has_mwo = 0; diff --git a/lustre/kernel_patches/patches/small_scatterlist-2.4.21-rhel.patch b/lustre/kernel_patches/patches/small_scatterlist-2.4.21-rhel.patch new file mode 100644 index 0000000..d9699e2 --- /dev/null +++ b/lustre/kernel_patches/patches/small_scatterlist-2.4.21-rhel.patch @@ -0,0 +1,4287 @@ +Index: linux-2.4.21/crypto/cipher.c +=================================================================== +--- linux-2.4.21.orig/crypto/cipher.c 2004-09-11 07:16:20.000000000 -0700 ++++ linux-2.4.21/crypto/cipher.c 2004-09-17 06:45:29.000000000 -0700 +@@ -88,12 +88,21 @@ + + walk->sg = sg; + ++#if SMALL_SCATTERLIST ++ walk->page = sg->u.page.page; ++ walk->len_this_segment = sg->length; ++ ++ rest_of_page = PAGE_CACHE_SIZE - (sg->u.page.offset & (PAGE_CACHE_SIZE - 1)); ++ walk->len_this_page = min(sg->length, rest_of_page); ++ walk->offset = sg->u.page.offset; ++#else + walk->page = sg->page; + walk->len_this_segment = sg->length; + + rest_of_page = PAGE_CACHE_SIZE - (sg->offset & (PAGE_CACHE_SIZE - 1)); + walk->len_this_page = min(sg->length, rest_of_page); + walk->offset = sg->offset; ++#endif + } + + static void scatterwalk_map(struct scatter_walk *walk, int out) +Index: linux-2.4.21/crypto/digest.c +=================================================================== +--- linux-2.4.21.orig/crypto/digest.c 2004-09-11 07:16:20.000000000 -0700 ++++ linux-2.4.21/crypto/digest.c 2004-09-17 06:45:29.000000000 -0700 +@@ -29,7 +29,11 @@ + unsigned int i; + + for (i = 0; i < nsg; i++) { ++#if SMALL_SCATTERLIST ++ char *p = crypto_kmap(sg[i].u.page.page, 0) + sg[i].u.page.offset; ++#else + char *p = crypto_kmap(sg[i].page, 0) + sg[i].offset; ++#endif + tfm->__crt_alg->cra_digest.dia_update(crypto_tfm_ctx(tfm), + p, sg[i].length); + crypto_kunmap(p, 0); +@@ -50,7 +54,11 @@ + tfm->crt_digest.dit_init(tfm); + + for (i = 0; i < nsg; i++) { ++#if SMALL_SCATTERLIST ++ char *p = crypto_kmap(sg[i].u.page.page, 0) + sg[i].u.page.offset; ++#else + char *p = crypto_kmap(sg[i].page, 0) + sg[i].offset; ++#endif + tfm->__crt_alg->cra_digest.dia_update(crypto_tfm_ctx(tfm), + p, sg[i].length); + crypto_kunmap(p, 0); +Index: linux-2.4.21/crypto/hmac.c +=================================================================== +--- linux-2.4.21.orig/crypto/hmac.c 2004-09-11 07:16:20.000000000 -0700 ++++ linux-2.4.21/crypto/hmac.c 2004-09-17 06:45:29.000000000 -0700 +@@ -25,8 +25,14 @@ + { + struct scatterlist tmp; + ++#if SMALL_SCATTERLIST ++ tmp.ispaged = 1; ++ tmp.u.page.page = virt_to_page(key); ++ tmp.u.page.offset = ((long)key & ~PAGE_MASK); ++#else + tmp.page = virt_to_page(key); + tmp.offset = ((long)key & ~PAGE_MASK); ++#endif + tmp.length = keylen; + crypto_digest_digest(tfm, &tmp, 1, key); + +@@ -70,8 +76,14 @@ + for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++) + ipad[i] ^= 0x36; + ++#if SMALL_SCATTERLIST ++ tmp.ispaged = 1; ++ tmp.u.page.page = virt_to_page(ipad); ++ tmp.u.page.offset = ((long)ipad & ~PAGE_MASK); ++#else + tmp.page = virt_to_page(ipad); + tmp.offset = ((long)ipad & ~PAGE_MASK); ++#endif + tmp.length = crypto_tfm_alg_blocksize(tfm); + + crypto_digest_init(tfm); +@@ -104,15 +116,27 @@ + for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++) + opad[i] ^= 0x5c; + ++#if SMALL_SCATTERLIST ++ tmp.ispaged = 1; ++ tmp.u.page.page = virt_to_page(opad); ++ tmp.u.page.offset = ((long)opad & ~PAGE_MASK); ++#else + tmp.page = virt_to_page(opad); + tmp.offset = ((long)opad & ~PAGE_MASK); ++#endif + tmp.length = crypto_tfm_alg_blocksize(tfm); + + crypto_digest_init(tfm); + crypto_digest_update(tfm, &tmp, 1); + ++#if SMALL_SCATTERLIST ++ tmp.ispaged = 1; ++ tmp.u.page.page = virt_to_page(out); ++ tmp.u.page.offset = ((long)out & ~PAGE_MASK); ++#else + tmp.page = virt_to_page(out); + tmp.offset = ((long)out & ~PAGE_MASK); ++#endif + tmp.length = crypto_tfm_alg_digestsize(tfm); + + crypto_digest_update(tfm, &tmp, 1); +Index: linux-2.4.21/crypto/tcrypt.c +=================================================================== +--- linux-2.4.21.orig/crypto/tcrypt.c 2004-09-11 07:16:20.000000000 -0700 ++++ linux-2.4.21/crypto/tcrypt.c 2004-09-17 08:16:59.000000000 -0700 +@@ -24,6 +24,15 @@ + #include + #include "tcrypt.h" + ++#if SMALL_SCATTERLIST ++#define SG_PAGE(sg) ((sg).u.page.page) ++#define SG_OFFSET(sg) ((sg).u.page.offset) ++#define SG_ADDRESS(sg) ((sg).u.address) ++#else ++#define SG_PAGE(sg) ((sg).page) ++#define SG_OFFSET(sg) ((sg).offset) ++#define SG_ADDRESS(sg) ((sg).address) ++#endif /* !SMALL_SCATTERLIST */ + /* + * Need to kmalloc() memory for testing kmap(). + */ +@@ -95,8 +104,8 @@ + memset(result, 0, sizeof (result)); + + p = md5_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(md5_tv[i].plaintext); + + crypto_digest_init(tfm); +@@ -118,13 +127,13 @@ + memcpy(&xbuf[IDX2], "nopqrstuvwxyz", 13); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[0].length = 13; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 13; + + memset(result, 0, sizeof (result)); +@@ -172,8 +181,8 @@ + memset(result, 0, sizeof (result)); + + p = hmac_md5_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(hmac_md5_tv[i].plaintext); + + klen = strlen(hmac_md5_tv[i].key); +@@ -194,13 +203,13 @@ + memcpy(&xbuf[IDX2], "for nothing?", 12); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 16; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 12; + + memset(result, 0, sizeof (result)); +@@ -249,8 +258,8 @@ + memset(result, 0, sizeof (result)); + + p = hmac_sha1_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(hmac_sha1_tv[i].plaintext); + + klen = strlen(hmac_sha1_tv[i].key); +@@ -273,13 +282,13 @@ + memcpy(&xbuf[IDX2], "for nothing?", 12); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 16; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 12; + + memset(result, 0, sizeof (result)); +@@ -328,8 +337,8 @@ + memset(result, 0, sizeof (result)); + + p = hmac_sha256_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(hmac_sha256_tv[i].plaintext); + + klen = strlen(hmac_sha256_tv[i].key); +@@ -382,8 +391,8 @@ + memset(result, 0, sizeof (result)); + + p = md4_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(md4_tv[i].plaintext); + + crypto_digest_digest(tfm, sg, 1, result); +@@ -432,8 +441,8 @@ + memset(result, 0, sizeof (result)); + + p = sha1_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(sha1_tv[i].plaintext); + + crypto_digest_init(tfm); +@@ -455,13 +464,13 @@ + memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 28; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 28; + + memset(result, 0, sizeof (result)); +@@ -507,8 +516,8 @@ + memset(result, 0, sizeof (result)); + + p = sha256_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(sha256_tv[i].plaintext); + + crypto_digest_init(tfm); +@@ -530,13 +539,13 @@ + memcpy(&xbuf[IDX2], "hijkijkljklmklmnlmnomnopnopq", 28); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 28; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 28; + + memset(result, 0, sizeof (result)); +@@ -583,8 +592,8 @@ + memset(result, 0, sizeof (result)); + + p = sha384_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(sha384_tv[i].plaintext); + + crypto_digest_init(tfm); +@@ -635,8 +644,8 @@ + memset(result, 0, sizeof (result)); + + p = sha512_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = strlen(sha512_tv[i].plaintext); + + crypto_digest_init(tfm); +@@ -700,8 +709,8 @@ + len = des_tv[i].len; + + p = des_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = len; + ret = crypto_cipher_encrypt(tfm, sg, sg, len); + if (ret) { +@@ -709,7 +718,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, len); + + printk("%s\n", +@@ -737,13 +746,13 @@ + memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 8; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 8; + + ret = crypto_cipher_encrypt(tfm, sg, sg, 16); +@@ -753,12 +762,12 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 8); + printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 8); + printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass"); + +@@ -800,18 +809,18 @@ + memcpy(&xbuf[IDX5], des_tv[i].plaintext + 24, 8); + + p = &xbuf[IDX3]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 14; + + p = &xbuf[IDX4]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 10; + + p = &xbuf[IDX5]; +- sg[2].page = virt_to_page(p); +- sg[2].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[2]) = virt_to_page(p); ++ SG_OFFSET(sg[2]) = ((long) p & ~PAGE_MASK); + sg[2].length = 8; + + ret = crypto_cipher_encrypt(tfm, sg, sg, 32); +@@ -822,17 +831,17 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 14); + printk("%s\n", memcmp(q, des_tv[i].result, 14) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 10); + printk("%s\n", memcmp(q, des_tv[i].result + 14, 10) ? "fail" : "pass"); + + printk("page 3\n"); +- q = kmap(sg[2].page) + sg[2].offset; ++ q = kmap(SG_PAGE(sg[2])) + SG_OFFSET(sg[2]); + hexdump(q, 8); + printk("%s\n", memcmp(q, des_tv[i].result + 24, 8) ? "fail" : "pass"); + +@@ -871,23 +880,23 @@ + memcpy(&xbuf[IDX6], des_tv[i].plaintext + 6, 18); + + p = &xbuf[IDX3]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 2; + + p = &xbuf[IDX4]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 1; + + p = &xbuf[IDX5]; +- sg[2].page = virt_to_page(p); +- sg[2].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[2]) = virt_to_page(p); ++ SG_OFFSET(sg[2]) = ((long) p & ~PAGE_MASK); + sg[2].length = 3; + + p = &xbuf[IDX6]; +- sg[3].page = virt_to_page(p); +- sg[3].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[3]) = virt_to_page(p); ++ SG_OFFSET(sg[3]) = ((long) p & ~PAGE_MASK); + sg[3].length = 18; + + ret = crypto_cipher_encrypt(tfm, sg, sg, 24); +@@ -898,22 +907,22 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 2); + printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 1); + printk("%s\n", memcmp(q, des_tv[i].result + 2, 1) ? "fail" : "pass"); + + printk("page 3\n"); +- q = kmap(sg[2].page) + sg[2].offset; ++ q = kmap(SG_PAGE(sg[2])) + SG_OFFSET(sg[2]); + hexdump(q, 3); + printk("%s\n", memcmp(q, des_tv[i].result + 3, 3) ? "fail" : "pass"); + + printk("page 4\n"); +- q = kmap(sg[3].page) + sg[3].offset; ++ q = kmap(SG_PAGE(sg[3])) + SG_OFFSET(sg[3]); + hexdump(q, 18); + printk("%s\n", memcmp(q, des_tv[i].result + 6, 18) ? "fail" : "pass"); + +@@ -955,28 +964,28 @@ + memcpy(&xbuf[IDX7], des_tv[i].plaintext + 8, 8); + + p = &xbuf[IDX3]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 2; + + p = &xbuf[IDX4]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 2; + + p = &xbuf[IDX5]; +- sg[2].page = virt_to_page(p); +- sg[2].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[2]) = virt_to_page(p); ++ SG_OFFSET(sg[2]) = ((long) p & ~PAGE_MASK); + sg[2].length = 2; + + p = &xbuf[IDX6]; +- sg[3].page = virt_to_page(p); +- sg[3].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[3]) = virt_to_page(p); ++ SG_OFFSET(sg[3]) = ((long) p & ~PAGE_MASK); + sg[3].length = 2; + + p = &xbuf[IDX7]; +- sg[4].page = virt_to_page(p); +- sg[4].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[4]) = virt_to_page(p); ++ SG_OFFSET(sg[4]) = ((long) p & ~PAGE_MASK); + sg[4].length = 8; + + ret = crypto_cipher_encrypt(tfm, sg, sg, 16); +@@ -987,27 +996,27 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 2); + printk("%s\n", memcmp(q, des_tv[i].result, 2) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 2); + printk("%s\n", memcmp(q, des_tv[i].result + 2, 2) ? "fail" : "pass"); + + printk("page 3\n"); +- q = kmap(sg[2].page) + sg[2].offset; ++ q = kmap(SG_PAGE(sg[2])) + SG_OFFSET(sg[2]); + hexdump(q, 2); + printk("%s\n", memcmp(q, des_tv[i].result + 4, 2) ? "fail" : "pass"); + + printk("page 4\n"); +- q = kmap(sg[3].page) + sg[3].offset; ++ q = kmap(SG_PAGE(sg[3])) + SG_OFFSET(sg[3]); + hexdump(q, 2); + printk("%s\n", memcmp(q, des_tv[i].result + 6, 2) ? "fail" : "pass"); + + printk("page 5\n"); +- q = kmap(sg[4].page) + sg[4].offset; ++ q = kmap(SG_PAGE(sg[4])) + SG_OFFSET(sg[4]); + hexdump(q, 8); + printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass"); + +@@ -1039,43 +1048,43 @@ + xbuf[IDX8] = des_tv[i].plaintext[7]; + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 1; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 1; + + p = &xbuf[IDX3]; +- sg[2].page = virt_to_page(p); +- sg[2].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[2]) = virt_to_page(p); ++ SG_OFFSET(sg[2]) = ((long) p & ~PAGE_MASK); + sg[2].length = 1; + + p = &xbuf[IDX4]; +- sg[3].page = virt_to_page(p); +- sg[3].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[3]) = virt_to_page(p); ++ SG_OFFSET(sg[3]) = ((long) p & ~PAGE_MASK); + sg[3].length = 1; + + p = &xbuf[IDX5]; +- sg[4].page = virt_to_page(p); +- sg[4].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[4]) = virt_to_page(p); ++ SG_OFFSET(sg[4]) = ((long) p & ~PAGE_MASK); + sg[4].length = 1; + + p = &xbuf[IDX6]; +- sg[5].page = virt_to_page(p); +- sg[5].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[5]) = virt_to_page(p); ++ SG_OFFSET(sg[5]) = ((long) p & ~PAGE_MASK); + sg[5].length = 1; + + p = &xbuf[IDX7]; +- sg[6].page = virt_to_page(p); +- sg[6].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[6]) = virt_to_page(p); ++ SG_OFFSET(sg[6]) = ((long) p & ~PAGE_MASK); + sg[6].length = 1; + + p = &xbuf[IDX8]; +- sg[7].page = virt_to_page(p); +- sg[7].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[7]) = virt_to_page(p); ++ SG_OFFSET(sg[7]) = ((long) p & ~PAGE_MASK); + sg[7].length = 1; + + ret = crypto_cipher_encrypt(tfm, sg, sg, 8); +@@ -1085,7 +1094,7 @@ + } + + for (i = 0; i < 8; i++) +- res[i] = *(char *) (kmap(sg[i].page) + sg[i].offset); ++ res[i] = *(char *) (kmap(SG_PAGE(sg[i])) + SG_OFFSET(sg[i])); + + hexdump(res, 8); + printk("%s\n", memcmp(res, des_tv[7].result, 8) ? "fail" : "pass"); +@@ -1116,8 +1125,8 @@ + len = des_tv[i].len; + + p = des_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = len; + + ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length); +@@ -1127,7 +1136,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, len); + + printk("%s\n", +@@ -1154,13 +1163,13 @@ + memcpy(&xbuf[IDX2], des_tv[i].plaintext + 8, 8); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 8; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 8; + + ret = crypto_cipher_decrypt(tfm, sg, sg, 16); +@@ -1170,12 +1179,12 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 8); + printk("%s\n", memcmp(q, des_tv[i].result, 8) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 8); + printk("%s\n", memcmp(q, des_tv[i].result + 8, 8) ? "fail" : "pass"); + +@@ -1206,18 +1215,18 @@ + memcpy(&xbuf[IDX3], des_tv[i].plaintext + 15, 1); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 3; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 12; + + p = &xbuf[IDX3]; +- sg[2].page = virt_to_page(p); +- sg[2].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[2]) = virt_to_page(p); ++ SG_OFFSET(sg[2]) = ((long) p & ~PAGE_MASK); + sg[2].length = 1; + + ret = crypto_cipher_decrypt(tfm, sg, sg, 16); +@@ -1228,17 +1237,17 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 3); + printk("%s\n", memcmp(q, des_tv[i].result, 3) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 12); + printk("%s\n", memcmp(q, des_tv[i].result + 3, 12) ? "fail" : "pass"); + + printk("page 3\n"); +- q = kmap(sg[2].page) + sg[2].offset; ++ q = kmap(SG_PAGE(sg[2])) + SG_OFFSET(sg[2]); + hexdump(q, 1); + printk("%s\n", memcmp(q, des_tv[i].result + 15, 1) ? "fail" : "pass"); + +@@ -1283,8 +1292,8 @@ + len = des_tv[i].len; + p = des_tv[i].plaintext; + +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = len; + + crypto_cipher_set_iv(tfm, des_tv[i].iv, +@@ -1297,7 +1306,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, len); + + printk("%s\n", +@@ -1338,13 +1347,13 @@ + memcpy(&xbuf[IDX2], des_tv[i].plaintext + 13, 11); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 13; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 11; + + crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm)); +@@ -1356,12 +1365,12 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 13); + printk("%s\n", memcmp(q, des_tv[i].result, 13) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 11); + printk("%s\n", memcmp(q, des_tv[i].result + 13, 11) ? "fail" : "pass"); + +@@ -1391,8 +1400,8 @@ + len = des_tv[i].len; + p = des_tv[i].plaintext; + +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = len; + + crypto_cipher_set_iv(tfm, des_tv[i].iv, +@@ -1407,7 +1416,7 @@ + + hexdump(tfm->crt_cipher.cit_iv, 8); + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, len); + + printk("%s\n", +@@ -1439,13 +1448,13 @@ + memcpy(&xbuf[IDX2], des_tv[i].plaintext + 4, 4); + + p = &xbuf[IDX1]; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = 4; + + p = &xbuf[IDX2]; +- sg[1].page = virt_to_page(p); +- sg[1].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[1]) = virt_to_page(p); ++ SG_OFFSET(sg[1]) = ((long) p & ~PAGE_MASK); + sg[1].length = 4; + + crypto_cipher_set_iv(tfm, des_tv[i].iv, crypto_tfm_alg_ivsize(tfm)); +@@ -1457,12 +1466,12 @@ + } + + printk("page 1\n"); +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, 4); + printk("%s\n", memcmp(q, des_tv[i].result, 4) ? "fail" : "pass"); + + printk("page 2\n"); +- q = kmap(sg[1].page) + sg[1].offset; ++ q = kmap(SG_PAGE(sg[1])) + SG_OFFSET(sg[1]); + hexdump(q, 4); + printk("%s\n", memcmp(q, des_tv[i].result + 4, 4) ? "fail" : "pass"); + +@@ -1515,8 +1524,8 @@ + len = des_tv[i].len; + + p = des_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = len; + ret = crypto_cipher_encrypt(tfm, sg, sg, len); + if (ret) { +@@ -1524,7 +1533,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, len); + + printk("%s\n", +@@ -1558,8 +1567,8 @@ + len = des_tv[i].len; + + p = des_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = len; + ret = crypto_cipher_decrypt(tfm, sg, sg, len); + if (ret) { +@@ -1567,7 +1576,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, len); + + printk("%s\n", +@@ -1621,8 +1630,8 @@ + } + + p = bf_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = bf_tv[i].plen; + ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -1630,7 +1639,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, bf_tv[i].rlen); + + printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ? +@@ -1663,8 +1672,8 @@ + } + + p = bf_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = bf_tv[i].plen; + ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -1672,7 +1681,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, bf_tv[i].rlen); + + printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) ? +@@ -1712,8 +1721,8 @@ + + p = bf_tv[i].plaintext; + +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = bf_tv[i].plen; + + crypto_cipher_set_iv(tfm, bf_tv[i].iv, +@@ -1726,7 +1735,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, bf_tv[i].rlen); + + printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) +@@ -1757,8 +1766,8 @@ + + p = bf_tv[i].plaintext; + +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = bf_tv[i].plen; + + crypto_cipher_set_iv(tfm, bf_tv[i].iv, +@@ -1771,7 +1780,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, bf_tv[i].rlen); + + printk("%s\n", memcmp(q, bf_tv[i].result, bf_tv[i].rlen) +@@ -1826,8 +1835,8 @@ + } + + p = tf_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = tf_tv[i].plen; + ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -1835,7 +1844,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, tf_tv[i].rlen); + + printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ? +@@ -1868,8 +1877,8 @@ + } + + p = tf_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = tf_tv[i].plen; + ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -1877,7 +1886,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, tf_tv[i].rlen); + + printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) ? +@@ -1917,8 +1926,8 @@ + + p = tf_tv[i].plaintext; + +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = tf_tv[i].plen; + + crypto_cipher_set_iv(tfm, tf_tv[i].iv, +@@ -1931,7 +1940,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, tf_tv[i].rlen); + + printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) +@@ -1963,8 +1972,8 @@ + + p = tf_tv[i].plaintext; + +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = tf_tv[i].plen; + + crypto_cipher_set_iv(tfm, tf_tv[i].iv, +@@ -1977,7 +1986,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, tf_tv[i].rlen); + + printk("%s\n", memcmp(q, tf_tv[i].result, tf_tv[i].rlen) +@@ -2027,8 +2036,8 @@ + } + + p = serp_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = sizeof(serp_tv[i].plaintext); + ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2036,7 +2045,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, sizeof(serp_tv[i].result)); + + printk("%s\n", memcmp(q, serp_tv[i].result, +@@ -2067,8 +2076,8 @@ + } + + p = serp_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = sizeof(serp_tv[i].plaintext); + ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2076,7 +2085,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, sizeof(serp_tv[i].result)); + + printk("%s\n", memcmp(q, serp_tv[i].result, +@@ -2126,8 +2135,8 @@ + } + + p = cast_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = sizeof(cast_tv[i].plaintext); + ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2135,7 +2144,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, sizeof(cast_tv[i].result)); + + printk("%s\n", memcmp(q, cast_tv[i].result, +@@ -2166,8 +2175,8 @@ + } + + p = cast_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = sizeof(cast_tv[i].plaintext); + ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2175,7 +2184,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, sizeof(cast_tv[i].result)); + + printk("%s\n", memcmp(q, cast_tv[i].result, +@@ -2229,8 +2238,8 @@ + } + + p = aes_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = aes_tv[i].plen; + ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2238,7 +2247,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, aes_tv[i].rlen); + + printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ? +@@ -2271,8 +2280,8 @@ + } + + p = aes_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = aes_tv[i].plen; + ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2280,7 +2289,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, aes_tv[i].rlen); + + printk("%s\n", memcmp(q, aes_tv[i].result, aes_tv[i].rlen) ? +@@ -2330,8 +2339,8 @@ + } + + p = c5_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = sizeof(c5_tv[i].plaintext); + ret = crypto_cipher_encrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2339,7 +2348,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, sizeof(c5_tv[i].ciphertext)); + + printk("%s\n", memcmp(q, c5_tv[i].ciphertext, +@@ -2368,8 +2377,8 @@ + } + + p = c5_tv[i].plaintext; +- sg[0].page = virt_to_page(p); +- sg[0].offset = ((long) p & ~PAGE_MASK); ++ SG_PAGE(sg[0]) = virt_to_page(p); ++ SG_OFFSET(sg[0]) = ((long) p & ~PAGE_MASK); + sg[0].length = sizeof(c5_tv[i].plaintext); + ret = crypto_cipher_decrypt(tfm, sg, sg, sg[0].length); + if (ret) { +@@ -2377,7 +2386,7 @@ + goto out; + } + +- q = kmap(sg[0].page) + sg[0].offset; ++ q = kmap(SG_PAGE(sg[0])) + SG_OFFSET(sg[0]); + hexdump(q, sizeof(c5_tv[i].ciphertext)); + + printk("%s\n", memcmp(q, c5_tv[i].ciphertext, +Index: linux-2.4.21/drivers/ide/ide-dma.c +=================================================================== +--- linux-2.4.21.orig/drivers/ide/ide-dma.c 2004-09-11 07:16:39.000000000 -0700 ++++ linux-2.4.21/drivers/ide/ide-dma.c 2004-09-17 06:45:29.000000000 -0700 +@@ -280,14 +280,25 @@ + memset(&sg[nents], 0, sizeof(*sg)); + + if (bh->b_page) { ++#if SMALL_SCATTERLIST ++ sg[nents].ispaged = 1; ++ sg[nents].u.page.page = bh->b_page; ++ sg[nents].u.page.offset = bh_offset(bh); ++#else + sg[nents].page = bh->b_page; + sg[nents].offset = bh_offset(bh); ++#endif + lastdataend = bh_phys(bh) + bh->b_size; + } else { + if ((unsigned long) bh->b_data < PAGE_SIZE) + BUG(); + ++#if SMALL_SCATTERLIST ++ sg[nents].ispaged = 0; ++ sg[nents].u.address = bh->b_data; ++#else + sg[nents].address = bh->b_data; ++#endif + lastdataend = (unsigned long) bh->b_data + bh->b_size; + } + +@@ -328,14 +339,24 @@ + #if 1 + if (sector_count > 128) { + memset(&sg[nents], 0, sizeof(*sg)); ++#if SMALL_SCATTERLIST ++ sg[nents].ispaged = 0; ++ sg[nents].u.address = virt_addr; ++#else + sg[nents].address = virt_addr; ++#endif + sg[nents].length = 128 * SECTOR_SIZE; + nents++; + virt_addr = virt_addr + (128 * SECTOR_SIZE); + sector_count -= 128; + } + memset(&sg[nents], 0, sizeof(*sg)); ++#if SMALL_SCATTERLIST ++ sg[nents].ispaged = 0; ++ sg[nents].u.address = virt_addr; ++#else + sg[nents].address = virt_addr; ++#endif + sg[nents].length = sector_count * SECTOR_SIZE; + nents++; + #else +Index: linux-2.4.21/drivers/scsi/dpt_i2o.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/dpt_i2o.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/dpt_i2o.c 2004-09-17 06:45:29.000000000 -0700 +@@ -2151,7 +2151,13 @@ + for(i = 0 ; i < cmd->use_sg; i++) { + *mptr++ = direction|0x10000000|sg->length; + len+=sg->length; ++#if SMALL_SCATTERLIST ++ if (sg->ispaged) ++ BUG(); ++ *mptr++ = virt_to_bus(sg->u.address); ++#else + *mptr++ = virt_to_bus(sg->address); ++#endif + sg++; + } + /* Make this an end of list */ +Index: linux-2.4.21/drivers/scsi/scsi_debug.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/scsi_debug.c 2002-11-28 15:53:14.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/scsi_debug.c 2004-09-17 06:45:29.000000000 -0700 +@@ -186,7 +186,13 @@ + struct scatterlist *sgpnt = (struct scatterlist *) + SCpnt->request_buffer; + ++#if SMALL_SCATTERLIST ++ if (sgpnt[0].ispaged) ++ BUG(); ++ buff = sgpnt[0].u.address; ++#else + buff = sgpnt[0].address; ++#endif + bufflen = sgpnt[0].length; + /* READ and WRITE process scatterlist themselves */ + } +@@ -672,7 +678,13 @@ + if (SCpnt->use_sg) { + sgcount = 0; + sgpnt = (struct scatterlist *) buff; ++#if SMALL_SCATTERLIST ++ if (sgpnt[sgcount].ispaged) ++ BUG(); ++ buff = sgpnt[sgcount].u.address; ++#else + buff = sgpnt[sgcount].address; ++#endif + bufflen = sgpnt[sgcount].length; + } + do { +@@ -682,7 +694,13 @@ + block += bufflen >> POW2_SECT_SIZE; + sgcount++; + if (nbytes) { ++#if SMALL_SCATTERLIST ++ if (sgpnt[sgcount].ispaged) ++ BUG(); ++ buff = sgpnt[sgcount].u.address; ++#else + buff = sgpnt[sgcount].address; ++#endif + bufflen = sgpnt[sgcount].length; + } + } else if (nbytes > 0) +@@ -713,7 +731,13 @@ + if (SCpnt->use_sg) { + sgcount = 0; + sgpnt = (struct scatterlist *) buff; ++#if SMALL_SCATTERLIST ++ if (sgpnt[sgcount].ispaged) ++ BUG(); ++ buff = sgpnt[sgcount].u.address; ++#else + buff = sgpnt[sgcount].address; ++#endif + bufflen = sgpnt[sgcount].length; + } + do { +@@ -724,7 +748,13 @@ + block += bufflen >> POW2_SECT_SIZE; + sgcount++; + if (nbytes) { ++#if SMALL_SCATTERLIST ++ if (sgpnt[sgcount].ispaged) ++ BUG(); ++ buff = sgpnt[sgcount].u.address; ++#else + buff = sgpnt[sgcount].address; ++#endif + bufflen = sgpnt[sgcount].length; + } + } else if (nbytes > 0) +Index: linux-2.4.21/drivers/scsi/scsi_lib.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/scsi_lib.c 2004-09-11 07:16:39.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/scsi_lib.c 2004-09-17 06:45:29.000000000 -0700 +@@ -549,7 +549,13 @@ + if (bbpnt) { + for (i = 0; i < SCpnt->use_sg; i++) { + if (bbpnt[i]) ++#if SMALL_SCATTERLIST ++ if (sgpnt[i].ispaged) ++ BUG(); ++ scsi_free(sgpnt[i].u.address, sgpnt[i].length); ++#else + scsi_free(sgpnt[i].address, sgpnt[i].length); ++#endif + } + } + scsi_free(SCpnt->request_buffer, SCpnt->sglist_len); +@@ -625,12 +631,23 @@ + if (bbpnt) { + for (i = 0; i < SCpnt->use_sg; i++) { + if (bbpnt[i]) { ++#if SMALL_SCATTERLIST ++ if (sgpnt[i].ispaged) ++ BUG(); ++ if (req->cmd == READ) { ++ memcpy(bbpnt[i], ++ sgpnt[i].u.address, ++ sgpnt[i].length); ++ } ++ scsi_free(sgpnt[i].u.address, sgpnt[i].length); ++#else + if (req->cmd == READ) { + memcpy(bbpnt[i], + sgpnt[i].address, + sgpnt[i].length); + } + scsi_free(sgpnt[i].address, sgpnt[i].length); ++#endif + } + } + } +Index: linux-2.4.21/drivers/scsi/scsi_merge.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/scsi_merge.c 2004-09-11 07:16:18.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/scsi_merge.c 2004-09-17 06:45:29.000000000 -0700 +@@ -144,11 +144,21 @@ + */ + for(jj=0; jj < SCpnt->use_sg; jj++) + { ++#if SMALL_SCATTERLIST ++ if (sgpnt[jj].ispaged) ++ BUG(); ++ printk("[%d]\tlen:%d\taddr:%p\tbounce:%p\n", ++ jj, ++ sgpnt[jj].length, ++ sgpnt[jj].u.address, ++ (bbpnt ? bbpnt[jj] : NULL)); ++#else + printk("[%d]\tlen:%d\taddr:%p\tbounce:%p\n", + jj, + sgpnt[jj].length, + sgpnt[jj].address, + (bbpnt ? bbpnt[jj] : NULL)); ++#endif + if (bbpnt && bbpnt[jj]) + consumed += sgpnt[jj].length; + } +@@ -612,6 +622,9 @@ + max_segments = scsi_max_sg; + + #ifdef DMA_CHUNK_SIZE ++# if SMALL_SCATTERLIST ++# error "This defeats the purpose of SMALL_SCATTERLIST" ++# endif + if (max_segments > 64) + max_segments = 64; + +@@ -929,15 +942,26 @@ + } + + if (SCpnt->host->highmem_io) { ++#if SMALL_SCATTERLIST ++ sgpnt[count].ispaged = 1; ++ sgpnt[count].u.page.page = bh->b_page; ++ sgpnt[count].u.page.offset = bh_offset(bh); ++#else + sgpnt[count].page = bh->b_page; + sgpnt[count].offset = bh_offset(bh); + sgpnt[count].address = NULL; ++#endif + } else { + if (PageHighMem(bh->b_page)) + BUG(); + ++#if SMALL_SCATTERLIST ++ sgpnt[count].ispaged = 0; ++ sgpnt[count].u.address = bh->b_data; ++#else + sgpnt[count].page = NULL; + sgpnt[count].address = bh->b_data; ++#endif + } + + sgpnt[count].length = bh->b_size; +@@ -972,6 +996,50 @@ + * only done for dma_host, in which case .page is not + * set since it's guarenteed to be a low memory page + */ ++#if SMALL_SCATTERLIST ++ if (sgpnt[i].ispaged) ++ BUG(); ++ if (virt_to_phys(sgpnt[i].u.address) + sgpnt[i].length - 1 > ++ ISA_DMA_THRESHOLD) { ++ if( scsi_dma_free_sectors - sectors <= 10 ) { ++ /* ++ * If this would nearly drain the DMA ++ * pool empty, then let's stop here. ++ * Don't make this request any larger. ++ * This is kind of a safety valve that ++ * we use - we could get screwed later ++ * on if we run out completely. ++ */ ++ SCpnt->request_bufflen -= sgpnt[i].length; ++ SCpnt->use_sg = i; ++ if (i == 0) { ++ goto big_trouble; ++ } ++ break; ++ } ++ ++ bbpnt[i] = sgpnt[i].u.address; ++ sgpnt[i].u.address = ++ (char *) scsi_malloc(sgpnt[i].length); ++ /* ++ * If we cannot allocate memory for this DMA bounce ++ * buffer, then queue just what we have done so far. ++ */ ++ if (sgpnt[i].u.address == NULL) { ++ printk("Warning - running low on DMA memory\n"); ++ SCpnt->request_bufflen -= sgpnt[i].length; ++ SCpnt->use_sg = i; ++ if (i == 0) { ++ goto big_trouble; ++ } ++ break; ++ } ++ if (req->cmd == WRITE) { ++ memcpy(sgpnt[i].u.address, bbpnt[i], ++ sgpnt[i].length); ++ } ++ } ++#else + if (virt_to_phys(sgpnt[i].address) + sgpnt[i].length - 1 > + ISA_DMA_THRESHOLD) { + if( scsi_dma_free_sectors - sectors <= 10 ) { +@@ -1012,6 +1080,7 @@ + sgpnt[i].length); + } + } ++#endif + } + return 1; + +Index: linux-2.4.21/drivers/scsi/sg.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/sg.c 2004-09-11 07:16:20.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/sg.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1068,7 +1068,11 @@ + + for (k = 0; k < rsv_schp->k_use_sg; ++k, ++sclp) { + for (m = PAGE_SIZE; m < sclp->length; m += PAGE_SIZE) { ++#if SMALL_SCATTERLIST ++ page_ptr = (unsigned char *)sclp->u.address + m; ++#else + page_ptr = (unsigned char *)sclp->address + m; ++#endif + page = virt_to_page(page_ptr); + if (startFinish) + get_page(page); /* increment page count */ +@@ -1121,7 +1125,11 @@ + len = vma->vm_end - sa; + len = (len < sclp->length) ? len : sclp->length; + if (offset < len) { ++#if SMALL_SCATTERLIST ++ page_ptr = (unsigned char *)sclp->u.address + offset; ++#else + page_ptr = (unsigned char *)sclp->address + offset; ++#endif + page = virt_to_page(page_ptr); + get_page(page); /* increment page count */ + break; +@@ -1166,8 +1174,13 @@ + + for (k = 0; (k < rsv_schp->k_use_sg) && (sa < vma->vm_end); + ++k, ++sclp) { ++#if SMALL_SCATTERLIST ++ if ((unsigned long)sclp->u.address & (PAGE_SIZE - 1)) ++ return -EFAULT; /* non page aligned memory ?? */ ++#else + if ((unsigned long)sclp->address & (PAGE_SIZE - 1)) + return -EFAULT; /* non page aligned memory ?? */ ++#endif + len = vma->vm_end - sa; + len = (len < sclp->length) ? len : sclp->length; + sa += len; +@@ -1716,16 +1729,27 @@ + offset = (0 == k) ? kp->offset : 0; + num = (rem_sz > (PAGE_SIZE - offset)) ? (PAGE_SIZE - offset) : + rem_sz; ++#if SMALL_SCATTERLIST ++ sclp->u.address = page_address(kp->maplist[k]) + offset; ++ sclp->ispaged = 0; ++#else + sclp->address = page_address(kp->maplist[k]) + offset; + #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,13) + sclp->page = NULL; + #endif ++#endif + sclp->length = num; + mem_src_arr[k] = SG_USER_MEM; + rem_sz -= num; ++#if SMALL_SCATTERLIST ++ SCSI_LOG_TIMEOUT(5, ++ printk("sg_build_dir: k=%d, a=0x%p, len=%d, ms=%d\n", ++ k, sclp->u.address, num, mem_src_arr[k])); ++#else + SCSI_LOG_TIMEOUT(5, + printk("sg_build_dir: k=%d, a=0x%p, len=%d, ms=%d\n", + k, sclp->address, num, mem_src_arr[k])); ++#endif + } + schp->k_use_sg = k; + SCSI_LOG_TIMEOUT(5, +@@ -1805,16 +1829,27 @@ + if (! p) + break; + } ++#if SMALL_SCATTERLIST ++ sclp->u.address = p; ++ sclp->ispaged = 0; ++#else + sclp->address = p; + #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,13) + sclp->page = NULL; + #endif ++#endif + sclp->length = ret_sz; + mem_src_arr[k] = mem_src; + ++#if SMALL_SCATTERLIST ++ SCSI_LOG_TIMEOUT(5, ++ printk("sg_build_build: k=%d, a=0x%p, len=%d, ms=%d\n", ++ k, sclp->u.address, ret_sz, mem_src)); ++#else + SCSI_LOG_TIMEOUT(5, + printk("sg_build_build: k=%d, a=0x%p, len=%d, ms=%d\n", + k, sclp->address, ret_sz, mem_src)); ++#endif + } /* end of for loop */ + schp->k_use_sg = k; + SCSI_LOG_TIMEOUT(5, +@@ -1879,13 +1914,21 @@ + struct scatterlist * sclp = (struct scatterlist *)schp->buffer; + char * mem_src_arr = sg_get_sgat_msa(schp); + ksglen = (int)sclp->length; ++#if SMALL_SCATTERLIST ++ p = sclp->u.address; ++#else + p = sclp->address; ++#endif + + for (j = 0, k = 0; j < onum; ++j) { + res = sg_u_iovec(hp, iovec_count, j, 1, &usglen, &up); + if (res) return res; + ++#if SMALL_SCATTERLIST ++ for ( ; p; ++sclp, ksglen = (int)sclp->length, p = sclp->u.address) { ++#else + for ( ; p; ++sclp, ksglen = (int)sclp->length, p = sclp->address) { ++#endif + ok = (SG_USER_MEM != mem_src_arr[k]); + if (usglen <= 0) + break; +@@ -1962,6 +2005,18 @@ + struct scatterlist * sclp = (struct scatterlist *)schp->buffer; + char * mem_src_arr = sg_get_sgat_msa(schp); + ++#if SMALL_SCATTERLIST ++ for (k = 0; (k < schp->k_use_sg) && sclp->u.address; ++k, ++sclp) { ++ mem_src = mem_src_arr[k]; ++ SCSI_LOG_TIMEOUT(5, ++ printk("sg_remove_scat: k=%d, a=0x%p, len=%d, ms=%d\n", ++ k, sclp->u.address, sclp->length, mem_src)); ++ sg_free(sclp->u.address, sclp->length, mem_src); ++ sclp->u.address = NULL; ++ sclp->ispaged = 0; ++ sclp->length = 0; ++ } ++#else + for (k = 0; (k < schp->k_use_sg) && sclp->address; ++k, ++sclp) { + mem_src = mem_src_arr[k]; + SCSI_LOG_TIMEOUT(5, +@@ -1974,6 +2029,7 @@ + #endif + sclp->length = 0; + } ++#endif + sg_free(schp->buffer, schp->sglist_len, schp->buffer_mem_src); + } + else if (schp->buffer) +@@ -2034,13 +2090,21 @@ + struct scatterlist * sclp = (struct scatterlist *)schp->buffer; + char * mem_src_arr = sg_get_sgat_msa(schp); + ksglen = (int)sclp->length; ++#if SMALL_SCATTERLIST ++ p = sclp->u.address; ++#else + p = sclp->address; ++#endif + + for (j = 0, k = 0; j < onum; ++j) { + res = sg_u_iovec(hp, iovec_count, j, 0, &usglen, &up); + if (res) return res; + ++#if SMALL_SCATTERLIST ++ for ( ; p; ++sclp, ksglen = (int)sclp->length, p = sclp->u.address) { ++#else + for ( ; p; ++sclp, ksglen = (int)sclp->length, p = sclp->address) { ++#endif + ok = (SG_USER_MEM != mem_src_arr[k]); + if (usglen <= 0) + break; +@@ -2084,14 +2148,26 @@ + int k, num; + struct scatterlist * sclp = (struct scatterlist *)schp->buffer; + ++#if SMALL_SCATTERLIST ++ for (k = 0; (k < schp->k_use_sg) && sclp->u.address; ++k, ++sclp) { ++#else + for (k = 0; (k < schp->k_use_sg) && sclp->address; ++k, ++sclp) { ++#endif + num = (int)sclp->length; + if (num > num_read_xfer) { ++#if SMALL_SCATTERLIST ++ __copy_to_user(outp, sclp->u.address, num_read_xfer); ++#else + __copy_to_user(outp, sclp->address, num_read_xfer); ++#endif + break; + } + else { ++#if SMALL_SCATTERLIST ++ __copy_to_user(outp, sclp->u.address, num); ++#else + __copy_to_user(outp, sclp->address, num); ++#endif + num_read_xfer -= num; + if (num_read_xfer <= 0) + break; +@@ -2137,7 +2213,11 @@ + if (rem <= num) { + if (0 == k) { + req_schp->k_use_sg = 0; ++#if SMALL_SCATTERLIST ++ req_schp->buffer = sclp->u.address; ++#else + req_schp->buffer = sclp->address; ++#endif + } + else { + sfp->save_scat_len = num; +Index: linux-2.4.21/drivers/scsi/sr.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/sr.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/sr.c 2004-09-17 06:45:29.000000000 -0700 +@@ -343,7 +343,12 @@ + + i = 0; + if (fsize) { ++#if SMALL_SCATTERLIST ++ sg[0].ispaged = 0; ++ sg[0].u.address = bbpnt[0] = front; ++#else + sg[0].address = bbpnt[0] = front; ++#endif + sg[0].length = fsize; + i++; + } +@@ -354,7 +359,12 @@ + scsi_free(old_sg, (((SCpnt->use_sg * sizeof(struct scatterlist)) + + (SCpnt->use_sg * sizeof(void *))) + 511) & ~511); + } else { ++#if SMALL_SCATTERLIST ++ sg[i].ispaged = 0; ++ sg[i].u.address = SCpnt->request_buffer; ++#else + sg[i].address = SCpnt->request_buffer; ++#endif + sg[i].length = SCpnt->request_bufflen; + } + +@@ -364,7 +374,12 @@ + SCpnt->use_sg += i; + + if (bsize) { ++#if SMALL_SCATTERLIST ++ sg[SCpnt->use_sg].ispaged = 0; ++ sg[SCpnt->use_sg].u.address = back; ++#else + sg[SCpnt->use_sg].address = back; ++#endif + bbpnt[SCpnt->use_sg] = back; + sg[SCpnt->use_sg].length = bsize; + SCpnt->use_sg++; +Index: linux-2.4.21/drivers/scsi/sim710.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/sim710.c 2002-08-02 17:39:44.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/sim710.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1164,7 +1164,11 @@ + + for (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; i++) { + u32 vbuf = cmd->use_sg ? ++#if SMALL_SCATTERLIST ++ (u32)(((struct scatterlist *)cmd->buffer)[i].u.address) : ++#else + (u32)(((struct scatterlist *)cmd->buffer)[i].address) : ++#endif + (u32)(cmd->request_buffer); + u32 bbuf = virt_to_bus((void *)vbuf); + u32 cnt = cmd->use_sg ? +Index: linux-2.4.21/drivers/scsi/advansys.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/advansys.c 2004-09-11 07:16:38.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/advansys.c 2004-09-17 06:45:29.000000000 -0700 +@@ -6803,7 +6803,11 @@ + slp = (struct scatterlist *) scp->request_buffer; + for (sgcnt = 0; sgcnt < scp->use_sg; sgcnt++, slp++) { + asc_sg_head.sg_list[sgcnt].addr = ++#if SMALL_SCATTERLIST ++ cpu_to_le32(virt_to_bus(slp->u.address)); ++#else + cpu_to_le32(virt_to_bus(slp->address)); ++#endif + asc_sg_head.sg_list[sgcnt].bytes = cpu_to_le32(slp->length); + ASC_STATS_ADD(scp->host, sg_xfer, ASC_CEILING(slp->length, 512)); + } +@@ -7061,7 +7065,11 @@ + for (i = 0; i < NO_OF_SG_PER_BLOCK; i++) + { + sg_block->sg_list[i].sg_addr = ++#if SMALL_SCATTERLIST ++ cpu_to_le32(virt_to_bus(slp->u.address)); ++#else + cpu_to_le32(virt_to_bus(slp->address)); ++#endif + sg_block->sg_list[i].sg_count = cpu_to_le32(slp->length); + ASC_STATS_ADD(scp->host, sg_xfer, ASC_CEILING(slp->length, 512)); + +Index: linux-2.4.21/drivers/scsi/pci2000.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/pci2000.c 2001-11-09 14:05:06.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/pci2000.c 2004-09-17 06:45:29.000000000 -0700 +@@ -513,7 +513,11 @@ + + if ( SCpnt->use_sg ) + { ++#if SMALL_SCATTERLIST ++ SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)SCpnt->request_buffer)->u.address, ++#else + SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)SCpnt->request_buffer)->address, ++#endif + SCpnt->request_bufflen, scsi_to_pci_dma_dir (SCpnt->sc_data_direction)); + } + else +@@ -536,7 +540,11 @@ + case SCSIOP_READ_CAPACITY: // read capacity CDB + if ( SCpnt->use_sg ) + { ++#if SMALL_SCATTERLIST ++ SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)(SCpnt->request_buffer))->u.address, ++#else + SCpnt->SCp.have_data_in = pci_map_single (padapter->pdev, ((struct scatterlist *)(SCpnt->request_buffer))->address, ++#endif + 8, PCI_DMA_FROMDEVICE); + } + else +Index: linux-2.4.21/drivers/scsi/pci2220i.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/pci2220i.c 2001-11-09 14:05:06.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/pci2220i.c 2004-09-17 06:45:29.000000000 -0700 +@@ -463,7 +463,11 @@ + { + if ( padapter->nextSg < padapter->SCpnt->use_sg ) + { ++#if SMALL_SCATTERLIST ++ padapter->currentSgBuffer = ((struct scatterlist *)padapter->SCpnt->request_buffer)[padapter->nextSg].u.address; ++#else + padapter->currentSgBuffer = ((struct scatterlist *)padapter->SCpnt->request_buffer)[padapter->nextSg].address; ++#endif + padapter->currentSgCount = ((struct scatterlist *)padapter->SCpnt->request_buffer)[padapter->nextSg].length; + padapter->nextSg++; + } +@@ -2057,7 +2061,11 @@ + + if ( SCpnt->use_sg ) + { ++#if SMALL_SCATTERLIST ++ padapter->currentSgBuffer = ((struct scatterlist *)SCpnt->request_buffer)[0].u.address; ++#else + padapter->currentSgBuffer = ((struct scatterlist *)SCpnt->request_buffer)[0].address; ++#endif + padapter->currentSgCount = ((struct scatterlist *)SCpnt->request_buffer)[0].length; + } + else +Index: linux-2.4.21/drivers/scsi/BusLogic.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/BusLogic.c 2001-12-21 09:41:55.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/BusLogic.c 2004-09-17 06:45:29.000000000 -0700 +@@ -3402,7 +3402,12 @@ + CCB->ScatterGatherList[Segment].SegmentByteCount = + ScatterList[Segment].length; + CCB->ScatterGatherList[Segment].SegmentDataPointer = ++#if SMALL_SCATTERLIST ++ Virtual_to_Bus(ScatterList[Segment].u.address); ++#else + Virtual_to_Bus(ScatterList[Segment].address); ++#endif ++ + } + } + switch (CDB[0]) +Index: linux-2.4.21/drivers/scsi/ultrastor.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/ultrastor.c 2002-08-02 17:39:44.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/ultrastor.c 2004-09-17 06:45:29.000000000 -0700 +@@ -666,7 +666,11 @@ + sl = (struct scatterlist *) SCpnt->request_buffer; + max = SCpnt->use_sg; + for (i = 0; i < max; i++) { ++#if SMALL_SCATTERLIST ++ mscp->sglist[i].address = virt_to_bus(sl[i].u.address); ++#else + mscp->sglist[i].address = virt_to_bus(sl[i].address); ++#endif + mscp->sglist[i].num_bytes = sl[i].length; + transfer_length += sl[i].length; + } +Index: linux-2.4.21/drivers/scsi/aha152x.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/aha152x.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/aha152x.c 2004-09-17 06:45:29.000000000 -0700 +@@ -603,7 +603,11 @@ + #define SCSEM(SCpnt) SCDATA(SCpnt)->sem + + #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0) ++#if SMALL_SCATTERLIST ++#define SG_ADDRESS(buffer) ((buffer)->u.address) ++#else + #define SG_ADDRESS(buffer) ((buffer)->address) ++#endif + #else + #define SG_ADDRESS(buffer) ((char *) (page_address((buffer)->page)+(buffer)->offset)) + #endif +Index: linux-2.4.21/drivers/scsi/aha1542.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/aha1542.c 2001-10-12 15:35:53.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/aha1542.c 2004-09-17 06:45:29.000000000 -0700 +@@ -69,8 +69,13 @@ + { + printk(KERN_CRIT "sgpnt[%d:%d] addr %p/0x%lx length %d\n", + badseg, nseg, ++#if SMALL_SCATTERLIST ++ sgpnt[badseg].u.address, ++ SCSI_PA(sgpnt[badseg].u.address), ++#else + sgpnt[badseg].address, + SCSI_PA(sgpnt[badseg].address), ++#endif + sgpnt[badseg].length); + + /* +@@ -710,11 +715,21 @@ + panic("aha1542.c: unable to allocate DMA memory\n"); + for (i = 0; i < SCpnt->use_sg; i++) { + if (sgpnt[i].length == 0 || SCpnt->use_sg > 16 || +- (((int) sgpnt[i].address) & 1) || (sgpnt[i].length & 1)) { ++#if SMALL_SCATTERLIST ++ (((int) sgpnt[i].u.address) & 1) ++#else ++ (((int) sgpnt[i].address) & 1) ++#endif ++ || (sgpnt[i].length & 1)) { + unsigned char *ptr; + printk(KERN_CRIT "Bad segment list supplied to aha1542.c (%d, %d)\n", SCpnt->use_sg, i); + for (i = 0; i < SCpnt->use_sg; i++) { +- printk(KERN_CRIT "%d: %p %d\n", i, sgpnt[i].address, ++ printk(KERN_CRIT "%d: %p %d\n", i, ++#if SMALL_SCATTERLIST ++ sgpnt[i].u.address, ++#else ++ sgpnt[i].address, ++#endif + sgpnt[i].length); + }; + printk(KERN_CRIT "cptr %x: ", (unsigned int) cptr); +@@ -723,8 +738,13 @@ + printk("%02x ", ptr[i]); + panic("Foooooooood fight!"); + }; ++#if SMALL_SCATTERLIST ++ any2scsi(cptr[i].dataptr, SCSI_PA(sgpnt[i].u.address)); ++ if (SCSI_PA(sgpnt[i].u.address + sgpnt[i].length - 1) > ISA_DMA_THRESHOLD) ++#else + any2scsi(cptr[i].dataptr, SCSI_PA(sgpnt[i].address)); + if (SCSI_PA(sgpnt[i].address + sgpnt[i].length - 1) > ISA_DMA_THRESHOLD) ++#endif + BAD_SG_DMA(SCpnt, sgpnt, SCpnt->use_sg, i); + any2scsi(cptr[i].datalen, sgpnt[i].length); + }; +Index: linux-2.4.21/drivers/scsi/aha1740.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/aha1740.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/aha1740.c 2004-09-17 06:45:29.000000000 -0700 +@@ -397,7 +397,11 @@ + for(i=0; iuse_sg; i++) + { + cptr[i].datalen = sgpnt[i].length; ++#if SMALL_SCATTERLIST ++ cptr[i].dataptr = virt_to_bus(sgpnt[i].u.address); ++#else + cptr[i].dataptr = virt_to_bus(sgpnt[i].address); ++#endif + } + host->ecb[ecbno].datalen = SCpnt->use_sg * sizeof(struct aha1740_chain); + host->ecb[ecbno].dataptr = virt_to_bus(cptr); +Index: linux-2.4.21/drivers/scsi/aic7xxx_old.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/aic7xxx_old.c 2004-09-11 07:16:29.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/aic7xxx_old.c 2004-09-17 06:45:29.000000000 -0700 +@@ -2845,7 +2845,11 @@ + struct scatterlist *sg; + + sg = (struct scatterlist *)cmd->request_buffer; ++#if SMALL_SCATTERLIST ++ buffer = (char *)sg[0].u.address; ++#else + buffer = (char *)sg[0].address; ++#endif + } + else + { +Index: linux-2.4.21/drivers/scsi/fdomain.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/fdomain.c 2002-11-28 15:53:14.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/fdomain.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1564,7 +1564,11 @@ + if (current_SC->SCp.buffers_residual) { + --current_SC->SCp.buffers_residual; + ++current_SC->SCp.buffer; ++#if SMALL_SCATTERLIST ++ current_SC->SCp.ptr = current_SC->SCp.buffer->u.address; ++#else + current_SC->SCp.ptr = current_SC->SCp.buffer->address; ++#endif + current_SC->SCp.this_residual = current_SC->SCp.buffer->length; + } else + break; +@@ -1597,7 +1601,11 @@ + && current_SC->SCp.buffers_residual) { + --current_SC->SCp.buffers_residual; + ++current_SC->SCp.buffer; ++#if SMALL_SCATTERLIST ++ current_SC->SCp.ptr = current_SC->SCp.buffer->u.address; ++#else + current_SC->SCp.ptr = current_SC->SCp.buffer->address; ++#endif + current_SC->SCp.this_residual = current_SC->SCp.buffer->length; + } + } +@@ -1683,7 +1691,11 @@ + if (current_SC->use_sg) { + current_SC->SCp.buffer = + (struct scatterlist *)current_SC->request_buffer; ++#if SMALL_SCATTERLIST ++ current_SC->SCp.ptr = current_SC->SCp.buffer->u.address; ++#else + current_SC->SCp.ptr = current_SC->SCp.buffer->address; ++#endif + current_SC->SCp.this_residual = current_SC->SCp.buffer->length; + current_SC->SCp.buffers_residual = current_SC->use_sg - 1; + } else { +Index: linux-2.4.21/drivers/scsi/in2000.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/in2000.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/in2000.c 2004-09-17 06:45:29.000000000 -0700 +@@ -355,7 +355,11 @@ + if (cmd->use_sg) { + cmd->SCp.buffer = (struct scatterlist *)cmd->buffer; + cmd->SCp.buffers_residual = cmd->use_sg - 1; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = (char *)cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = (char *)cmd->SCp.buffer->address; ++#endif + cmd->SCp.this_residual = cmd->SCp.buffer->length; + } + else { +@@ -762,7 +766,11 @@ + ++cmd->SCp.buffer; + --cmd->SCp.buffers_residual; + cmd->SCp.this_residual = cmd->SCp.buffer->length; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = cmd->SCp.buffer->address; ++#endif + } + + /* Set up hardware registers */ +Index: linux-2.4.21/drivers/scsi/NCR5380.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/NCR5380.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/NCR5380.c 2004-09-17 06:45:29.000000000 -0700 +@@ -337,7 +337,11 @@ + if (cmd->use_sg) { + cmd->SCp.buffer = (struct scatterlist *) cmd->buffer; + cmd->SCp.buffers_residual = cmd->use_sg - 1; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = (char *) cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = (char *) cmd->SCp.buffer->address; ++#endif + cmd->SCp.this_residual = cmd->SCp.buffer->length; + } else { + cmd->SCp.buffer = NULL; +@@ -2308,7 +2312,11 @@ + ++cmd->SCp.buffer; + --cmd->SCp.buffers_residual; + cmd->SCp.this_residual = cmd->SCp.buffer->length; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = cmd->SCp.buffer->address; ++#endif + dprintk(NDEBUG_INFORMATION, ("scsi%d : %d bytes and %d buffers left\n", instance->host_no, cmd->SCp.this_residual, cmd->SCp.buffers_residual)); + } + /* +Index: linux-2.4.21/drivers/scsi/NCR53c406a.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/NCR53c406a.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/NCR53c406a.c 2004-09-17 06:45:29.000000000 -0700 +@@ -895,7 +895,11 @@ + sgcount = current_SC->use_sg; + sglist = current_SC->request_buffer; + while( sgcount-- ) { ++#if SMALL_SCATTERLIST ++ NCR53c406a_pio_write(sglist->u.address, sglist->length); ++#else + NCR53c406a_pio_write(sglist->address, sglist->length); ++#endif + sglist++; + } + } +@@ -924,7 +928,11 @@ + sgcount = current_SC->use_sg; + sglist = current_SC->request_buffer; + while( sgcount-- ) { ++#if SMALL_SCATTERLIST ++ NCR53c406a_pio_read(sglist->u.address, sglist->length); ++#else + NCR53c406a_pio_read(sglist->address, sglist->length); ++#endif + sglist++; + } + } +Index: linux-2.4.21/drivers/scsi/sym53c416.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/sym53c416.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/sym53c416.c 2004-09-17 06:45:29.000000000 -0700 +@@ -448,7 +448,11 @@ + sglist = current_command->request_buffer; + while(sgcount--) + { ++#if SMALL_SCATTERLIST ++ tot_trans += sym53c416_write(base, sglist->u.address, sglist->length); ++#else + tot_trans += sym53c416_write(base, sglist->address, sglist->length); ++#endif + sglist++; + } + } +@@ -474,7 +478,11 @@ + sglist = current_command->request_buffer; + while(sgcount--) + { ++#if SMALL_SCATTERLIST ++ tot_trans += sym53c416_read(base, sglist->u.address, sglist->length); ++#else + tot_trans += sym53c416_read(base, sglist->address, sglist->length); ++#endif + sglist++; + } + } +Index: linux-2.4.21/drivers/scsi/qlogicfas.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/qlogicfas.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/qlogicfas.c 2004-09-17 06:45:29.000000000 -0700 +@@ -393,7 +393,11 @@ + REG0; + return ((qabort == 1 ? DID_ABORT : DID_RESET) << 16); + } ++#if SMALL_SCATTERLIST ++ if (ql_pdma(phase, sglist->u.address, sglist->length)) ++#else + if (ql_pdma(phase, sglist->address, sglist->length)) ++#endif + break; + sglist++; + } +Index: linux-2.4.21/drivers/scsi/qla1280.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/qla1280.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/qla1280.c 2004-09-17 06:45:29.000000000 -0700 +@@ -3985,8 +3985,13 @@ + { + DEBUG(sprintf(debug_buff,"SG Segment ap=0x%p, len=0x%x\n\r",sg->address,sg->length)); + DEBUG(qla1280_print(debug_buff)); ++#if SMALL_SCATTERLIST ++ *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_LOW(sg->u.address)); ++ *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_HIGH(sg->u.address)); ++#else + *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_LOW(sg->address)); + *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_HIGH(sg->address)); ++#endif + *dword_ptr++ = sg->length; + sg++; + } +@@ -4038,8 +4043,13 @@ + /* Load continuation entry data segments. */ + for (cnt = 0; cnt < 5 && seg_cnt; cnt++, seg_cnt--) + { ++#if SMALL_SCATTERLIST ++ *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_LOW(sg->u.address)); ++ *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_HIGH(sg->u.address)); ++#else + *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_LOW(sg->address)); + *dword_ptr++ = cpu_to_le32(VIRT_TO_BUS_HIGH(sg->address)); ++#endif + *dword_ptr++ = sg->length; + sg++; + } +@@ -4325,7 +4335,11 @@ + /* Load command entry data segments. */ + for (cnt = 0; cnt < 4 && seg_cnt; cnt++, seg_cnt--) + { ++#if SMALL_SCATTERLIST ++ *dword_ptr++ = (uint32_t) cpu_to_le32(VIRT_TO_BUS(sg->u.address)); ++#else + *dword_ptr++ = (uint32_t) cpu_to_le32(VIRT_TO_BUS(sg->address)); ++#endif + *dword_ptr++ = sg->length; + DEBUG(sprintf(debug_buff,"SG Segment ap=0x%p, len=0x%x\n\r",sg->address,sg->length)); + DEBUG(qla1280_print(debug_buff)); +@@ -4368,7 +4382,11 @@ + /* Load continuation entry data segments. */ + for (cnt = 0; cnt < 7 && seg_cnt; cnt++, seg_cnt--) + { ++#if SMALL_SCATTERLIST ++ *dword_ptr++ = (u_int) cpu_to_le32(VIRT_TO_BUS(sg->u.address)); ++#else + *dword_ptr++ = (u_int) cpu_to_le32(VIRT_TO_BUS(sg->address)); ++#endif + *dword_ptr++ = sg->length; + sg++; + } +Index: linux-2.4.21/drivers/scsi/seagate.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/seagate.c 2004-09-11 07:16:10.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/seagate.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1070,7 +1070,11 @@ + + buffer = (struct scatterlist *) SCint->buffer; + len = buffer->length; ++#if SMALL_SCATTERLIST ++ data = (unsigned char *) buffer->u.address; ++#else + data = (unsigned char *) buffer->address; ++#endif + } else { + DPRINTK (DEBUG_SG, + "scsi%d : scatter gather not requested.\n", +@@ -1337,7 +1341,11 @@ + ++buffer; + len = buffer->length; + data = +- (unsigned char *) buffer->address; ++#if SMALL_SCATTERLIST ++ (unsigned char *)buffer->u.address; ++#else ++ (unsigned char *)buffer->address; ++#endif + DPRINTK (DEBUG_SG, + "scsi%d : next scatter-gather buffer len = %d address = %08x\n", + hostno, len, data); +@@ -1521,7 +1529,11 @@ + ++buffer; + len = buffer->length; + data = ++#if SMALL_SCATTERLIST ++ (unsigned char *)buffer->u.address; ++#else + (unsigned char *) buffer->address; ++#endif + DPRINTK (DEBUG_SG, + "scsi%d : next scatter-gather buffer len = %d address = %08x\n", + hostno, len, data); +Index: linux-2.4.21/drivers/scsi/53c7,8xx.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/53c7,8xx.c 2002-02-25 11:38:04.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/53c7,8xx.c 2004-09-17 06:45:29.000000000 -0700 +@@ -3787,7 +3787,11 @@ + for (i = 0; cmd->use_sg ? (i < cmd->use_sg) : !i; cmd_datain += 4, + cmd_dataout += 4, ++i) { + u32 buf = cmd->use_sg ? ++#if SMALL_SCATTERLIST ++ virt_to_bus(((struct scatterlist *)cmd->buffer)[i].u.address) : ++#else + virt_to_bus(((struct scatterlist *)cmd->buffer)[i].address) : ++#endif + virt_to_bus(cmd->request_buffer); + u32 count = cmd->use_sg ? + ((struct scatterlist *)cmd->buffer)[i].length : +@@ -5752,8 +5756,13 @@ + if ((buffers = cmd->use_sg)) { + for (offset = 0, + segment = (struct scatterlist *) cmd->buffer; ++#if SMALL_SCATTERLIST ++ buffers && !((found = ((ptr >= segment->u.address) && ++ (ptr < (segment->u.address + segment->length))))); ++#else + buffers && !((found = ((ptr >= segment->address) && + (ptr < (segment->address + segment->length))))); ++#endif + --buffers, offset += segment->length, ++segment) + #if 0 + printk("scsi%d: comparing 0x%p to 0x%p\n", +@@ -5761,7 +5770,11 @@ + #else + ; + #endif ++#if SMALL_SCATTERLIST ++ offset += ptr - segment->u.address; ++#else + offset += ptr - segment->address; ++#endif + } else { + found = 1; + offset = ptr - (char *) (cmd->request_buffer); +Index: linux-2.4.21/drivers/scsi/eata_dma.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/eata_dma.c 2004-09-11 07:16:38.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/eata_dma.c 2004-09-17 06:45:29.000000000 -0700 +@@ -571,7 +571,11 @@ + ccb->cp_datalen = htonl(cmd->use_sg * sizeof(struct eata_sg_list)); + sl=(struct scatterlist *)cmd->request_buffer; + for(i = 0; i < cmd->use_sg; i++, sl++){ ++#if SMALL_SCATTERLIST ++ ccb->sg_list[i].data = htonl(virt_to_bus(sl->u.address)); ++#else + ccb->sg_list[i].data = htonl(virt_to_bus(sl->address)); ++#endif + ccb->sg_list[i].len = htonl((u32) sl->length); + } + } else { +Index: linux-2.4.21/drivers/scsi/eata_pio.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/eata_pio.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/eata_pio.c 2004-09-17 06:45:29.000000000 -0700 +@@ -99,7 +99,11 @@ + else + { + SCp->buffer++; ++#if SMALL_SCATTERLIST ++ SCp->ptr=SCp->buffer->u.address; ++#else + SCp->ptr=SCp->buffer->address; ++#endif + SCp->this_residual=SCp->buffer->length; + } + } +@@ -371,7 +375,11 @@ + } else { + cmd->SCp.buffer = cmd->request_buffer; + cmd->SCp.buffers_residual = cmd->use_sg; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = cmd->SCp.buffer->address; ++#endif + cmd->SCp.this_residual = cmd->SCp.buffer->length; + } + cmd->SCp.Status = (cmd->SCp.this_residual != 0); /* TRUE as long as bytes +Index: linux-2.4.21/drivers/scsi/wd7000.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/wd7000.c 2001-09-30 12:26:08.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/wd7000.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1189,7 +1189,11 @@ + any2scsi (scb->maxlen, SCpnt->use_sg * sizeof (Sgb)); + + for (i = 0; i < SCpnt->use_sg; i++) { ++#if SMALL_SCATTERLIST ++ any2scsi (sgb[i].ptr, (int) sg[i].u.address); ++#else + any2scsi (sgb[i].ptr, (int) sg[i].address); ++#endif + any2scsi (sgb[i].len, sg[i].length); + } + } +Index: linux-2.4.21/drivers/scsi/scsiiom.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/scsiiom.c 2000-12-31 11:06:00.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/scsiiom.c 2004-09-17 06:45:29.000000000 -0700 +@@ -379,7 +379,11 @@ + pSRB->pSegmentList++; + psgl = pSRB->pSegmentList; + ++#if SMALL_SCATTERLIST ++ pSRB->SGBusAddr = virt_to_bus( psgl->u.address ); ++#else + pSRB->SGBusAddr = virt_to_bus( psgl->address ); ++#endif + pSRB->SGToBeXferLen = (ULONG) psgl->length; + } + else +@@ -443,7 +447,11 @@ + pSRB->pSegmentList++; + psgl = pSRB->pSegmentList; + ++#if SMALL_SCATTERLIST ++ pSRB->SGBusAddr = virt_to_bus( psgl->u.address ); ++#else + pSRB->SGBusAddr = virt_to_bus( psgl->address ); ++#endif + pSRB->SGToBeXferLen = (ULONG) psgl->length; + } + else +@@ -742,7 +750,11 @@ + pSRB->pSegmentList++; + psgl = pSRB->pSegmentList; + ++#if SMALL_SCATTERLIST ++ pSRB->SGBusAddr = virt_to_bus( psgl->u.address ); ++#else + pSRB->SGBusAddr = virt_to_bus( psgl->address ); ++#endif + pSRB->SGToBeXferLen = (ULONG) psgl->length; + } + else +@@ -756,10 +768,17 @@ + { + pSRB->SGcount = 1; + pSRB->pSegmentList = (PSGL) &pSRB->Segmentx; ++#if SMALL_SCATTERLIST ++ pSRB->Segmentx.u.address = (PUCHAR) pSRB->pcmd->request_buffer + pSRB->Saved_Ptr; ++ pSRB->Segmentx.length = pSRB->pcmd->request_bufflen - pSRB->Saved_Ptr; ++ printk (KERN_INFO "DC390: Pointer restored. Total %li, Bus %p\n", ++ pSRB->Saved_Ptr, pSRB->Segmentx.u.address); ++#else + pSRB->Segmentx.address = (PUCHAR) pSRB->pcmd->request_buffer + pSRB->Saved_Ptr; + pSRB->Segmentx.length = pSRB->pcmd->request_bufflen - pSRB->Saved_Ptr; + printk (KERN_INFO "DC390: Pointer restored. Total %li, Bus %p\n", + pSRB->Saved_Ptr, pSRB->Segmentx.address); ++#endif + } + else + { +@@ -893,7 +912,11 @@ + if( !pSRB->SGToBeXferLen ) + { + psgl = pSRB->pSegmentList; ++#if SMALL_SCATTERLIST ++ pSRB->SGBusAddr = virt_to_bus( psgl->u.address ); ++#else + pSRB->SGBusAddr = virt_to_bus( psgl->address ); ++#endif + pSRB->SGToBeXferLen = (ULONG) psgl->length; + DEBUG1(printk (KERN_DEBUG " DC390: Next SG segment.");) + } +@@ -1368,7 +1391,11 @@ + status = pSRB->TargetStatus; + ptr = (PSCSI_INQDATA) (pcmd->request_buffer); + if( pcmd->use_sg ) ++#if SMALL_SCATTERLIST ++ ptr = (PSCSI_INQDATA) (((PSGL) ptr)->u.address); ++#else + ptr = (PSCSI_INQDATA) (((PSGL) ptr)->address); ++#endif + + DEBUG0(printk (" SRBdone (%02x,%08x), SRB %p, pid %li\n", status, pcmd->result,\ + pSRB, pcmd->pid);) +@@ -1443,7 +1470,11 @@ + else if( pcmd->request_buffer ) + { + pSRB->pSegmentList = (PSGL) &pSRB->Segmentx; ++#if SMALL_SCATTERLIST ++ pSRB->Segmentx.u.address = (PUCHAR) pcmd->request_buffer; ++#else + pSRB->Segmentx.address = (PUCHAR) pcmd->request_buffer; ++#endif + pSRB->Segmentx.length = pcmd->request_bufflen; + } + if( dc390_StartSCSI( pACB, pDCB, pSRB ) ) { +@@ -1518,7 +1549,11 @@ + else if( pcmd->request_buffer ) + { + pSRB->pSegmentList = (PSGL) &pSRB->Segmentx; ++#if SMALL_SCATTERLIST ++ pSRB->Segmentx.u.address = (PUCHAR) pcmd->request_buffer; ++#else + pSRB->Segmentx.address = (PUCHAR) pcmd->request_buffer; ++#endif + pSRB->Segmentx.length = pcmd->request_bufflen; + } + if( dc390_StartSCSI( pACB, pDCB, pSRB ) ) { +@@ -1759,7 +1794,11 @@ + + pcmd = pSRB->pcmd; + ++#if SMALL_SCATTERLIST ++ pSRB->Segmentx.u.address = (PUCHAR) &(pcmd->sense_buffer); ++#else + pSRB->Segmentx.address = (PUCHAR) &(pcmd->sense_buffer); ++#endif + pSRB->Segmentx.length = sizeof(pcmd->sense_buffer); + pSRB->pSegmentList = &pSRB->Segmentx; + pSRB->SGcount = 1; +Index: linux-2.4.21/drivers/scsi/tmscsim.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/tmscsim.c 2001-12-21 09:41:55.000000000 -0800 ++++ linux-2.4.21/drivers/scsi/tmscsim.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1146,7 +1146,11 @@ + { + pSRB->SGcount = 1; + pSRB->pSegmentList = (PSGL) &pSRB->Segmentx; ++#if SMALL_SCATTERLIST ++ pSRB->Segmentx.u.address = (PUCHAR) pcmd->request_buffer; ++#else + pSRB->Segmentx.address = (PUCHAR) pcmd->request_buffer; ++#endif + pSRB->Segmentx.length = pcmd->request_bufflen; + } + else +Index: linux-2.4.21/drivers/scsi/AM53C974.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/AM53C974.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/AM53C974.c 2004-09-17 06:45:29.000000000 -0700 +@@ -842,7 +842,11 @@ + if (cmd->use_sg) { + cmd->SCp.buffer = (struct scatterlist *) cmd->buffer; + cmd->SCp.buffers_residual = cmd->use_sg - 1; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = (char *) cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = (char *) cmd->SCp.buffer->address; ++#endif + cmd->SCp.this_residual = cmd->SCp.buffer->length; + } else { + cmd->SCp.buffer = NULL; +@@ -1555,7 +1559,11 @@ + if ((!cmd->SCp.this_residual) && cmd->SCp.buffers_residual) { + cmd->SCp.buffer++; + cmd->SCp.buffers_residual--; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = (unsigned char *) cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = (unsigned char *) cmd->SCp.buffer->address; ++#endif + cmd->SCp.this_residual = cmd->SCp.buffer->length; + } + if (cmd->SCp.this_residual) { +Index: linux-2.4.21/drivers/scsi/megaraid2.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/megaraid2.c 2004-09-11 07:16:28.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/megaraid2.c 2004-09-17 06:45:29.000000000 -0700 +@@ -2197,7 +2197,11 @@ + if( cmd->use_sg ) { + sgl = (struct scatterlist *) + cmd->request_buffer; ++#if SMALL_SCATTERLIST ++ c = *(u8 *)sgl[0].u.address; ++#else + c = *(u8 *)sgl[0].address; ++#endif + } + else { + c = *(u8 *)cmd->request_buffer; +Index: linux-2.4.21/drivers/scsi/megaraid.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/megaraid.c 2004-09-11 07:16:28.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/megaraid.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1201,8 +1201,13 @@ + case READ_CAPACITY: + if ( SCpnt->use_sg ) { + sgList = (struct scatterlist *)SCpnt->request_buffer; ++#if SMALL_SCATTERLIST ++ memcpy(sgList[0].u.address, pScb->bounce_buffer, ++ SCpnt->request_bufflen); ++#else + memcpy(sgList[0].address, pScb->bounce_buffer, +- SCpnt->request_bufflen); ++ SCpnt->request_bufflen); ++#endif + } else { + memcpy (SCpnt->request_buffer, pScb->bounce_buffer, + SCpnt->request_bufflen); +@@ -1226,7 +1231,11 @@ + if (SCpnt->cmnd[0] == INQUIRY && !islogical) { + if ( SCpnt->use_sg ) { + sgList = (struct scatterlist *)SCpnt->request_buffer; ++#if SMALL_SCATTERLIST ++ memcpy(&c, sgList[0].u.address, 0x1); ++#else + memcpy(&c, sgList[0].address, 0x1); ++#endif + } else { + memcpy(&c, SCpnt->request_buffer, 0x1); + } +Index: linux-2.4.21/drivers/scsi/atp870u.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/atp870u.c 2002-08-02 17:39:44.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/atp870u.c 2004-09-17 06:45:29.000000000 -0700 +@@ -804,7 +804,11 @@ + sgpnt = (struct scatterlist *) workrequ->request_buffer; + i = 0; + for (j = 0; j < workrequ->use_sg; j++) { ++#if SMALL_SCATTERLIST ++ bttl = virt_to_bus(sgpnt[j].u.address); ++#else + bttl = virt_to_bus(sgpnt[j].address); ++#endif + l = sgpnt[j].length; + while (l > 0x10000) { + (unsigned short int) (((unsigned short int *) (prd))[i + 3]) = 0x0000; +Index: linux-2.4.21/drivers/scsi/gdth.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/gdth.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/gdth.c 2004-09-17 06:45:29.000000000 -0700 +@@ -2662,7 +2662,11 @@ + if (cpsum+cpnow > cpcount) + cpnow = cpcount - cpsum; + cpsum += cpnow; ++#if SMALL_SCATTERLIST ++ memcpy((char*)sl->u.address,buffer,cpnow); ++#else + memcpy((char*)sl->address,buffer,cpnow); ++#endif + if (cpsum == cpcount) + break; + buffer += cpnow; +@@ -2837,7 +2841,11 @@ + cmdp->u.cache.DestAddr= 0xffffffff; + sl = (struct scatterlist *)scp->request_buffer; + for (i=0; iuse_sg; ++i,++sl) { ++#if SMALL_SCATTERLIST ++ cmdp->u.cache.sg_lst[i].sg_ptr = virt_to_bus(sl->u.address); ++#else + cmdp->u.cache.sg_lst[i].sg_ptr = virt_to_bus(sl->address); ++#endif + cmdp->u.cache.sg_lst[i].sg_len = (ulong32)sl->length; + } + cmdp->u.cache.sg_canz = (ulong32)i; +@@ -2954,7 +2962,11 @@ + cmdp->u.raw.sdata = 0xffffffff; + sl = (struct scatterlist *)scp->request_buffer; + for (i=0; iuse_sg; ++i,++sl) { ++#if SMALL_SCATTERLIST ++ cmdp->u.raw.sg_lst[i].sg_ptr = virt_to_bus(sl->u.address); ++#else + cmdp->u.raw.sg_lst[i].sg_ptr = virt_to_bus(sl->address); ++#endif + cmdp->u.raw.sg_lst[i].sg_len = (ulong32)sl->length; + } + cmdp->u.raw.sg_ranz = (ulong32)i; +Index: linux-2.4.21/drivers/scsi/ini9100u.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/ini9100u.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/ini9100u.c 2004-09-17 06:45:29.000000000 -0700 +@@ -489,7 +489,11 @@ + if (SCpnt->use_sg) { + pSrbSG = (struct scatterlist *) SCpnt->request_buffer; + if (SCpnt->use_sg == 1) { /* If only one entry in the list *//* treat it as regular I/O */ ++#if SMALL_SCATTERLIST ++ pSCB->SCB_BufPtr = (U32) VIRT_TO_BUS(pSrbSG->u.address); ++#else + pSCB->SCB_BufPtr = (U32) VIRT_TO_BUS(pSrbSG->address); ++#endif + TotalLen = pSrbSG->length; + pSCB->SCB_SGLen = 0; + } else { /* Assign SG physical address */ +@@ -498,7 +502,11 @@ + for (i = 0, TotalLen = 0, pSG = &pSCB->SCB_SGList[0]; /* 1.01g */ + i < SCpnt->use_sg; + i++, pSG++, pSrbSG++) { ++#if SMALL_SCATTERLIST ++ pSG->SG_Ptr = (U32) VIRT_TO_BUS(pSrbSG->u.address); ++#else + pSG->SG_Ptr = (U32) VIRT_TO_BUS(pSrbSG->address); ++#endif + TotalLen += pSG->SG_Len = pSrbSG->length; + } + pSCB->SCB_SGLen = i; +Index: linux-2.4.21/drivers/scsi/inia100.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/inia100.c 2001-09-30 12:26:07.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/inia100.c 2004-09-17 06:45:29.000000000 -0700 +@@ -494,7 +494,11 @@ + pSCB->SCB_SGLen = (U32) (SCpnt->use_sg * 8); + pSrbSG = (struct scatterlist *) SCpnt->request_buffer; + for (i = 0; i < SCpnt->use_sg; i++, pSG++, pSrbSG++) { ++#if SMALL_SCATTERLIST ++ pSG->SG_Ptr = (U32) (VIRT_TO_BUS(pSrbSG->u.address)); ++#else + pSG->SG_Ptr = (U32) (VIRT_TO_BUS(pSrbSG->address)); ++#endif + pSG->SG_Len = (U32) pSrbSG->length; + TotalLen += (U32) pSrbSG->length; + } +Index: linux-2.4.21/drivers/scsi/ide-scsi.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/ide-scsi.c 2004-09-11 07:16:39.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/ide-scsi.c 2004-09-17 06:45:29.000000000 -0700 +@@ -154,7 +154,11 @@ + return; + } + count = IDE_MIN(pc->sg->length - pc->b_count, bcount); ++#if SMALL_SCATTERLIST ++ HWIF(drive)->atapi_input_bytes(drive, pc->sg->u.address + pc->b_count, count); ++#else + HWIF(drive)->atapi_input_bytes(drive, pc->sg->address + pc->b_count, count); ++#endif + bcount -= count; + pc->b_count += count; + if (pc->b_count == pc->sg->length) { +@@ -176,7 +180,11 @@ + return; + } + count = IDE_MIN(pc->sg->length - pc->b_count, bcount); ++#if SMALL_SCATTERLIST ++ HWIF(drive)->atapi_output_bytes(drive, pc->sg->u.address + pc->b_count, count); ++#else + HWIF(drive)->atapi_output_bytes(drive, pc->sg->address + pc->b_count, count); ++#endif + bcount -= count; + pc->b_count += count; + if (pc->b_count == pc->sg->length) { +@@ -1026,6 +1034,19 @@ + pc->request_transfer >> 10); + #endif /* IDESCSI_DEBUG_LOG */ + while (segments--) { ++#if SMALL_SCATTERLIST ++#if 1 ++ bh->b_data = sg->u.address; ++#else ++ if (sg->u.address) { ++ bh->b_page = virt_to_page(sg->u.address); ++ bh->b_data = (char *) ((unsigned long) sg->u.address & ~PAGE_MASK); ++ } else if (sg->u.page.page) { ++ bh->b_page = sg->u.page.page; ++ bh->b_data = (char *) sg->u.page.offset; ++ } ++#endif ++#else /* !SMALL_SCATTERLIST */ + #if 1 + bh->b_data = sg->address; + #else +@@ -1037,6 +1058,7 @@ + bh->b_data = (char *) sg->offset; + } + #endif ++#endif /* !SMALL_SCATTERLIST */ + bh->b_size = sg->length; + bh = bh->b_reqnext; + sg++; +Index: linux-2.4.21/drivers/scsi/ppa.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/ppa.c 2004-09-11 07:16:38.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/ppa.c 2004-09-17 06:45:29.000000000 -0700 +@@ -740,7 +740,11 @@ + if (cmd->SCp.buffers_residual--) { + cmd->SCp.buffer++; + cmd->SCp.this_residual = cmd->SCp.buffer->length; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = cmd->SCp.buffer->address; ++#endif + } + } + /* Now check to see if the drive is ready to comunicate */ +@@ -925,7 +929,11 @@ + /* if many buffers are available, start filling the first */ + cmd->SCp.buffer = (struct scatterlist *) cmd->request_buffer; + cmd->SCp.this_residual = cmd->SCp.buffer->length; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = cmd->SCp.buffer->address; ++#endif + } else { + /* else fill the only available buffer */ + cmd->SCp.buffer = NULL; +Index: linux-2.4.21/drivers/scsi/imm.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/imm.c 2004-09-11 07:16:38.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/imm.c 2004-09-17 06:45:29.000000000 -0700 +@@ -834,7 +834,11 @@ + if (cmd->SCp.buffers_residual--) { + cmd->SCp.buffer++; + cmd->SCp.this_residual = cmd->SCp.buffer->length; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = cmd->SCp.buffer->address; ++#endif + + /* + * Make sure that we transfer even number of bytes +@@ -1008,7 +1012,11 @@ + /* if many buffers are available, start filling the first */ + cmd->SCp.buffer = (struct scatterlist *) cmd->request_buffer; + cmd->SCp.this_residual = cmd->SCp.buffer->length; ++#if SMALL_SCATTERLIST ++ cmd->SCp.ptr = cmd->SCp.buffer->u.address; ++#else + cmd->SCp.ptr = cmd->SCp.buffer->address; ++#endif + } else { + /* else fill the only available buffer */ + cmd->SCp.buffer = NULL; +Index: linux-2.4.21/drivers/scsi/st.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/st.c 2004-09-11 07:16:35.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/st.c 2004-09-17 06:45:29.000000000 -0700 +@@ -3399,6 +3399,12 @@ + } + + ++#if SMALL_SCATTERLIST ++#define SG_ADDRESS(sg) ((sg).u.address) ++#else ++#define SG_ADDRESS(sg) ((sg).address) ++#endif ++ + /* Try to allocate a new tape buffer. Calling function must not hold + dev_arr_lock. */ + static ST_buffer * +@@ -3436,18 +3442,23 @@ + order++, b_size *= 2) + ; + for ( ; b_size >= PAGE_SIZE; order--, b_size /= 2) { +- tb->sg[0].address = ++ SG_ADDRESS(tb->sg[0]) = + (unsigned char *) __get_free_pages(priority, order); +- if (tb->sg[0].address != NULL) { ++ if (SG_ADDRESS(tb->sg[0]) != NULL) { + tb->sg_lengths[0] = b_size; + break; + } + } ++#if SMALL_SCATTERLIST ++ tb->sg[0].ispaged = 0; ++#else + tb->sg[0].page = NULL; +- if (tb->sg[segs].address == NULL) { ++#endif ++ if (SG_ADDRESS(tb->sg[segs]) == NULL) { + kfree(tb); + tb = NULL; +- } else { /* Got something, continue */ ++ } ++ else { /* Got something, continue */ + + for (b_size = PAGE_SIZE, order=0; + st_buffer_size > +@@ -3456,10 +3467,10 @@ + ; + for (segs = 1, got = tb->sg_lengths[0]; + got < st_buffer_size && segs < ST_FIRST_SG;) { +- tb->sg[segs].address = ++ SG_ADDRESS(tb->sg[segs]) = + (unsigned char *) __get_free_pages(priority, + order); +- if (tb->sg[segs].address == NULL) { ++ if (SG_ADDRESS(tb->sg[segs]) == NULL) { + if (st_buffer_size - got <= + (ST_FIRST_SG - segs) * b_size / 2) { + b_size /= 2; /* Large enough for the +@@ -3475,7 +3486,11 @@ + tb = NULL; + break; + } ++#if SMALL_SCATTERLIST ++ tb->sg[segs].ispaged = 0; ++#else + tb->sg[segs].page = NULL; ++#endif + tb->sg_lengths[segs] = b_size; + got += b_size; + segs++; +@@ -3489,7 +3504,7 @@ + return NULL; + } + tb->sg_segs = tb->orig_sg_segs = segs; +- tb->b_data = tb->sg[0].address; ++ tb->b_data = SG_ADDRESS(tb->sg[0]); + + DEBC(printk(ST_DEB_MSG + "st: Allocated tape buffer %d (%d bytes, %d segments, dma: %d, a: %p).\n", +@@ -3535,9 +3550,9 @@ + + for (segs = STbuffer->sg_segs, got = STbuffer->buffer_size; + segs < max_segs && got < new_size;) { +- STbuffer->sg[segs].address = ++ SG_ADDRESS(STbuffer->sg[segs]) = + (unsigned char *) __get_free_pages(priority, order); +- if (STbuffer->sg[segs].address == NULL) { ++ if (SG_ADDRESS(STbuffer->sg[segs]) == NULL) { + if (new_size - got <= (max_segs - segs) * b_size / 2) { + b_size /= 2; /* Large enough for the rest of the buffers */ + order--; +@@ -3549,7 +3564,11 @@ + normalize_buffer(STbuffer); + return FALSE; + } ++#if SMALL_SCATTERLIST ++ STbuffer->sg[segs].ispaged = 0; ++#else + STbuffer->sg[segs].page = NULL; ++#endif + STbuffer->sg_lengths[segs] = b_size; + STbuffer->sg_segs += 1; + got += b_size; +@@ -3573,13 +3592,13 @@ + for (b_size=PAGE_SIZE, order=0; b_size < STbuffer->sg_lengths[i]; + order++, b_size *= 2) + ; /* empty */ +- free_pages((unsigned long)(STbuffer->sg[i].address), order); ++ free_pages((unsigned long)(SG_ADDRESS(STbuffer->sg[i])), order); + STbuffer->buffer_size -= STbuffer->sg_lengths[i]; + } + DEB( + if (debugging && STbuffer->orig_sg_segs < STbuffer->sg_segs) + printk(ST_DEB_MSG "st: Buffer at %p normalized to %d bytes (segs %d).\n", +- STbuffer->sg[0].address, STbuffer->buffer_size, ++ SG_ADDRESS(STbuffer->sg[0]), STbuffer->buffer_size, + STbuffer->sg_segs); + ) /* end DEB */ + STbuffer->sg_segs = STbuffer->orig_sg_segs; +@@ -3602,7 +3621,7 @@ + for (; i < st_bp->sg_segs && do_count > 0; i++) { + cnt = st_bp->sg_lengths[i] - offset < do_count ? + st_bp->sg_lengths[i] - offset : do_count; +- res = copy_from_user(st_bp->sg[i].address + offset, ubp, cnt); ++ res = copy_from_user(SG_ADDRESS(st_bp->sg[i]) + offset, ubp, cnt); + if (res) + return (-EFAULT); + do_count -= cnt; +@@ -3635,7 +3654,7 @@ + for (; i < st_bp->sg_segs && do_count > 0; i++) { + cnt = st_bp->sg_lengths[i] - offset < do_count ? + st_bp->sg_lengths[i] - offset : do_count; +- res = copy_to_user(ubp, st_bp->sg[i].address + offset, cnt); ++ res = copy_to_user(ubp, SG_ADDRESS(st_bp->sg[i]) + offset, cnt); + if (res) + return (-EFAULT); + do_count -= cnt; +@@ -3678,8 +3697,8 @@ + for (dst_seg=dst_offset=0; total > 0; ) { + count = min(st_bp->sg_lengths[dst_seg] - dst_offset, + st_bp->sg_lengths[src_seg] - src_offset); +- memmove(st_bp->sg[dst_seg].address + dst_offset, +- st_bp->sg[src_seg].address + src_offset, count); ++ memmove(SG_ADDRESS(st_bp->sg[dst_seg]) + dst_offset, ++ SG_ADDRESS(st_bp->sg[src_seg]) + src_offset, count); + printk("st: move (%d,%d) -> (%d,%d) count %d\n", + src_seg, src_offset, dst_seg, dst_offset, count); + src_offset += count; +Index: linux-2.4.21/drivers/scsi/osst.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/osst.c 2004-09-11 07:16:35.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/osst.c 2004-09-17 06:45:29.000000000 -0700 +@@ -477,7 +477,11 @@ + if (STp->raw) { + if (STp->buffer->syscall_result) { + for (i=0; i < STp->buffer->sg_segs; i++) ++#if SMALL_SCATTERLIST ++ memset(STp->buffer->sg[i].u.address, 0, STp->buffer->sg[i].length); ++#else + memset(STp->buffer->sg[i].address, 0, STp->buffer->sg[i].length); ++#endif + strcpy(STp->buffer->b_data, "READ ERROR ON FRAME"); + } else + STp->buffer->buffer_bytes = OS_FRAME_SIZE; +@@ -4452,10 +4456,19 @@ + for (i = 0, b_size = 0; + i < STp->buffer->sg_segs && (b_size + STp->buffer->sg[i].length) <= OS_DATA_SIZE; + b_size += STp->buffer->sg[i++].length); ++#if SMALL_SCATTERLIST ++ STp->buffer->aux = (os_aux_t *) (STp->buffer->sg[i].u.address + OS_DATA_SIZE - b_size); ++#else + STp->buffer->aux = (os_aux_t *) (STp->buffer->sg[i].address + OS_DATA_SIZE - b_size); ++#endif + #if DEBUG + printk(OSST_DEB_MSG "osst%d:D: b_data points to %p in segment 0 at %p\n", dev, +- STp->buffer->b_data, STp->buffer->sg[0].address); ++ STp->buffer->b_data, ++#if SMALL_SCATTERLIST ++ STp->buffer->sg[0].u.address); ++#else ++ STp->buffer->sg[0].address); ++#endif + printk(OSST_DEB_MSG "osst%d:D: AUX points to %p in segment %d at %p\n", dev, + STp->buffer->aux, i, STp->buffer->sg[i].address); + #endif +@@ -4997,6 +5010,12 @@ + + /* Memory handling routines */ + ++#if SMALL_SCATTERLIST ++#define SG_ADDRESS(sg) ((sg).u.address) ++#else ++#define SG_ADDRESS(sg) ((sg).address) ++#endif ++ + /* Try to allocate a new tape buffer */ + static OSST_buffer * new_tape_buffer( int from_initialization, int need_dma ) + { +@@ -5025,15 +5044,19 @@ + b_size *= 2, order++ ); + + for ( ; b_size >= PAGE_SIZE; order--, b_size /= 2) { +- tb->sg[0].address = ++ SG_ADDRESS(tb->sg[0]) = + (unsigned char *)__get_free_pages(priority, order); +- if (tb->sg[0].address != NULL) { ++ if (SG_ADDRESS(tb->sg[0]) != NULL) { ++#if SMALL_SCATTERLIST ++ tb->sg[0].ispaged = 0; ++#else + tb->sg[0].page = NULL; ++#endif + tb->sg[0].length = b_size; + break; + } + } +- if (tb->sg[segs].address == NULL) { ++ if (SG_ADDRESS(tb->sg[segs]) == NULL) { + kfree(tb); + tb = NULL; + } +@@ -5045,9 +5068,9 @@ + + for (segs=1, got=tb->sg[0].length; + got < osst_buffer_size && segs < OSST_FIRST_SG; ) { +- tb->sg[segs].address = ++ SG_ADDRESS(tb->sg[segs]) = + (unsigned char *)__get_free_pages(priority, order); +- if (tb->sg[segs].address == NULL) { ++ if (SG_ADDRESS(tb->sg[segs]) == NULL) { + if (osst_buffer_size - got <= + (OSST_FIRST_SG - segs) * b_size / 2) { + b_size /= 2; /* Large enough for the rest of the buffers */ +@@ -5064,7 +5087,11 @@ + tb = NULL; + break; + } ++#if SMALL_SCATTERLIST ++ tb->sg[segs].ispaged = 0; ++#else + tb->sg[segs].page = NULL; ++#endif + tb->sg[segs].length = b_size; + got += b_size; + segs++; +@@ -5077,7 +5104,7 @@ + return NULL; + } + tb->sg_segs = tb->orig_sg_segs = segs; +- tb->b_data = tb->sg[0].address; ++ tb->b_data = SG_ADDRESS(tb->sg[0]); + + #if DEBUG + if (debugging) { +@@ -5122,9 +5149,9 @@ + + for (segs=STbuffer->sg_segs, got=STbuffer->buffer_size; + segs < max_segs && got < new_size; ) { +- STbuffer->sg[segs].address = ++ SG_ADDRESS(STbuffer->sg[segs]) = + (unsigned char *)__get_free_pages(priority, order); +- if (STbuffer->sg[segs].address == NULL) { ++ if (SG_ADDRESS(STbuffer->sg[segs]) == NULL) { + if (new_size - got <= (max_segs - segs) * b_size / 2) { + b_size /= 2; /* Large enough for the rest of the buffers */ + order--; +@@ -5138,7 +5165,11 @@ + normalize_buffer(STbuffer); + return FALSE; + } ++#if SMALL_SCATTERLIST ++ STbuffer->sg[segs].ispaged = 0; ++#else + STbuffer->sg[segs].page = NULL; ++#endif + STbuffer->sg[segs].length = b_size; + STbuffer->sg_segs += 1; + got += b_size; +@@ -5171,8 +5202,8 @@ + for (b_size = PAGE_SIZE, order = 0; + b_size < STbuffer->sg[i].length; + b_size *= 2, order++); +- +- free_pages((unsigned long)STbuffer->sg[i].address, order); ++ ++ free_pages((unsigned long)SG_ADDRESS(STbuffer->sg[i]), order); + STbuffer->buffer_size -= STbuffer->sg[i].length; + } + #if DEBUG +@@ -5200,7 +5231,7 @@ + for ( ; i < st_bp->sg_segs && do_count > 0; i++) { + cnt = st_bp->sg[i].length - offset < do_count ? + st_bp->sg[i].length - offset : do_count; +- res = copy_from_user(st_bp->sg[i].address + offset, ubp, cnt); ++ res = copy_from_user(SG_ADDRESS(st_bp->sg[i]) + offset, ubp, cnt); + if (res) + return (-EFAULT); + do_count -= cnt; +@@ -5233,7 +5264,7 @@ + for ( ; i < st_bp->sg_segs && do_count > 0; i++) { + cnt = st_bp->sg[i].length - offset < do_count ? + st_bp->sg[i].length - offset : do_count; +- res = copy_to_user(ubp, st_bp->sg[i].address + offset, cnt); ++ res = copy_to_user(ubp, SG_ADDRESS(st_bp->sg[i]) + offset, cnt); + if (res) + return (-EFAULT); + do_count -= cnt; +@@ -5266,7 +5297,7 @@ + i < st_bp->sg_segs && do_count > 0; i++) { + cnt = st_bp->sg[i].length - offset < do_count ? + st_bp->sg[i].length - offset : do_count ; +- memset(st_bp->sg[i].address + offset, 0, cnt); ++ memset(SG_ADDRESS(st_bp->sg[i]) + offset, 0, cnt); + do_count -= cnt; + offset = 0; + } +@@ -5286,7 +5317,7 @@ + for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) { + cnt = st_bp->sg[i].length < do_count ? + st_bp->sg[i].length : do_count ; +- memcpy(st_bp->sg[i].address, ptr, cnt); ++ memcpy(SG_ADDRESS(st_bp->sg[i]), ptr, cnt); + do_count -= cnt; + ptr += cnt; + } +@@ -5307,7 +5338,7 @@ + for (i = 0; i < st_bp->sg_segs && do_count > 0; i++) { + cnt = st_bp->sg[i].length < do_count ? + st_bp->sg[i].length : do_count ; +- memcpy(ptr, st_bp->sg[i].address, cnt); ++ memcpy(ptr, SG_ADDRESS(st_bp->sg[i]), cnt); + do_count -= cnt; + ptr += cnt; + } +Index: linux-2.4.21/drivers/scsi/pcmcia/nsp_cs.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/pcmcia/nsp_cs.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/pcmcia/nsp_cs.c 2004-09-17 06:45:29.000000000 -0700 +@@ -201,7 +201,11 @@ + SCp.phase : current state of the command */ + if (SCpnt->use_sg) { + SCpnt->SCp.buffer = (struct scatterlist *) SCpnt->request_buffer; ++#if SMALL_SCATTERLIST ++ SCpnt->SCp.ptr = SCpnt->SCp.buffer->u.address; ++#else + SCpnt->SCp.ptr = SCpnt->SCp.buffer->address; ++#endif + SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; + SCpnt->SCp.buffers_residual = SCpnt->use_sg - 1; + } else { +@@ -713,7 +717,11 @@ + //DEBUG(0, " scatterlist next timeout=%d\n", time_out); + SCpnt->SCp.buffers_residual--; + SCpnt->SCp.buffer++; ++#if SMALL_SCATTERLIST ++ SCpnt->SCp.ptr = SCpnt->SCp.buffer->u.address; ++#else + SCpnt->SCp.ptr = SCpnt->SCp.buffer->address; ++#endif + SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; + } + +@@ -786,7 +794,11 @@ + //DEBUG(0, " scatterlist next\n"); + SCpnt->SCp.buffers_residual--; + SCpnt->SCp.buffer++; ++#if SMALL_SCATTERLIST ++ SCpnt->SCp.ptr = SCpnt->SCp.buffer->u.address; ++#else + SCpnt->SCp.ptr = SCpnt->SCp.buffer->address; ++#endif + SCpnt->SCp.this_residual = SCpnt->SCp.buffer->length; + } + +Index: linux-2.4.21/drivers/scsi/ips.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/ips.c 2004-09-11 07:16:28.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/ips.c 2004-09-17 07:20:12.000000000 -0700 +@@ -207,7 +207,11 @@ + #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0) + #include + #include "sd.h" ++#if SMALL_SCATTERLIST ++#define IPS_SG_ADDRESS(sg) ((sg)->u.address) ++#else + #define IPS_SG_ADDRESS(sg) ((sg)->address) ++#endif /* !SMALL_SCATTERLIST */ + #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags) + #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags) + #ifndef __devexit_p +Index: linux-2.4.21/drivers/scsi/libata-core.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/libata-core.c 2004-09-11 07:16:34.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/libata-core.c 2004-09-17 07:23:29.000000000 -0700 +@@ -1912,8 +1912,13 @@ + qc->buf_virt = buf; + + sg = qc->sg; ++#if SMALL_SCATTERLIST ++ sg->u.page.page = virt_to_page(buf); ++ sg->u.page.offset = (unsigned long) buf & ~PAGE_MASK; ++#else + sg->page = virt_to_page(buf); + sg->offset = (unsigned long) buf & ~PAGE_MASK; ++#endif /* !SMALL_SCATTERLIST */ + sg_dma_len(sg) = buflen; + + /* WARN_ON(buflen > PAGE_SIZE); */ +@@ -2168,9 +2173,15 @@ + if (qc->cursect == (qc->nsect - 1)) + ap->pio_task_state = PIO_ST_LAST; + ++#if SMALL_SCATTERLIST ++ page = sg[qc->cursg].u.page.page; ++ buf = kmap(page) + ++ sg[qc->cursg].u.page.offset + (qc->cursg_ofs * ATA_SECT_SIZE); ++#else + page = sg[qc->cursg].page; + buf = kmap(page) + + sg[qc->cursg].offset + (qc->cursg_ofs * ATA_SECT_SIZE); ++#endif /* SMALL_SCATTERLIST */ + + qc->cursect++; + qc->cursg_ofs++; +Index: linux-2.4.21/drivers/scsi/libata-scsi.c +=================================================================== +--- linux-2.4.21.orig/drivers/scsi/libata-scsi.c 2004-09-11 07:16:34.000000000 -0700 ++++ linux-2.4.21/drivers/scsi/libata-scsi.c 2004-09-17 07:25:20.000000000 -0700 +@@ -400,7 +400,11 @@ + struct scatterlist *sg; + + sg = (struct scatterlist *) cmd->request_buffer; ++#if SMALL_SCATTERLIST ++ buf = kmap_atomic(sg->u.page.page, KM_USER0) + sg->u.page.offset; ++#else + buf = kmap_atomic(sg->page, KM_USER0) + sg->offset; ++#endif /* !SMALL_SCATTERLIST */ + buflen = sg->length; + } else { + buf = cmd->request_buffer; +@@ -428,7 +432,11 @@ + struct scatterlist *sg; + + sg = (struct scatterlist *) cmd->request_buffer; ++#if SMALL_SCATTERLIST ++ kunmap_atomic(sg->u.page.page, KM_USER0); ++#else + kunmap_atomic(sg->page, KM_USER0); ++#endif /* !SMALL_SCATTERLIST */ + } + } + +Index: linux-2.4.21/drivers/block/cpqarray.c +=================================================================== +--- linux-2.4.21.orig/drivers/block/cpqarray.c 2004-09-11 07:16:29.000000000 -0700 ++++ linux-2.4.21/drivers/block/cpqarray.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1003,9 +1003,14 @@ + } else { + if (seg == SG_MAX) + BUG(); ++#if SMALL_SCATTERLIST ++ tmp_sg[seg].u.page.page = bh->b_page; ++ tmp_sg[seg].u.page.offset = bh_offset(bh); ++#else + tmp_sg[seg].page = bh->b_page; +- tmp_sg[seg].length = bh->b_size; + tmp_sg[seg].offset = bh_offset(bh); ++#endif ++ tmp_sg[seg].length = bh->b_size; + lastdataend = bh_phys(bh) + bh->b_size; + seg++; + } +@@ -1015,7 +1020,12 @@ + for( i=0; i < seg; i++) { + c->req.sg[i].size = tmp_sg[i].length; + c->req.sg[i].addr = (__u32) pci_map_page( +- h->pci_dev, tmp_sg[i].page, tmp_sg[i].offset, ++ h->pci_dev, ++#if SMALL_SCATTERLIST ++ tmp_sg[i].u.page.page, tmp_sg[i].u.page.offset, ++#else ++ tmp_sg[i].page, tmp_sg[i].offset, ++#endif + tmp_sg[i].length, + (creq->cmd == READ) ? + PCI_DMA_FROMDEVICE : PCI_DMA_TODEVICE); +Index: linux-2.4.21/drivers/block/cciss.c +=================================================================== +--- linux-2.4.21.orig/drivers/block/cciss.c 2004-09-11 07:16:28.000000000 -0700 ++++ linux-2.4.21/drivers/block/cciss.c 2004-09-17 06:45:29.000000000 -0700 +@@ -2485,9 +2485,14 @@ + } else { + if (seg == MAXSGENTRIES) + BUG(); ++#if SMALL_SCATTERLIST ++ tmp_sg[seg].u.page.page = bh->b_page; ++ tmp_sg[seg].u.page.offset = bh_offset(bh); ++#else + tmp_sg[seg].page = bh->b_page; +- tmp_sg[seg].length = bh->b_size; + tmp_sg[seg].offset = bh_offset(bh); ++#endif ++ tmp_sg[seg].length = bh->b_size; + lastdataend = bh_phys(bh) + bh->b_size; + seg++; + } +@@ -2501,8 +2506,14 @@ + ddir = PCI_DMA_TODEVICE; + for (i=0; iSG[i].Len = tmp_sg[i].length; +- temp64.val = pci_map_page(h->pdev, tmp_sg[i].page, +- tmp_sg[i].offset, tmp_sg[i].length, ddir); ++ temp64.val = pci_map_page(h->pdev, ++#if SMALL_SCATTERLIST ++ tmp_sg[i].u.page.page, ++ tmp_sg[i].u.page.offset, ++#else ++ tmp_sg[i].page, tmp_sg[i].offset, ++#endif ++ tmp_sg[i].length, ddir); + c->SG[i].Addr.lower = temp64.val32.lower; + c->SG[i].Addr.upper = temp64.val32.upper; + c->SG[i].Ext = 0; /* we are not chaining */ +Index: linux-2.4.21/drivers/block/sx8.c +=================================================================== +--- linux-2.4.21.orig/drivers/block/sx8.c 2004-09-11 07:16:34.000000000 -0700 ++++ linux-2.4.21/drivers/block/sx8.c 2004-09-17 07:05:53.000000000 -0700 +@@ -1103,9 +1103,15 @@ + } else { + if (unlikely(n_elem == CARM_MAX_REQ_SG)) + BUG(); ++#if SMALL_SCATTERLIST ++ sg[n_elem].u.page.page = bh->b_page; ++ sg[n_elem].length = bh->b_size; ++ sg[n_elem].u.page.offset = bh_offset(bh); ++#else + sg[n_elem].page = bh->b_page; + sg[n_elem].length = bh->b_size; + sg[n_elem].offset = bh_offset(bh); ++#endif /* !SMALL_SCATTERLIST */ + last_phys = bh_phys(bh) + bh->b_size; + n_elem++; + } +Index: linux-2.4.21/drivers/ieee1394/dma.c +=================================================================== +--- linux-2.4.21.orig/drivers/ieee1394/dma.c 2003-06-13 07:51:34.000000000 -0700 ++++ linux-2.4.21/drivers/ieee1394/dma.c 2004-09-17 06:45:29.000000000 -0700 +@@ -97,8 +97,12 @@ + /* fill scatter/gather list with pages */ + for(i = 0; i < dma->n_pages; i++) { + unsigned long va = (unsigned long) dma->kvirt + i * PAGE_SIZE; +- ++ ++#if SMALL_SCATTERLIST ++ dma->sglist[i].u.page.page = vmalloc_to_page((void *)va); ++#else + dma->sglist[i].page = vmalloc_to_page((void *)va); ++#endif + dma->sglist[i].length = PAGE_SIZE; + } + +Index: linux-2.4.21/drivers/ieee1394/sbp2.c +=================================================================== +--- linux-2.4.21.orig/drivers/ieee1394/sbp2.c 2003-06-13 07:51:34.000000000 -0700 ++++ linux-2.4.21/drivers/ieee1394/sbp2.c 2004-09-17 06:45:29.000000000 -0700 +@@ -2037,8 +2037,13 @@ + command->dma_size = sgpnt[0].length; + command->dma_type = CMD_DMA_PAGE; + command->cmd_dma = pci_map_page(hi->host->pdev, ++#if SMALL_SCATTERLIST ++ sgpnt[0].u.page.page, ++ sgpnt[0].u.page.offset, ++#else + sgpnt[0].page, + sgpnt[0].offset, ++#endif + command->dma_size, + command->dma_dir); + SBP2_DMA_ALLOC("single page scatter element"); +Index: linux-2.4.21/drivers/message/i2o/i2o_scsi.c +=================================================================== +--- linux-2.4.21.orig/drivers/message/i2o/i2o_scsi.c 2002-08-02 17:39:44.000000000 -0700 ++++ linux-2.4.21/drivers/message/i2o/i2o_scsi.c 2004-09-17 06:45:29.000000000 -0700 +@@ -693,7 +693,11 @@ + { + *mptr++=direction|0x10000000|sg->length; + len+=sg->length; ++#if SMALL_SCATTERLIST ++ *mptr++=virt_to_bus(sg->u.address); ++#else + *mptr++=virt_to_bus(sg->address); ++#endif + sg++; + } + mptr[-2]=direction|0xD0000000|(sg-1)->length; +@@ -704,7 +708,11 @@ + { + i2o_raw_writel(direction|0x10000000|sg->length, mptr++); + len+=sg->length; ++#if SMALL_SCATTERLIST ++ i2o_raw_writel(virt_to_bus(sg->u.address), mptr++); ++#else + i2o_raw_writel(virt_to_bus(sg->address), mptr++); ++#endif + sg++; + } + +Index: linux-2.4.21/drivers/net/fc/iph5526.c +=================================================================== +--- linux-2.4.21.orig/drivers/net/fc/iph5526.c 2003-06-13 07:51:34.000000000 -0700 ++++ linux-2.4.21/drivers/net/fc/iph5526.c 2004-09-17 06:45:29.000000000 -0700 +@@ -4249,7 +4249,11 @@ + if (Cmnd->use_sg) { + int count = 0, j; + for(i = 0; i < no_of_sg; i++) { ++#if SMALL_SCATTERLIST ++ char *addr_ptr = sl2->u.address; ++#else + char *addr_ptr = sl2->address; ++#endif + count = sl2->length / SEST_BUFFER_SIZE; + if (sl2->length % SEST_BUFFER_SIZE) + count++; +@@ -4349,7 +4353,11 @@ + int count = 0, j; + count = sl1->length / SEST_BUFFER_SIZE; + for (j = 0; j < count; j++) { ++#if SMALL_SCATTERLIST ++ build_EDB(fi, (char *)sl1->u.address, 0, SEST_BUFFER_SIZE); ++#else + build_EDB(fi, (char *)sl1->address, 0, SEST_BUFFER_SIZE); ++#endif + memcpy(fi->q.ptr_edb[fi->q.edb_buffer_indx], &(fi->g.edb), sizeof(EDB)); + /* Mark this EDB as being in use */ + fi->q.free_edb_list[fi->q.edb_buffer_indx] = EDB_BUSY; +@@ -4358,13 +4366,21 @@ + * safe. + */ + update_EDB_indx(fi); ++#if SMALL_SCATTERLIST ++ sl1->u.address += SEST_BUFFER_SIZE; ++#else + sl1->address += SEST_BUFFER_SIZE; ++#endif + } + /* Just in case itz not a multiple of + * SEST_BUFFER_SIZE bytes. + */ + if (sl1->length % SEST_BUFFER_SIZE) { ++#if SMALL_SCATTERLIST ++ build_EDB(fi, (char *)sl1->u.address, 0, sl1->length % SEST_BUFFER_SIZE); ++#else + build_EDB(fi, (char *)sl1->address, 0, sl1->length % SEST_BUFFER_SIZE); ++#endif + memcpy(fi->q.ptr_edb[fi->q.edb_buffer_indx], &(fi->g.edb), sizeof(EDB)); + fi->q.free_edb_list[fi->q.edb_buffer_indx] = EDB_BUSY; + update_EDB_indx(fi); +Index: linux-2.4.21/drivers/net/wireless/airo.c +=================================================================== +--- linux-2.4.21.orig/drivers/net/wireless/airo.c 2004-09-11 07:16:30.000000000 -0700 ++++ linux-2.4.21/drivers/net/wireless/airo.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1584,11 +1584,20 @@ + aes_counter[12] = (u8)(counter >> 24); + counter++; + memcpy (plain, aes_counter, 16); ++#if SMALL_SCATTERLIST ++ sg[0].u.page.page = virt_to_page(plain); ++ sg[0].u.page.offset = ((long) plain & ~PAGE_MASK); ++#else + sg[0].page = virt_to_page(plain); + sg[0].offset = ((long) plain & ~PAGE_MASK); ++#endif + sg[0].length = 16; + crypto_cipher_encrypt(tfm, sg, sg, 16); ++#if SMALL_SCATTERLIST ++ cipher = kmap(sg[0].u.page.page) + sg[0].u.page.offset; ++#else + cipher = kmap(sg[0].page) + sg[0].offset; ++#endif + for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) { + context->coeff[i++] = ntohl(*(u32 *)&cipher[j]); + j += 4; +Index: linux-2.4.21/drivers/usb/microtek.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/microtek.c 2002-11-28 15:53:14.000000000 -0800 ++++ linux-2.4.21/drivers/usb/microtek.c 2004-09-17 06:45:29.000000000 -0700 +@@ -623,7 +623,11 @@ + context->fragment++; + mts_int_submit_urb(transfer, + context->data_pipe, ++#if SMALL_SCATTERLIST ++ sg[context->fragment].u.address, ++#else + sg[context->fragment].address, ++#endif + sg[context->fragment].length, + context->fragment + 1 == context->srb->use_sg ? mts_data_done : mts_do_sg); + return; +@@ -667,7 +671,11 @@ + } else { + MTS_DEBUG("Using scatter/gather\n"); + sg = srb->buffer; ++#if SMALL_SCATTERLIST ++ desc->context.data = sg[0].u.address; ++#else + desc->context.data = sg[0].address; ++#endif + desc->context.data_length = sg[0].length; + } + +Index: linux-2.4.21/drivers/usb/hpusbscsi.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/hpusbscsi.c 2003-06-13 07:51:36.000000000 -0700 ++++ linux-2.4.21/drivers/usb/hpusbscsi.c 2004-09-17 06:45:29.000000000 -0700 +@@ -576,6 +576,17 @@ + hpusbscsi->state = HP_STATE_WORKING; + PDEBUG(2, "state= %s", states[hpusbscsi->state]); + ++#if SMALL_SCATTERLIST ++ FILL_BULK_URB( ++ u, ++ hpusbscsi->dev, ++ hpusbscsi->current_data_pipe, ++ sg[hpusbscsi->fragment].u.address, ++ sg[hpusbscsi->fragment++].length, ++ callback, ++ hpusbscsi ++ ); ++#else + FILL_BULK_URB( + u, + hpusbscsi->dev, +@@ -585,6 +596,7 @@ + callback, + hpusbscsi + ); ++#endif + + res = usb_submit_urb(u); + if (res) +Index: linux-2.4.21/drivers/usb/storage/protocol.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/protocol.c 2002-08-02 17:39:45.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/protocol.c 2004-09-17 06:45:29.000000000 -0700 +@@ -72,7 +72,11 @@ + struct scatterlist *sg; + + sg = (struct scatterlist *) srb->request_buffer; ++#if SMALL_SCATTERLIST ++ data_ptr = (unsigned char *) sg[0].u.address; ++#else + data_ptr = (unsigned char *) sg[0].address; ++#endif + } else + data_ptr = (unsigned char *)srb->request_buffer; + +Index: linux-2.4.21/drivers/usb/storage/transport.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/transport.c 2004-09-11 07:16:25.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/transport.c 2004-09-17 06:45:29.000000000 -0700 +@@ -592,11 +592,20 @@ + if (transfer_amount - total_transferred >= + sg[i].length) { + result = usb_stor_transfer_partial(us, +- sg[i].address, sg[i].length); ++#if SMALL_SCATTERLIST ++ sg[i].u.address, ++#else ++ sg[i].address, ++#endif ++ sg[i].length); + total_transferred += sg[i].length; + } else + result = usb_stor_transfer_partial(us, ++#if SMALL_SCATTERLIST ++ sg[i].u.address, ++#else + sg[i].address, ++#endif + transfer_amount - total_transferred); + + /* if we get an error, end the loop here */ +Index: linux-2.4.21/drivers/usb/storage/usb.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/usb.c 2004-09-11 07:16:25.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/usb.c 2004-09-17 06:45:29.000000000 -0700 +@@ -291,13 +291,21 @@ + if (us->srb->use_sg) { + sg = (struct scatterlist *)us->srb->request_buffer; + for (i=0; isrb->use_sg; i++) ++#if SMALL_SCATTERLIST ++ memset(sg[i].u.address, 0, sg[i].length); ++#else + memset(sg[i].address, 0, sg[i].length); ++#endif + for (i=0, transferred=0; + isrb->use_sg && transferred < len; + i++) { + amt = sg[i].length > len-transferred ? + len-transferred : sg[i].length; ++#if SMALL_SCATTERLIST ++ memcpy(sg[i].u.address, data+transferred, amt); ++#else + memcpy(sg[i].address, data+transferred, amt); ++#endif + transferred -= amt; + } + } else { +Index: linux-2.4.21/drivers/usb/storage/shuttle_usbat.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/shuttle_usbat.c 2003-06-13 07:51:37.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/shuttle_usbat.c 2004-09-17 06:45:29.000000000 -0700 +@@ -217,7 +217,11 @@ + sg = (struct scatterlist *)data; + for (i=0; i sg[i].length ? + sg[i].length : len-transferred); + if (result!=US_BULK_TRANSFER_GOOD) +@@ -742,17 +746,29 @@ + while (amount= + sg[sg_segment].length-sg_offset) { ++#if SMALL_SCATTERLIST ++ memcpy(sg[sg_segment].u.address + sg_offset, ++ buffer + amount, ++ sg[sg_segment].length - sg_offset); ++#else + memcpy(sg[sg_segment].address + sg_offset, + buffer + amount, + sg[sg_segment].length - sg_offset); ++#endif + amount += + sg[sg_segment].length-sg_offset; + sg_segment++; + sg_offset=0; + } else { ++#if SMALL_SCATTERLIST ++ memcpy(sg[sg_segment].u.address + sg_offset, ++ buffer + amount, ++ len - amount); ++#else + memcpy(sg[sg_segment].address + sg_offset, + buffer + amount, + len - amount); ++#endif + sg_offset += (len - amount); + amount = len; + } +Index: linux-2.4.21/drivers/usb/storage/sddr09.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/sddr09.c 2003-06-13 07:51:37.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/sddr09.c 2004-09-17 06:45:29.000000000 -0700 +@@ -387,7 +387,11 @@ + unsigned char *buf; + unsigned int length; + ++#if SMALL_SCATTERLIST ++ buf = sg[i].u.address; ++#else + buf = sg[i].address; ++#endif + length = len-transferred; + if (length > sg[i].length) + length = sg[i].length; +@@ -903,7 +907,11 @@ + int transferred = 0; + + for (i=0; i sg[i].length ? ++ sg[i].length : len-transferred); ++#else + memcpy(buffer+transferred, + sg[i].address, + len-transferred > sg[i].length ? + sg[i].length : len-transferred); ++#endif + transferred += sg[i].length; + } + ptr = buffer; +@@ -1307,17 +1322,35 @@ + + for (i=0; icapacity >> (info->blockshift + info->pageshift); + + result = sddr09_read_control(us, 0, numblocks, + (unsigned char *)sg, alloc_blocks); + if (result != USB_STOR_TRANSPORT_GOOD) { + for (i=0; ilba_to_pba = NULL; + info->pba_to_lba = NULL; + for (i=0; ilba_to_pba[i] = info->pba_to_lba[i] = UNDEF; + ++#if SMALL_SCATTERLIST ++ ptr = sg[0].u.address; ++#else + ptr = sg[0].address; ++#endif + + /* + * Define lba-pba translation table +@@ -1374,7 +1420,11 @@ + printk("sddr09: no translation today\n"); + #else + for (i=0; i>11].u.address + ((i&0x7ff)<<6); ++#else + ptr = sg[i>>11].address + ((i&0x7ff)<<6); ++#endif + + if (i == 0 || i == 1) { + info->pba_to_lba[i] = UNUSABLE; +@@ -1477,7 +1527,11 @@ + US_DEBUGP("Found %d LBA's\n", lbact); + + for (i=0; i sg[i].length ? ++ sg[i].length : len-transferred); ++#else + memcpy(sg[i].address, buffer+transferred, + len-transferred > sg[i].length ? + sg[i].length : len-transferred); ++#endif + transferred += sg[i].length; + } + kfree(buffer); +@@ -462,9 +468,15 @@ + + transferred = 0; + for (i=0; i sg[i].length ? ++ sg[i].length : len-transferred); ++#else + memcpy(buffer+transferred, sg[i].address, + len-transferred > sg[i].length ? + sg[i].length : len-transferred); ++#endif + transferred += sg[i].length; + } + +Index: linux-2.4.21/drivers/usb/storage/freecom.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/freecom.c 2003-06-13 07:51:37.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/freecom.c 2004-09-17 06:45:29.000000000 -0700 +@@ -144,11 +144,20 @@ + if (transfer_amount - total_transferred >= + sg[i].length) { + result = usb_stor_transfer_partial(us, +- sg[i].address, sg[i].length); ++#if SMALL_SCATTERLIST ++ sg[i].u.address, ++#else ++ sg[i].address, ++#endif ++ sg[i].length); + total_transferred += sg[i].length; + } else { + result = usb_stor_transfer_partial(us, ++#if SMALL_SCATTERLIST ++ sg[i].u.address, ++#else + sg[i].address, ++#endif + transfer_amount - total_transferred); + total_transferred += transfer_amount - total_transferred; + } +Index: linux-2.4.21/drivers/usb/storage/isd200.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/isd200.c 2003-06-13 07:51:37.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/isd200.c 2004-09-17 06:45:29.000000000 -0700 +@@ -494,13 +494,21 @@ + sg[i].length) { + result = isd200_transfer_partial(us, + srb->sc_data_direction, ++#if SMALL_SCATTERLIST ++ sg[i].u.address, ++#else + sg[i].address, ++#endif + sg[i].length); + total_transferred += sg[i].length; + } else + result = isd200_transfer_partial(us, + srb->sc_data_direction, ++#if SMALL_SCATTERLIST ++ sg[i].u.address, ++#else + sg[i].address, ++#endif + transfer_amount - total_transferred); + + /* if we get an error, end the loop here */ +@@ -1396,10 +1404,18 @@ + /* transfer the lesser of the next buffer or the + * remaining data */ + if (len - total >= sg[i].length) { ++#if SMALL_SCATTERLIST ++ memcpy(sg[i].u.address, src + total, sg[i].length); ++#else + memcpy(sg[i].address, src + total, sg[i].length); ++#endif + total += sg[i].length; + } else { ++#if SMALL_SCATTERLIST ++ memcpy(sg[i].u.address, src + total, len - total); ++#else + memcpy(sg[i].address, src + total, len - total); ++#endif + total = len; + } + } +Index: linux-2.4.21/drivers/usb/storage/datafab.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/datafab.c 2003-06-13 07:51:37.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/datafab.c 2004-09-17 06:45:29.000000000 -0700 +@@ -265,18 +265,30 @@ + while (sg_idx < use_sg && transferred < len) { + if (len - transferred >= sg[sg_idx].length - current_sg_offset) { + US_DEBUGP("datafab_read_data: adding %d bytes to %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(sg[sg_idx].u.address + current_sg_offset, ++ buffer + transferred, ++ sg[sg_idx].length - current_sg_offset); ++#else + memcpy(sg[sg_idx].address + current_sg_offset, + buffer + transferred, + sg[sg_idx].length - current_sg_offset); ++#endif + transferred += sg[sg_idx].length - current_sg_offset; + current_sg_offset = 0; + // on to the next sg buffer + ++sg_idx; + } else { + US_DEBUGP("datafab_read_data: adding %d bytes to %d byte sg buffer\n", len - transferred, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(sg[sg_idx].u.address + current_sg_offset, ++ buffer + transferred, ++ len - transferred); ++#else + memcpy(sg[sg_idx].address + current_sg_offset, + buffer + transferred, + len - transferred); ++#endif + current_sg_offset += len - transferred; + // this sg buffer is only partially full and we're out of data to copy in + break; +@@ -355,18 +367,30 @@ + while (transferred < len) { + if (len - transferred >= sg[sg_idx].length - current_sg_offset) { + US_DEBUGP("datafab_write_data: getting %d bytes from %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(ptr + transferred, ++ sg[sg_idx].u.address + current_sg_offset, ++ sg[sg_idx].length - current_sg_offset); ++#else + memcpy(ptr + transferred, + sg[sg_idx].address + current_sg_offset, + sg[sg_idx].length - current_sg_offset); ++#endif + transferred += sg[sg_idx].length - current_sg_offset; + current_sg_offset = 0; + // on to the next sg buffer + ++sg_idx; + } else { + US_DEBUGP("datafab_write_data: getting %d bytes from %d byte sg buffer\n", len - transferred, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(ptr + transferred, ++ sg[sg_idx].u.address + current_sg_offset, ++ len - transferred); ++#else + memcpy(ptr + transferred, + sg[sg_idx].address + current_sg_offset, + len - transferred); ++#endif + current_sg_offset += len - transferred; + // we only copied part of this sg buffer + break; +Index: linux-2.4.21/drivers/usb/storage/jumpshot.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/jumpshot.c 2003-06-13 07:51:37.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/jumpshot.c 2004-09-17 06:45:29.000000000 -0700 +@@ -341,18 +341,30 @@ + while (sg_idx < use_sg && transferred < len) { + if (len - transferred >= sg[sg_idx].length - current_sg_offset) { + US_DEBUGP("jumpshot_read_data: adding %d bytes to %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(sg[sg_idx].u.address + current_sg_offset, ++ buffer + transferred, ++ sg[sg_idx].length - current_sg_offset); ++#else + memcpy(sg[sg_idx].address + current_sg_offset, + buffer + transferred, + sg[sg_idx].length - current_sg_offset); ++#endif + transferred += sg[sg_idx].length - current_sg_offset; + current_sg_offset = 0; + // on to the next sg buffer + ++sg_idx; + } else { + US_DEBUGP("jumpshot_read_data: adding %d bytes to %d byte sg buffer\n", len - transferred, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(sg[sg_idx].u.address + current_sg_offset, ++ buffer + transferred, ++ len - transferred); ++#else + memcpy(sg[sg_idx].address + current_sg_offset, + buffer + transferred, + len - transferred); ++#endif + current_sg_offset += len - transferred; + // this sg buffer is only partially full and we're out of data to copy in + break; +@@ -422,18 +434,31 @@ + while (transferred < len) { + if (len - transferred >= sg[sg_idx].length - current_sg_offset) { + US_DEBUGP("jumpshot_write_data: getting %d bytes from %d byte sg buffer\n", sg[sg_idx].length - current_sg_offset, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(ptr + transferred, ++ sg[sg_idx].u.address + current_sg_offset, ++ sg[sg_idx].length - current_sg_offset); ++#else + memcpy(ptr + transferred, + sg[sg_idx].address + current_sg_offset, + sg[sg_idx].length - current_sg_offset); ++ ++#endif + transferred += sg[sg_idx].length - current_sg_offset; + current_sg_offset = 0; + // on to the next sg buffer + ++sg_idx; + } else { + US_DEBUGP("jumpshot_write_data: getting %d bytes from %d byte sg buffer\n", len - transferred, sg[sg_idx].length); ++#if SMALL_SCATTERLIST ++ memcpy(ptr + transferred, ++ sg[sg_idx].u.address + current_sg_offset, ++ len - transferred); ++#else + memcpy(ptr + transferred, + sg[sg_idx].address + current_sg_offset, + len - transferred); ++#endif + current_sg_offset += len - transferred; + // we only copied part of this sg buffer + break; +Index: linux-2.4.21/drivers/usb/storage/scsiglue.c +=================================================================== +--- linux-2.4.21.orig/drivers/usb/storage/scsiglue.c 2004-09-11 07:16:25.000000000 -0700 ++++ linux-2.4.21/drivers/usb/storage/scsiglue.c 2004-09-17 06:45:29.000000000 -0700 +@@ -594,7 +594,11 @@ + } + + /* copy one byte */ ++#if SMALL_SCATTERLIST ++ sg[db].u.address[di] = sg[sb].u.address[si]; ++#else + sg[db].address[di] = sg[sb].address[si]; ++#endif + + /* get next destination */ + if ( sg[db].length-1 == di ) +@@ -632,7 +636,11 @@ + break; + } + ++#if SMALL_SCATTERLIST ++ sg[db].u.address[di] = 0; ++#else + sg[db].address[di] = 0; ++#endif + + /* get next destination */ + if ( sg[db].length-1 == di ) +@@ -782,7 +790,11 @@ + } + + /* copy one byte */ ++#if SMALL_SCATTERLIST ++ sg[db].u.address[di] = sg[sb].u.address[si]; ++#else + sg[db].address[di] = sg[sb].address[si]; ++#endif + + /* get next destination */ + if ( di == 0 ) +@@ -819,7 +831,11 @@ + break; + } + ++#if SMALL_SCATTERLIST ++ sg[db].u.address[di] = tempBuffer[element-USB_STOR_SCSI_SENSE_HDRSZ]; ++#else + sg[db].address[di] = tempBuffer[element-USB_STOR_SCSI_SENSE_HDRSZ]; ++#endif + + /* get next destination */ + if ( di == 0 ) +@@ -869,6 +885,15 @@ + if ( element < USB_STOR_SCSI_SENSE_HDRSZ ) + { + /* fill in the pointers for both header types */ ++#if SMALL_SCATTERLIST ++ the6->array[element] = &(sg[i].u.address[j]); ++ the10->array[element] = &(sg[i].u.address[j]); ++ } ++ else if ( element < USB_STOR_SCSI_SENSE_10_HDRSZ ) ++ { ++ /* only the longer headers still cares now */ ++ the10->array[element] = &(sg[i].u.address[j]); ++#else + the6->array[element] = &(sg[i].address[j]); + the10->array[element] = &(sg[i].address[j]); + } +@@ -876,6 +901,7 @@ + { + /* only the longer headers still cares now */ + the10->array[element] = &(sg[i].address[j]); ++#endif + } + /* increase element counter */ + element++; +Index: linux-2.4.21/drivers/addon/ips_61107/ips.c +=================================================================== +--- linux-2.4.21.orig/drivers/addon/ips_61107/ips.c 2004-09-11 07:16:28.000000000 -0700 ++++ linux-2.4.21/drivers/addon/ips_61107/ips.c 2004-09-17 06:56:30.000000000 -0700 +@@ -206,7 +206,11 @@ + #endif + + #if LINUX_VERSION_CODE <= LinuxVersionCode(2,5,0) ++#if SMALL_SCATTERLIST ++#define IPS_SG_ADDRESS(sg) ((sg)->u.address) ++#else + #define IPS_SG_ADDRESS(sg) ((sg)->address) ++#endif /* !SMALL_SCATTERLIST */ + #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags) + #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags) + #else +Index: linux-2.4.21/drivers/addon/megaraid_2101/megaraid2.c +=================================================================== +--- linux-2.4.21.orig/drivers/addon/megaraid_2101/megaraid2.c 2004-09-11 07:16:28.000000000 -0700 ++++ linux-2.4.21/drivers/addon/megaraid_2101/megaraid2.c 2004-09-17 07:00:55.000000000 -0700 +@@ -2127,7 +2127,11 @@ + if( cmd->use_sg ) { + sgl = (struct scatterlist *) + cmd->request_buffer; ++#if SMALL_SCATTERLIST ++ c = *(u8 *)sgl[0].u.address; ++#else + c = *(u8 *)sgl[0].address; ++#endif + } + else { + c = *(u8 *)cmd->request_buffer; +Index: linux-2.4.21/include/asm-i386/pci.h +=================================================================== +--- linux-2.4.21.orig/include/asm-i386/pci.h 2004-09-11 07:16:18.000000000 -0700 ++++ linux-2.4.21/include/asm-i386/pci.h 2004-09-17 06:48:18.000000000 -0700 +@@ -157,6 +157,17 @@ + * temporary 2.4 hack + */ + for (i = 0; i < nents; i++ ) { ++#if SMALL_SCATTERLIST ++ if (sg[i].ispaged) { ++ if (!sg[i].u.page.page) ++ out_of_line_bug(); ++ sg[i].dma_address = page_to_bus(sg[i].u.page.page) + sg[i].u.page.offset; ++ } else { ++ if (!sg[i].u.address) ++ out_of_line_bug(); ++ sg[i].dma_address = virt_to_bus(sg[i].u.address); ++ } ++#else + if (sg[i].address && sg[i].page) + out_of_line_bug(); + else if (!sg[i].address && !sg[i].page) +@@ -166,6 +177,7 @@ + sg[i].dma_address = virt_to_bus(sg[i].address); + else + sg[i].dma_address = page_to_bus(sg[i].page) + sg[i].offset; ++#endif + } + + flush_write_buffers(); +Index: linux-2.4.21/include/asm-i386/scatterlist.h +=================================================================== +--- linux-2.4.21.orig/include/asm-i386/scatterlist.h 2002-11-28 15:53:15.000000000 -0800 ++++ linux-2.4.21/include/asm-i386/scatterlist.h 2004-09-17 06:45:29.000000000 -0700 +@@ -19,7 +19,25 @@ + * + * and that's it. There's no excuse for not highmem enabling YOUR driver. /jens + */ ++ ++/* Define SMALL_SCATTERLIST non-zero if you want to compress scatter/gather ++ descriptors to fit in 1 page. NB this file is arch-specific, so we only ++ define this where we actually need/want it */ ++#define SMALL_SCATTERLIST 1 ++ + struct scatterlist { ++#if SMALL_SCATTERLIST ++ union { ++ char *address; /* mapped address... */ ++ struct { ++ struct page *page; /* ...or page + offset... */ ++ unsigned int offset; ++ } page; ++ } u; ++ dma_addr_t dma_address; ++ unsigned int length:31; /* ...steal 1 bit from the length */ ++ unsigned int ispaged:1; /* to discriminate */ ++#else + char * address; /* Location data is to be transferred to, NULL for + * highmem page */ + struct page * page; /* Location for highmem page, if any */ +@@ -27,6 +45,7 @@ + + dma_addr_t dma_address; + unsigned int length; ++#endif + }; + + #define ISA_DMA_THRESHOLD (0x00ffffff) +Index: linux-2.4.21/net/xfrm/xfrm_algo.c +=================================================================== +--- linux-2.4.21.orig/net/xfrm/xfrm_algo.c 2004-09-11 07:16:24.000000000 -0700 ++++ linux-2.4.21/net/xfrm/xfrm_algo.c 2004-09-17 06:45:29.000000000 -0700 +@@ -487,9 +487,14 @@ + if (copy > 0) { + if (copy > len) + copy = len; +- ++#if SMALL_SCATTERLIST ++ sg.ispaged = 1; ++ sg.u.page.page = virt_to_page(skb->data + offset); ++ sg.u.page.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE; ++#else + sg.page = virt_to_page(skb->data + offset); + sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE; ++#endif + sg.length = copy; + + icv_update(tfm, &sg, 1); +@@ -511,8 +516,14 @@ + if (copy > len) + copy = len; + ++#if SMALL_SCATTERLIST ++ sg.ispaged = 1; ++ sg.u.page.page = frag->page; ++ sg.u.page.offset = frag->page_offset + offset-start; ++#else + sg.page = frag->page; + sg.offset = frag->page_offset + offset-start; ++#endif + sg.length = copy; + + icv_update(tfm, &sg, 1); +@@ -562,8 +573,15 @@ + if (copy > 0) { + if (copy > len) + copy = len; ++#if SMALL_SCATTERLIST ++# ++ sg[elt].u.page.page = virt_to_page(skb->data + offset); ++ sg[elt].u.page.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE; ++#else ++# + sg[elt].page = virt_to_page(skb->data + offset); + sg[elt].offset = (unsigned long)(skb->data + offset) % PAGE_SIZE; ++#endif + sg[elt].length = copy; + elt++; + if ((len -= copy) == 0) +@@ -582,8 +600,13 @@ + + if (copy > len) + copy = len; ++#if SMALL_SCATTERLIST ++ sg[elt].u.page.page = frag->page; ++ sg[elt].u.page.offset = frag->page_offset+offset-start; ++#else + sg[elt].page = frag->page; + sg[elt].offset = frag->page_offset+offset-start; ++#endif + sg[elt].length = copy; + elt++; + if (!(len -= copy)) +Index: linux-2.4.21/net/ipv6/addrconf.c +=================================================================== +--- linux-2.4.21.orig/net/ipv6/addrconf.c 2004-09-11 07:16:24.000000000 -0700 ++++ linux-2.4.21/net/ipv6/addrconf.c 2004-09-17 06:45:29.000000000 -0700 +@@ -1047,11 +1047,18 @@ + u8 digest[16]; + struct scatterlist sg[2]; + +- sg[0].page = virt_to_page(idev->entropy); ++#if SMALL_SCATTERLIST ++ sg[0].u.page.page = virt_to_page(idev->entropy); ++ sg[0].u.page.offset = ((long) idev->entropy & ~PAGE_MASK); ++ sg[1].u.page.page = virt_to_page(eui64); ++ sg[1].u.page.offset = ((long) eui64 & ~PAGE_MASK); ++#else ++ sg[0].page = virt_to_page(idev->entropy); + sg[0].offset = ((long) idev->entropy & ~PAGE_MASK); +- sg[0].length = 8; + sg[1].page = virt_to_page(eui64); + sg[1].offset = ((long) eui64 & ~PAGE_MASK); ++#endif ++ sg[0].length = 8; + sg[1].length = 8; + + dev = idev->dev; diff --git a/lustre/kernel_patches/series/rhel-2.4.21 b/lustre/kernel_patches/series/rhel-2.4.21 index bc6924a..a211f19 100644 --- a/lustre/kernel_patches/series/rhel-2.4.21 +++ b/lustre/kernel_patches/series/rhel-2.4.21 @@ -34,6 +34,12 @@ pagecache-lock-2.4.21-chaos.patch ext3-truncate-buffer-head.patch inode-max-readahead-2.4.24.patch dcache_refcount_debug.patch +ext3-extents-2.4.21-chaos.patch +ext3-extents-asyncdel-2.4.21-chaos.patch +ext3-mballoc-2.4.21-chaos.patch blkdev_tunables-2.4.21-chaos.patch +small_scatterlist-2.4.21-rhel.patch ext3-nlinks-2.4.21-chaos.patch +sd_iostats-2.4.21-chaos.patch export-show_task-2.4-rhel.patch +compile-fixes-2.4.21-rhel.patch -- 1.8.3.1