adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 11:46:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

[PATCH] Use sg_set_buf/sg_init_one where applicable

Browse source 
This patch uses sg_set_buf/sg_init_one in some places where it was
duplicated.

Signed-off-by: David Hardeman <david@2gen.com>
Cc: James Bottomley <James.Bottomley@steeleye.com>
Cc: Greg KH <greg@kroah.com>
Cc: "David S. Miller" <davem@davemloft.net>
Cc: Jeff Garzik <jgarzik@pobox.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>
This commit is contained in:
David Hardeman 2005-09-17 17:55:31 +10:00 committed by Herbert Xu
parent d32311fed7
commit 378f058cc4
10 changed files with 44 additions and 105 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
crypto/hmac.c
View file

@ -18,18 +18,15 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/scatterlist.h> #include <linux/scatterlist.h>
#include "internal.h" #include "internal.h"
static void hash_key(struct crypto_tfm *tfm, u8 *key, unsigned int keylen) static void hash_key(struct crypto_tfm *tfm, u8 *key, unsigned int keylen)
{ {
struct scatterlist tmp; struct scatterlist tmp;
tmp.page = virt_to_page(key); sg_set_buf(&tmp, key, keylen);
tmp.offset = offset_in_page(key);
tmp.length = keylen;
crypto_digest_digest(tfm, &tmp, 1, key); crypto_digest_digest(tfm, &tmp, 1, key);
} }
int crypto_alloc_hmac_block(struct crypto_tfm *tfm) int crypto_alloc_hmac_block(struct crypto_tfm *tfm)
@ -69,9 +66,7 @@ void crypto_hmac_init(struct crypto_tfm *tfm, u8 *key, unsigned int *keylen)
for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++) for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
ipad[i] ^= 0x36; ipad[i] ^= 0x36;
tmp.page = virt_to_page(ipad); sg_set_buf(&tmp, ipad, crypto_tfm_alg_blocksize(tfm));
tmp.offset = offset_in_page(ipad);
tmp.length = crypto_tfm_alg_blocksize(tfm);
crypto_digest_init(tfm); crypto_digest_init(tfm);
crypto_digest_update(tfm, &tmp, 1); crypto_digest_update(tfm, &tmp, 1);
@ -103,16 +98,12 @@ void crypto_hmac_final(struct crypto_tfm *tfm, u8 *key,
for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++) for (i = 0; i < crypto_tfm_alg_blocksize(tfm); i++)
opad[i] ^= 0x5c; opad[i] ^= 0x5c;
tmp.page = virt_to_page(opad); sg_set_buf(&tmp, opad, crypto_tfm_alg_blocksize(tfm));
tmp.offset = offset_in_page(opad);
tmp.length = crypto_tfm_alg_blocksize(tfm);
crypto_digest_init(tfm); crypto_digest_init(tfm);
crypto_digest_update(tfm, &tmp, 1); crypto_digest_update(tfm, &tmp, 1);
tmp.page = virt_to_page(out); sg_set_buf(&tmp, out, crypto_tfm_alg_digestsize(tfm));
tmp.offset = offset_in_page(out);
tmp.length = crypto_tfm_alg_digestsize(tfm);
crypto_digest_update(tfm, &tmp, 1); crypto_digest_update(tfm, &tmp, 1);
crypto_digest_final(tfm, out); crypto_digest_final(tfm, out);

52
crypto/tcrypt.c
View file

@ -21,7 +21,7 @@
#include <linux/module.h> #include <linux/module.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/string.h> #include <linux/string.h>
#include <linux/crypto.h> #include <linux/crypto.h>
#include <linux/highmem.h> #include <linux/highmem.h>
@ -86,7 +86,6 @@ static void hexdump(unsigned char *buf, unsigned int len)
static void test_hash(char *algo, struct hash_testvec *template, static void test_hash(char *algo, struct hash_testvec *template,
unsigned int tcount) unsigned int tcount)
{ {
char *p;
unsigned int i, j, k, temp; unsigned int i, j, k, temp;
struct scatterlist sg[8]; struct scatterlist sg[8];
char result[64]; char result[64];
@ -116,10 +115,7 @@ static void test_hash(char *algo, struct hash_testvec *template,
printk("test %u:\n", i + 1); printk("test %u:\n", i + 1);
memset(result, 0, 64); memset(result, 0, 64);
p = hash_tv[i].plaintext; sg_set_buf(&sg[0], hash_tv[i].plaintext, hash_tv[i].psize);
sg[0].page = virt_to_page(p);
sg[0].offset = offset_in_page(p);
sg[0].length = hash_tv[i].psize;
crypto_digest_init(tfm); crypto_digest_init(tfm);
if (tfm->crt_u.digest.dit_setkey) { if (tfm->crt_u.digest.dit_setkey) {
@ -154,10 +150,8 @@ static void test_hash(char *algo, struct hash_testvec *template,
hash_tv[i].plaintext + temp, hash_tv[i].plaintext + temp,
hash_tv[i].tap[k]); hash_tv[i].tap[k]);
temp += hash_tv[i].tap[k]; temp += hash_tv[i].tap[k];
p = &xbuf[IDX[k]]; sg_set_buf(&sg[k], &xbuf[IDX[k]],
sg[k].page = virt_to_page(p); hash_tv[i].tap[k]);
sg[k].offset = offset_in_page(p);
sg[k].length = hash_tv[i].tap[k];
} }
crypto_digest_digest(tfm, sg, hash_tv[i].np, result); crypto_digest_digest(tfm, sg, hash_tv[i].np, result);
@ -179,7 +173,6 @@ static void test_hash(char *algo, struct hash_testvec *template,
static void test_hmac(char *algo, struct hmac_testvec *template, static void test_hmac(char *algo, struct hmac_testvec *template,
unsigned int tcount) unsigned int tcount)
{ {
char *p;
unsigned int i, j, k, temp; unsigned int i, j, k, temp;
struct scatterlist sg[8]; struct scatterlist sg[8];
char result[64]; char result[64];
@ -210,11 +203,8 @@ static void test_hmac(char *algo, struct hmac_testvec *template,
printk("test %u:\n", i + 1); printk("test %u:\n", i + 1);
memset(result, 0, sizeof (result)); memset(result, 0, sizeof (result));
p = hmac_tv[i].plaintext;
klen = hmac_tv[i].ksize; klen = hmac_tv[i].ksize;
sg[0].page = virt_to_page(p); sg_set_buf(&sg[0], hmac_tv[i].plaintext, hmac_tv[i].psize);
sg[0].offset = offset_in_page(p);
sg[0].length = hmac_tv[i].psize;
crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result); crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, 1, result);
@ -243,10 +233,8 @@ static void test_hmac(char *algo, struct hmac_testvec *template,
hmac_tv[i].plaintext + temp, hmac_tv[i].plaintext + temp,
hmac_tv[i].tap[k]); hmac_tv[i].tap[k]);
temp += hmac_tv[i].tap[k]; temp += hmac_tv[i].tap[k];
p = &xbuf[IDX[k]]; sg_set_buf(&sg[k], &xbuf[IDX[k]],
sg[k].page = virt_to_page(p); hmac_tv[i].tap[k]);
sg[k].offset = offset_in_page(p);
sg[k].length = hmac_tv[i].tap[k];
} }
crypto_hmac(tfm, hmac_tv[i].key, &klen, sg, crypto_hmac(tfm, hmac_tv[i].key, &klen, sg,
@ -270,7 +258,7 @@ static void test_cipher(char *algo, int mode, int enc,
{ {
unsigned int ret, i, j, k, temp; unsigned int ret, i, j, k, temp;
unsigned int tsize; unsigned int tsize;
char *p, *q; char *q;
struct crypto_tfm *tfm; struct crypto_tfm *tfm;
char *key; char *key;
struct cipher_testvec *cipher_tv; struct cipher_testvec *cipher_tv;
@ -330,10 +318,8 @@ static void test_cipher(char *algo, int mode, int enc,
goto out; goto out;
} }
p = cipher_tv[i].input; sg_set_buf(&sg[0], cipher_tv[i].input,
sg[0].page = virt_to_page(p); cipher_tv[i].ilen);
sg[0].offset = offset_in_page(p);
sg[0].length = cipher_tv[i].ilen;
if (!mode) { if (!mode) {
crypto_cipher_set_iv(tfm, cipher_tv[i].iv, crypto_cipher_set_iv(tfm, cipher_tv[i].iv,
@ -389,10 +375,8 @@ static void test_cipher(char *algo, int mode, int enc,
cipher_tv[i].input + temp, cipher_tv[i].input + temp,
cipher_tv[i].tap[k]); cipher_tv[i].tap[k]);
temp += cipher_tv[i].tap[k]; temp += cipher_tv[i].tap[k];
p = &xbuf[IDX[k]]; sg_set_buf(&sg[k], &xbuf[IDX[k]],
sg[k].page = virt_to_page(p); cipher_tv[i].tap[k]);
sg[k].offset = offset_in_page(p);
sg[k].length = cipher_tv[i].tap[k];
} }
if (!mode) { if (!mode) {
@ -436,9 +420,7 @@ static int test_cipher_jiffies(struct crypto_tfm *tfm, int enc, char *p,
int bcount; int bcount;
int ret; int ret;
sg[0].page = virt_to_page(p); sg_set_buf(&sg[0], p, blen);
sg[0].offset = offset_in_page(p);
sg[0].length = blen;
for (start = jiffies, end = start + sec * HZ, bcount = 0; for (start = jiffies, end = start + sec * HZ, bcount = 0;
time_before(jiffies, end); bcount++) { time_before(jiffies, end); bcount++) {
@ -464,9 +446,7 @@ static int test_cipher_cycles(struct crypto_tfm *tfm, int enc, char *p,
int ret = 0; int ret = 0;
int i; int i;
sg[0].page = virt_to_page(p); sg_set_buf(&sg[0], p, blen);
sg[0].offset = offset_in_page(p);
sg[0].length = blen;
local_bh_disable(); local_bh_disable();
local_irq_disable(); local_irq_disable();
@ -709,9 +689,7 @@ static void test_crc32c(void)
for (i = 0; i < NUMVEC; i++) { for (i = 0; i < NUMVEC; i++) {
for (j = 0; j < VECSIZE; j++) for (j = 0; j < VECSIZE; j++)
test_vec[i][j] = ++b; test_vec[i][j] = ++b;
sg[i].page = virt_to_page(test_vec[i]); sg_set_buf(&sg[i], test_vec[i], VECSIZE);
sg[i].offset = offset_in_page(test_vec[i]);
sg[i].length = VECSIZE;
} }
seed = SEEDTESTVAL; seed = SEEDTESTVAL;

12
drivers/md/dm-crypt.c
View file

@ -15,7 +15,7 @@
#include <linux/crypto.h> #include <linux/crypto.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <asm/atomic.h> #include <asm/atomic.h>
#include <asm/scatterlist.h> #include <linux/scatterlist.h>
#include <asm/page.h> #include <asm/page.h>
#include "dm.h" #include "dm.h"
@ -164,9 +164,7 @@ static int crypt_iv_essiv_ctr(struct crypt_config *cc, struct dm_target *ti,
return -ENOMEM; return -ENOMEM;
} }
sg.page = virt_to_page(cc->key); sg_set_buf(&sg, cc->key, cc->key_size);
sg.offset = offset_in_page(cc->key);
sg.length = cc->key_size;
crypto_digest_digest(hash_tfm, &sg, 1, salt); crypto_digest_digest(hash_tfm, &sg, 1, salt);
crypto_free_tfm(hash_tfm); crypto_free_tfm(hash_tfm);
@ -207,14 +205,12 @@ static void crypt_iv_essiv_dtr(struct crypt_config *cc)
static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv, sector_t sector) static int crypt_iv_essiv_gen(struct crypt_config *cc, u8 *iv, sector_t sector)
{ {
struct scatterlist sg = { NULL, }; struct scatterlist sg;
memset(iv, 0, cc->iv_size); memset(iv, 0, cc->iv_size);
*(u64 *)iv = cpu_to_le64(sector); *(u64 *)iv = cpu_to_le64(sector);
sg.page = virt_to_page(iv); sg_set_buf(&sg, iv, cc->iv_size);
sg.offset = offset_in_page(iv);
sg.length = cc->iv_size;
crypto_cipher_encrypt((struct crypto_tfm *)cc->iv_gen_private, crypto_cipher_encrypt((struct crypto_tfm *)cc->iv_gen_private,
&sg, &sg, cc->iv_size); &sg, &sg, cc->iv_size);

5
drivers/net/wireless/airo.c
View file

@ -35,6 +35,7 @@
#include <linux/interrupt.h> #include <linux/interrupt.h>
#include <linux/in.h> #include <linux/in.h>
#include <linux/bitops.h> #include <linux/bitops.h>
#include <linux/scatterlist.h>
#include <asm/io.h> #include <asm/io.h>
#include <asm/system.h> #include <asm/system.h>
@ -1590,9 +1591,7 @@ static void emmh32_setseed(emmh32_context *context, u8 *pkey, int keylen, struct
aes_counter[12] = (u8)(counter >> 24); aes_counter[12] = (u8)(counter >> 24);
counter++; counter++;
memcpy (plain, aes_counter, 16); memcpy (plain, aes_counter, 16);
sg[0].page = virt_to_page(plain); sg_set_buf(&sg[0], plain, 16);
sg[0].offset = ((long) plain & ~PAGE_MASK);
sg[0].length = 16;
crypto_cipher_encrypt(tfm, sg, sg, 16); crypto_cipher_encrypt(tfm, sg, sg, 16);
cipher = kmap(sg[0].page) + sg[0].offset; cipher = kmap(sg[0].page) + sg[0].offset;
for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) { for (j=0; (j<16) && (i< (sizeof(context->coeff)/sizeof(context->coeff[0]))); ) {

6
drivers/scsi/arm/scsi.h
View file

@ -10,6 +10,8 @@
* Commonly used scsi driver functions. * Commonly used scsi driver functions.
*/ */
#include <linux/scatterlist.h>
#define BELT_AND_BRACES #define BELT_AND_BRACES
/* /*
@ -22,9 +24,7 @@ static inline int copy_SCp_to_sg(struct scatterlist *sg, Scsi_Pointer *SCp, int
BUG_ON(bufs + 1 > max); BUG_ON(bufs + 1 > max);
sg->page = virt_to_page(SCp->ptr); sg_set_buf(sg, SCp->ptr, SCp->this_residual);
sg->offset = offset_in_page(SCp->ptr);
sg->length = SCp->this_residual;
if (bufs) if (bufs)
memcpy(sg + 1, SCp->buffer + 1, memcpy(sg + 1, SCp->buffer + 1,

10
drivers/scsi/libata-core.c
View file

@ -49,6 +49,7 @@
#include <linux/suspend.h> #include <linux/suspend.h>
#include <linux/workqueue.h> #include <linux/workqueue.h>
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/scatterlist.h>
#include <scsi/scsi.h> #include <scsi/scsi.h>
#include "scsi.h" #include "scsi.h"
#include "scsi_priv.h" #include "scsi_priv.h"
@ -2576,19 +2577,12 @@ void ata_qc_prep(struct ata_queued_cmd *qc)
void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen) void ata_sg_init_one(struct ata_queued_cmd *qc, void *buf, unsigned int buflen)
{ {
struct scatterlist *sg;
qc->flags |= ATA_QCFLAG_SINGLE; qc->flags |= ATA_QCFLAG_SINGLE;
memset(&qc->sgent, 0, sizeof(qc->sgent));
qc->sg = &qc->sgent; qc->sg = &qc->sgent;
qc->n_elem = 1; qc->n_elem = 1;
qc->buf_virt = buf; qc->buf_virt = buf;
sg_init_one(qc->sg, buf, buflen);
sg = qc->sg;
sg->page = virt_to_page(buf);
sg->offset = (unsigned long) buf & ~PAGE_MASK;
sg->length = buflen;
} }
/** /**

5
drivers/scsi/sg.c
View file

@ -49,6 +49,7 @@ static int sg_version_num = 30533; /* 2 digits for each component */
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/blkdev.h> #include <linux/blkdev.h>
#include <linux/delay.h> #include <linux/delay.h>
#include <linux/scatterlist.h>
#include "scsi.h" #include "scsi.h"
#include <scsi/scsi_dbg.h> #include <scsi/scsi_dbg.h>
@ -1992,9 +1993,7 @@ sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
if (!p) if (!p)
break; break;
} }
sclp->page = virt_to_page(p); sg_set_buf(sclp, p, ret_sz);
sclp->offset = offset_in_page(p);
sclp->length = ret_sz;
SCSI_LOG_TIMEOUT(5, printk("sg_build_build: k=%d, a=0x%p, len=%d\n", SCSI_LOG_TIMEOUT(5, printk("sg_build_build: k=%d, a=0x%p, len=%d\n",
k, sg_scatg2virt(sclp), ret_sz)); k, sg_scatg2virt(sclp), ret_sz));

7
drivers/usb/misc/usbtest.c
View file

@ -9,7 +9,7 @@
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/module.h> #include <linux/module.h>
#include <linux/moduleparam.h> #include <linux/moduleparam.h>
#include <asm/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/usb.h> #include <linux/usb.h>
@ -381,7 +381,6 @@ alloc_sglist (int nents, int max, int vary)
sg = kmalloc (nents * sizeof *sg, SLAB_KERNEL); sg = kmalloc (nents * sizeof *sg, SLAB_KERNEL);
if (!sg) if (!sg)
return NULL; return NULL;
memset (sg, 0, nents * sizeof *sg);
for (i = 0; i < nents; i++) { for (i = 0; i < nents; i++) {
char *buf; char *buf;
@ -394,9 +393,7 @@ alloc_sglist (int nents, int max, int vary)
memset (buf, 0, size); memset (buf, 0, size);
/* kmalloc pages are always physically contiguous! */ /* kmalloc pages are always physically contiguous! */
sg [i].page = virt_to_page (buf); sg_init_one(&sg[i], buf, size);
sg [i].offset = offset_in_page (buf);
sg [i].length = size;
if (vary) { if (vary) {
size += vary; size += vary;

10
net/ipv6/addrconf.c
View file

@ -75,7 +75,7 @@
#ifdef CONFIG_IPV6_PRIVACY #ifdef CONFIG_IPV6_PRIVACY
#include <linux/random.h> #include <linux/random.h>
#include <linux/crypto.h> #include <linux/crypto.h>
#include <asm/scatterlist.h> #include <linux/scatterlist.h>
#endif #endif
#include <asm/uaccess.h> #include <asm/uaccess.h>
@ -1217,12 +1217,8 @@ static int __ipv6_regen_rndid(struct inet6_dev *idev)
struct net_device *dev; struct net_device *dev;
struct scatterlist sg[2]; struct scatterlist sg[2];
sg[0].page = virt_to_page(idev->entropy); sg_set_buf(&sg[0], idev->entropy, 8);
sg[0].offset = offset_in_page(idev->entropy); sg_set_buf(&sg[1], idev->work_eui64, 8);
sg[0].length = 8;
sg[1].page = virt_to_page(idev->work_eui64);
sg[1].offset = offset_in_page(idev->work_eui64);
sg[1].length = 8;
dev = idev->dev; dev = idev->dev;

23
net/sunrpc/auth_gss/gss_krb5_crypto.c
View file

@ -37,7 +37,7 @@
#include <linux/types.h> #include <linux/types.h>
#include <linux/mm.h> #include <linux/mm.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <asm/scatterlist.h> #include <linux/scatterlist.h>
#include <linux/crypto.h> #include <linux/crypto.h>
#include <linux/highmem.h> #include <linux/highmem.h>
#include <linux/pagemap.h> #include <linux/pagemap.h>
@ -75,9 +75,7 @@ krb5_encrypt(
memcpy(local_iv, iv, crypto_tfm_alg_ivsize(tfm)); memcpy(local_iv, iv, crypto_tfm_alg_ivsize(tfm));
memcpy(out, in, length); memcpy(out, in, length);
sg[0].page = virt_to_page(out); sg_set_buf(&sg[0], out, length);
sg[0].offset = offset_in_page(out);
sg[0].length = length;
ret = crypto_cipher_encrypt_iv(tfm, sg, sg, length, local_iv); ret = crypto_cipher_encrypt_iv(tfm, sg, sg, length, local_iv);
@ -117,9 +115,7 @@ krb5_decrypt(
memcpy(local_iv,iv, crypto_tfm_alg_ivsize(tfm)); memcpy(local_iv,iv, crypto_tfm_alg_ivsize(tfm));
memcpy(out, in, length); memcpy(out, in, length);
sg[0].page = virt_to_page(out); sg_set_buf(&sg[0], out, length);
sg[0].offset = offset_in_page(out);
sg[0].length = length;
ret = crypto_cipher_decrypt_iv(tfm, sg, sg, length, local_iv); ret = crypto_cipher_decrypt_iv(tfm, sg, sg, length, local_iv);
@ -132,13 +128,6 @@ out:
EXPORT_SYMBOL(krb5_decrypt); EXPORT_SYMBOL(krb5_decrypt);
static void
buf_to_sg(struct scatterlist *sg, char *ptr, int len) {
sg->page = virt_to_page(ptr);
sg->offset = offset_in_page(ptr);
sg->length = len;
}
static int static int
process_xdr_buf(struct xdr_buf *buf, int offset, int len, process_xdr_buf(struct xdr_buf *buf, int offset, int len,
int (*actor)(struct scatterlist *, void *), void *data) int (*actor)(struct scatterlist *, void *), void *data)
@ -152,7 +141,7 @@ process_xdr_buf(struct xdr_buf *buf, int offset, int len,
thislen = buf->head[0].iov_len - offset; thislen = buf->head[0].iov_len - offset;
if (thislen > len) if (thislen > len)
thislen = len; thislen = len;
buf_to_sg(sg, buf->head[0].iov_base + offset, thislen); sg_set_buf(sg, buf->head[0].iov_base + offset, thislen);
ret = actor(sg, data); ret = actor(sg, data);
if (ret) if (ret)
goto out; goto out;
@ -195,7 +184,7 @@ process_xdr_buf(struct xdr_buf *buf, int offset, int len,
thislen = buf->tail[0].iov_len - offset; thislen = buf->tail[0].iov_len - offset;
if (thislen > len) if (thislen > len)
thislen = len; thislen = len;
buf_to_sg(sg, buf->tail[0].iov_base + offset, thislen); sg_set_buf(sg, buf->tail[0].iov_base + offset, thislen);
ret = actor(sg, data); ret = actor(sg, data);
len -= thislen; len -= thislen;
} }
@ -241,7 +230,7 @@ make_checksum(s32 cksumtype, char *header, int hdrlen, struct xdr_buf *body,
goto out; goto out;
crypto_digest_init(tfm); crypto_digest_init(tfm);
buf_to_sg(sg, header, hdrlen); sg_set_buf(sg, header, hdrlen);
crypto_digest_update(tfm, sg, 1); crypto_digest_update(tfm, sg, 1);
process_xdr_buf(body, body_offset, body->len - body_offset, process_xdr_buf(body, body_offset, body->len - body_offset,
checksummer, tfm); checksummer, tfm);