GitHub-Mirror/linux-bl808
2
0
Fork 0
mirror of https://github.com/Fishwaldo/linux-bl808.git synced 2025-06-17 20:25:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

SG: Change sg_set_page() to take length and offset argument

Browse source 
Most drivers need to set length and offset as well, so may as well fold
those three lines into one.

Add sg_assign_page() for those two locations that only needed to set
the page, where the offset/length is set outside of the function context.

Signed-off-by: Jens Axboe <jens.axboe@oracle.com>
This commit is contained in:
Jens Axboe 2007-10-24 11:20:47 +02:00
parent bd6dee6f30
commit 642f149031
31 changed files with 99 additions and 162 deletions
Download patch file Download diff file Expand all files Collapse all files

4
block/ll_rw_blk.c
View file

@ -1366,9 +1366,7 @@ new_segment:
sg = sg_next(sg); sg = sg_next(sg);
} }
sg_set_page(sg, bvec->bv_page); sg_set_page(sg, bvec->bv_page, nbytes, bvec->bv_offset);
sg->length = nbytes;
sg->offset = bvec->bv_offset;
nsegs++; nsegs++;
} }
bvprv = bvec; bvprv = bvec;

3
crypto/hmac.c
View file

@ -160,8 +160,7 @@ static int hmac_digest(struct hash_desc *pdesc, struct scatterlist *sg,
sg_set_buf(sg1, ipad, bs); sg_set_buf(sg1, ipad, bs);
sg_set_page(&sg[1], (void *) sg); sg_set_page(&sg[1], (void *) sg, 0, 0);
sg1[1].length = 0;
sg_set_buf(sg2, opad, bs + ds); sg_set_buf(sg2, opad, bs + ds);
err = crypto_hash_digest(&desc, sg1, nbytes + bs, digest); err = crypto_hash_digest(&desc, sg1, nbytes + bs, digest);

4
drivers/ata/libata-core.c
View file

@ -4689,8 +4689,8 @@ static int ata_sg_setup(struct ata_queued_cmd *qc)
* data in this function or read data in ata_sg_clean. * data in this function or read data in ata_sg_clean.
*/ */
offset = lsg->offset + lsg->length - qc->pad_len; offset = lsg->offset + lsg->length - qc->pad_len;
sg_set_page(psg, nth_page(sg_page(lsg), offset >> PAGE_SHIFT)); sg_set_page(psg, nth_page(sg_page(lsg), offset >> PAGE_SHIFT),
psg->offset = offset_in_page(offset); qc->pad_len, offset_in_page(offset));
if (qc->tf.flags & ATA_TFLAG_WRITE) { if (qc->tf.flags & ATA_TFLAG_WRITE) {
void *addr = kmap_atomic(sg_page(psg), KM_IRQ0); void *addr = kmap_atomic(sg_page(psg), KM_IRQ0);

9
drivers/block/cryptoloop.c
View file

@ -150,13 +150,8 @@ cryptoloop_transfer(struct loop_device *lo, int cmd,
u32 iv[4] = { 0, }; u32 iv[4] = { 0, };
iv[0] = cpu_to_le32(IV & 0xffffffff); iv[0] = cpu_to_le32(IV & 0xffffffff);
sg_set_page(&sg_in, in_page); sg_set_page(&sg_in, in_page, sz, in_offs);
sg_in.offset = in_offs; sg_set_page(&sg_out, out_page, sz, out_offs);
sg_in.length = sz;
sg_set_page(&sg_out, out_page);
sg_out.offset = out_offs;
sg_out.length = sz;
desc.info = iv; desc.info = iv;
err = encdecfunc(&desc, &sg_out, &sg_in, sz); err = encdecfunc(&desc, &sg_out, &sg_in, sz);

9
drivers/block/ub.c
View file

@ -1428,9 +1428,8 @@ static void ub_state_sense(struct ub_dev *sc, struct ub_scsi_cmd *cmd)
scmd->state = UB_CMDST_INIT; scmd->state = UB_CMDST_INIT;
scmd->nsg = 1; scmd->nsg = 1;
sg = &scmd->sgv[0]; sg = &scmd->sgv[0];
sg_set_page(sg, virt_to_page(sc->top_sense)); sg_set_page(sg, virt_to_page(sc->top_sense), UB_SENSE_SIZE,
sg->offset = (unsigned long)sc->top_sense & (PAGE_SIZE-1); (unsigned long)sc->top_sense & (PAGE_SIZE-1));
sg->length = UB_SENSE_SIZE;
scmd->len = UB_SENSE_SIZE; scmd->len = UB_SENSE_SIZE;
scmd->lun = cmd->lun; scmd->lun = cmd->lun;
scmd->done = ub_top_sense_done; scmd->done = ub_top_sense_done;
@ -1864,9 +1863,7 @@ static int ub_sync_read_cap(struct ub_dev *sc, struct ub_lun *lun,
cmd->state = UB_CMDST_INIT; cmd->state = UB_CMDST_INIT;
cmd->nsg = 1; cmd->nsg = 1;
sg = &cmd->sgv[0]; sg = &cmd->sgv[0];
sg_set_page(sg, virt_to_page(p)); sg_set_page(sg, virt_to_page(p), 8, (unsigned long)p & (PAGE_SIZE-1));
sg->offset = (unsigned long)p & (PAGE_SIZE-1);
sg->length = 8;
cmd->len = 8; cmd->len = 8;
cmd->lun = lun; cmd->lun = lun;
cmd->done = ub_probe_done; cmd->done = ub_probe_done;

4
drivers/ieee1394/dma.c
View file

@ -111,8 +111,8 @@ int dma_region_alloc(struct dma_region *dma, unsigned long n_bytes,
unsigned long va = unsigned long va =
(unsigned long)dma->kvirt + (i << PAGE_SHIFT); (unsigned long)dma->kvirt + (i << PAGE_SHIFT);
sg_set_page(&dma->sglist[i], vmalloc_to_page((void *)va)); sg_set_page(&dma->sglist[i], vmalloc_to_page((void *)va),
dma->sglist[i].length = PAGE_SIZE; PAGE_SIZE, 0);
} }
/* map sglist to the IOMMU */ /* map sglist to the IOMMU */

4
drivers/infiniband/core/umem.c
View file

@ -171,9 +171,7 @@ struct ib_umem *ib_umem_get(struct ib_ucontext *context, unsigned long addr,
if (vma_list && if (vma_list &&
!is_vm_hugetlb_page(vma_list[i + off])) !is_vm_hugetlb_page(vma_list[i + off]))
umem->hugetlb = 0; umem->hugetlb = 0;
sg_set_page(&chunk->page_list[i], page_list[i + off]); sg_set_page(&chunk->page_list[i], page_list[i + off], PAGE_SIZE, 0);
chunk->page_list[i].offset = 0;
chunk->page_list[i].length = PAGE_SIZE;
} }
chunk->nmap = ib_dma_map_sg(context->device, chunk->nmap = ib_dma_map_sg(context->device,

9
drivers/infiniband/hw/mthca/mthca_memfree.c
View file

@ -113,9 +113,7 @@ static int mthca_alloc_icm_pages(struct scatterlist *mem, int order, gfp_t gfp_m
if (!page) if (!page)
return -ENOMEM; return -ENOMEM;
sg_set_page(mem, page); sg_set_page(mem, page, PAGE_SIZE << order, 0);
mem->length = PAGE_SIZE << order;
mem->offset = 0;
return 0; return 0;
} }
@ -481,9 +479,8 @@ int mthca_map_user_db(struct mthca_dev *dev, struct mthca_uar *uar,
if (ret < 0) if (ret < 0)
goto out; goto out;
sg_set_page(&db_tab->page[i].mem, pages[0]); sg_set_page(&db_tab->page[i].mem, pages[0], MTHCA_ICM_PAGE_SIZE,
db_tab->page[i].mem.length = MTHCA_ICM_PAGE_SIZE; uaddr & ~PAGE_MASK);
db_tab->page[i].mem.offset = uaddr & ~PAGE_MASK;
ret = pci_map_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE); ret = pci_map_sg(dev->pdev, &db_tab->page[i].mem, 1, PCI_DMA_TODEVICE);
if (ret < 0) { if (ret < 0) {

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

@ -351,14 +351,10 @@ static int crypt_convert(struct crypt_config *cc,
struct scatterlist sg_in, sg_out; struct scatterlist sg_in, sg_out;
sg_init_table(&sg_in, 1); sg_init_table(&sg_in, 1);
sg_set_page(&sg_in, bv_in->bv_page); sg_set_page(&sg_in, bv_in->bv_page, 1 << SECTOR_SHIFT, bv_in->bv_offset + ctx->offset_in);
sg_in.offset = bv_in->bv_offset + ctx->offset_in;
sg_in.length = 1 << SECTOR_SHIFT;
sg_init_table(&sg_out, 1); sg_init_table(&sg_out, 1);
sg_set_page(&sg_out, bv_out->bv_page); sg_set_page(&sg_out, bv_out->bv_page, 1 << SECTOR_SHIFT, bv_out->bv_offset + ctx->offset_out);
sg_out.offset = bv_out->bv_offset + ctx->offset_out;
sg_out.length = 1 << SECTOR_SHIFT;
ctx->offset_in += sg_in.length; ctx->offset_in += sg_in.length;
if (ctx->offset_in >= bv_in->bv_len) { if (ctx->offset_in >= bv_in->bv_len) {

3
drivers/media/common/saa7146_core.c
View file

@ -118,8 +118,7 @@ static struct scatterlist* vmalloc_to_sg(unsigned char *virt, int nr_pages)
if (NULL == pg) if (NULL == pg)
goto err; goto err;
BUG_ON(PageHighMem(pg)); BUG_ON(PageHighMem(pg));
sg_set_page(&sglist[i], pg); sg_set_page(&sglist[i], pg, PAGE_SIZE, 0);
sglist[i].length = PAGE_SIZE;
} }
return sglist; return sglist;

6
drivers/media/video/ivtv/ivtv-udma.c
View file

@ -49,8 +49,6 @@ int ivtv_udma_fill_sg_list (struct ivtv_user_dma *dma, struct ivtv_dma_page_info
unsigned int len = (i == dma_page->page_count - 1) ? unsigned int len = (i == dma_page->page_count - 1) ?
dma_page->tail : PAGE_SIZE - offset; dma_page->tail : PAGE_SIZE - offset;
dma->SGlist[map_offset].length = len;
dma->SGlist[map_offset].offset = offset;
if (PageHighMem(dma->map[map_offset])) { if (PageHighMem(dma->map[map_offset])) {
void *src; void *src;
@ -63,10 +61,10 @@ int ivtv_udma_fill_sg_list (struct ivtv_user_dma *dma, struct ivtv_dma_page_info
memcpy(page_address(dma->bouncemap[map_offset]) + offset, src, len); memcpy(page_address(dma->bouncemap[map_offset]) + offset, src, len);
kunmap_atomic(src, KM_BOUNCE_READ); kunmap_atomic(src, KM_BOUNCE_READ);
local_irq_restore(flags); local_irq_restore(flags);
sg_set_page(&dma->SGlist[map_offset], dma->bouncemap[map_offset]); sg_set_page(&dma->SGlist[map_offset], dma->bouncemap[map_offset], len, offset);
} }
else { else {
sg_set_page(&dma->SGlist[map_offset], dma->map[map_offset]); sg_set_page(&dma->SGlist[map_offset], dma->map[map_offset], len, offset);
} }
offset = 0; offset = 0;
map_offset++; map_offset++;

10
drivers/media/video/videobuf-dma-sg.c
View file

@ -67,8 +67,7 @@ videobuf_vmalloc_to_sg(unsigned char *virt, int nr_pages)
if (NULL == pg) if (NULL == pg)
goto err; goto err;
BUG_ON(PageHighMem(pg)); BUG_ON(PageHighMem(pg));
sg_set_page(&sglist[i], pg); sg_set_page(&sglist[i], pg, PAGE_SIZE, 0);
sglist[i].length = PAGE_SIZE;
} }
return sglist; return sglist;
@ -95,16 +94,13 @@ videobuf_pages_to_sg(struct page **pages, int nr_pages, int offset)
if (PageHighMem(pages[0])) if (PageHighMem(pages[0]))
/* DMA to highmem pages might not work */ /* DMA to highmem pages might not work */
goto highmem; goto highmem;
sg_set_page(&sglist[0], pages[0]); sg_set_page(&sglist[0], pages[0], PAGE_SIZE - offset, offset);
sglist[0].offset = offset;
sglist[0].length = PAGE_SIZE - offset;
for (i = 1; i < nr_pages; i++) { for (i = 1; i < nr_pages; i++) {
if (NULL == pages[i]) if (NULL == pages[i])
goto nopage; goto nopage;
if (PageHighMem(pages[i])) if (PageHighMem(pages[i]))
goto highmem; goto highmem;
sg_set_page(&sglist[i], pages[i]); sg_set_page(&sglist[i], pages[i], PAGE_SIZE, 0);
sglist[i].length = PAGE_SIZE;
} }
return sglist; return sglist;

4
drivers/net/mlx4/icm.c
View file

@ -101,9 +101,7 @@ static int mlx4_alloc_icm_pages(struct scatterlist *mem, int order, gfp_t gfp_ma
if (!page) if (!page)
return -ENOMEM; return -ENOMEM;
sg_set_page(mem, page); sg_set_page(mem, page, PAGE_SIZE << order, 0);
mem->length = PAGE_SIZE << order;
mem->offset = 0;
return 0; return 0;
} }

10
drivers/s390/scsi/zfcp_aux.c
View file

@ -562,8 +562,6 @@ zfcp_sg_list_alloc(struct zfcp_sg_list *sg_list, size_t size)
sg_init_table(sg_list->sg, sg_list->count); sg_init_table(sg_list->sg, sg_list->count);
for (i = 0, sg = sg_list->sg; i < sg_list->count; i++, sg++) { for (i = 0, sg = sg_list->sg; i < sg_list->count; i++, sg++) {
sg->length = min(size, PAGE_SIZE);
sg->offset = 0;
address = (void *) get_zeroed_page(GFP_KERNEL); address = (void *) get_zeroed_page(GFP_KERNEL);
if (address == NULL) { if (address == NULL) {
sg_list->count = i; sg_list->count = i;
@ -571,7 +569,7 @@ zfcp_sg_list_alloc(struct zfcp_sg_list *sg_list, size_t size)
retval = -ENOMEM; retval = -ENOMEM;
goto out; goto out;
} }
zfcp_address_to_sg(address, sg); zfcp_address_to_sg(address, sg, min(size, PAGE_SIZE));
size -= sg->length; size -= sg->length;
} }
@ -1523,10 +1521,8 @@ zfcp_gid_pn_buffers_alloc(struct zfcp_gid_pn_data **gid_pn, mempool_t *pool)
data->ct.req = &data->req; data->ct.req = &data->req;
data->ct.resp = &data->resp; data->ct.resp = &data->resp;
data->ct.req_count = data->ct.resp_count = 1; data->ct.req_count = data->ct.resp_count = 1;
zfcp_address_to_sg(&data->ct_iu_req, &data->req); zfcp_address_to_sg(&data->ct_iu_req, &data->req, sizeof(struct ct_iu_gid_pn_req));
zfcp_address_to_sg(&data->ct_iu_resp, &data->resp); zfcp_address_to_sg(&data->ct_iu_resp, &data->resp, sizeof(struct ct_iu_gid_pn_resp));
data->req.length = sizeof(struct ct_iu_gid_pn_req);
data->resp.length = sizeof(struct ct_iu_gid_pn_resp);
*gid_pn = data; *gid_pn = data;
return 0; return 0;

3
drivers/s390/scsi/zfcp_def.h
View file

@ -74,8 +74,7 @@ zfcp_sg_to_address(struct scatterlist *list)
static inline void static inline void
zfcp_address_to_sg(void *address, struct scatterlist *list) zfcp_address_to_sg(void *address, struct scatterlist *list)
{ {
sg_set_page(list, virt_to_page(address)); sg_set_buf(list, address, 0);
list->offset = ((unsigned long) address) & (PAGE_SIZE - 1);
} }
#define REQUEST_LIST_SIZE 128 #define REQUEST_LIST_SIZE 128

7
drivers/s390/scsi/zfcp_erp.c
View file

@ -322,9 +322,9 @@ zfcp_erp_adisc(struct zfcp_port *port)
if (address == NULL) if (address == NULL)
goto nomem; goto nomem;
zfcp_address_to_sg(address, send_els->req); zfcp_address_to_sg(address, send_els->req, sizeof(struct zfcp_ls_adisc));
address += PAGE_SIZE >> 1; address += PAGE_SIZE >> 1;
zfcp_address_to_sg(address, send_els->resp); zfcp_address_to_sg(address, send_els->resp, sizeof(struct zfcp_ls_adisc_acc));
send_els->req_count = send_els->resp_count = 1; send_els->req_count = send_els->resp_count = 1;
send_els->adapter = adapter; send_els->adapter = adapter;
@ -336,9 +336,6 @@ zfcp_erp_adisc(struct zfcp_port *port)
adisc = zfcp_sg_to_address(send_els->req); adisc = zfcp_sg_to_address(send_els->req);
send_els->ls_code = adisc->code = ZFCP_LS_ADISC; send_els->ls_code = adisc->code = ZFCP_LS_ADISC;
send_els->req->length = sizeof(struct zfcp_ls_adisc);
send_els->resp->length = sizeof(struct zfcp_ls_adisc_acc);
/* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
without FC-AL-2 capability, so we don't set it */ without FC-AL-2 capability, so we don't set it */
adisc->wwpn = fc_host_port_name(adapter->scsi_host); adisc->wwpn = fc_host_port_name(adapter->scsi_host);

2
drivers/scsi/ipr.c
View file

@ -2890,7 +2890,7 @@ static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
return NULL; return NULL;
} }
sg_set_page(&scatterlist[i], page); sg_set_page(&scatterlist[i], page, 0, 0);
} }
return sglist; return sglist;

4
drivers/scsi/iscsi_tcp.c
View file

@ -79,9 +79,7 @@ static inline void
iscsi_buf_init_sg(struct iscsi_buf *ibuf, struct scatterlist *sg) iscsi_buf_init_sg(struct iscsi_buf *ibuf, struct scatterlist *sg)
{ {
sg_init_table(&ibuf->sg, 1); sg_init_table(&ibuf->sg, 1);
sg_set_page(&ibuf->sg, sg_page(sg)); sg_set_page(&ibuf->sg, sg_page(sg), sg->length, sg->offset);
ibuf->sg.offset = sg->offset;
ibuf->sg.length = sg->length;
/* /*
* Fastpath: sg element fits into single page * Fastpath: sg element fits into single page
*/ */

6
drivers/scsi/osst.c
View file

@ -5256,8 +5256,7 @@ static int enlarge_buffer(struct osst_buffer *STbuffer, int need_dma)
STbuffer->sg[0].offset = 0; STbuffer->sg[0].offset = 0;
if (page != NULL) { if (page != NULL) {
sg_set_page(&STbuffer->sg[0], page); sg_set_page(&STbuffer->sg[0], page, b_size, 0);
STbuffer->sg[0].length = b_size;
STbuffer->b_data = page_address(page); STbuffer->b_data = page_address(page);
break; break;
} }
@ -5285,8 +5284,7 @@ static int enlarge_buffer(struct osst_buffer *STbuffer, int need_dma)
normalize_buffer(STbuffer); normalize_buffer(STbuffer);
return 0; return 0;
} }
sg_set_page(&STbuffer->sg[segs], page); sg_set_page(&STbuffer->sg[segs], page, (OS_FRAME_SIZE - got <= PAGE_SIZE / 2) ? (OS_FRAME_SIZE - got) : b_size, 0);
STbuffer->sg[segs].length = (OS_FRAME_SIZE - got <= PAGE_SIZE / 2) ? (OS_FRAME_SIZE - got) : b_size;
got += STbuffer->sg[segs].length; got += STbuffer->sg[segs].length;
STbuffer->buffer_size = got; STbuffer->buffer_size = got;
STbuffer->sg_segs = ++segs; STbuffer->sg_segs = ++segs;

13
drivers/scsi/sg.c
View file

@ -1717,16 +1717,12 @@ st_map_user_pages(struct scatterlist *sgl, const unsigned int max_pages,
goto out_unlock; */ goto out_unlock; */
} }
sg_set_page(sgl, pages[0]); sg_set_page(sgl, pages[0], 0, uaddr & ~PAGE_MASK);
sgl[0].offset = uaddr & ~PAGE_MASK;
if (nr_pages > 1) { if (nr_pages > 1) {
sgl[0].length = PAGE_SIZE - sgl[0].offset; sgl[0].length = PAGE_SIZE - sgl[0].offset;
count -= sgl[0].length; count -= sgl[0].length;
for (i=1; i < nr_pages ; i++) { for (i=1; i < nr_pages ; i++)
sg_set_page(&sgl[i], pages[i]); sg_set_page(&sgl[i], pages[i], count < PAGE_SIZE ? count : PAGE_SIZE, 0);
sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
count -= PAGE_SIZE;
}
} }
else { else {
sgl[0].length = count; sgl[0].length = count;
@ -1854,8 +1850,7 @@ sg_build_indirect(Sg_scatter_hold * schp, Sg_fd * sfp, int buff_size)
scatter_elem_sz_prev = ret_sz; scatter_elem_sz_prev = ret_sz;
} }
} }
sg_set_page(sg, p); sg_set_page(sg, p, (ret_sz > num) ? num : ret_sz, 0);
sg->length = (ret_sz > num) ? num : ret_sz;
SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, " SCSI_LOG_TIMEOUT(5, printk("sg_build_indirect: k=%d, num=%d, "
"ret_sz=%d\n", k, num, ret_sz)); "ret_sz=%d\n", k, num, ret_sz));

14
drivers/scsi/st.c
View file

@ -3797,13 +3797,11 @@ static void buf_to_sg(struct st_buffer *STbp, unsigned int length)
sg = &(STbp->sg[0]); sg = &(STbp->sg[0]);
frp = STbp->frp; frp = STbp->frp;
for (i=count=0; count < length; i++) { for (i=count=0; count < length; i++) {
sg_set_page(&sg[i], frp[i].page);
if (length - count > frp[i].length) if (length - count > frp[i].length)
sg[i].length = frp[i].length; sg_set_page(&sg[i], frp[i].page, frp[i].length, 0);
else else
sg[i].length = length - count; sg_set_page(&sg[i], frp[i].page, length - count, 0);
count += sg[i].length; count += sg[i].length;
sg[i].offset = 0;
} }
STbp->sg_segs = i; STbp->sg_segs = i;
STbp->frp_sg_current = length; STbp->frp_sg_current = length;
@ -4446,15 +4444,13 @@ static int sgl_map_user_pages(struct scatterlist *sgl, const unsigned int max_pa
} }
/* Populate the scatter/gather list */ /* Populate the scatter/gather list */
sg_set_page(&sgl[0], pages[0]); sg_set_page(&sgl[0], pages[0], 0, uaddr & ~PAGE_MASK);
sgl[0].offset = uaddr & ~PAGE_MASK;
if (nr_pages > 1) { if (nr_pages > 1) {
sgl[0].length = PAGE_SIZE - sgl[0].offset; sgl[0].length = PAGE_SIZE - sgl[0].offset;
count -= sgl[0].length; count -= sgl[0].length;
for (i=1; i < nr_pages ; i++) { for (i=1; i < nr_pages ; i++) {
sg_set_page(&sgl[i], pages[i]);; sg_set_page(&sgl[i], pages[i],
sgl[i].offset = 0; count < PAGE_SIZE ? count : PAGE_SIZE, 0);;
sgl[i].length = count < PAGE_SIZE ? count : PAGE_SIZE;
count -= PAGE_SIZE; count -= PAGE_SIZE;
} }
} }

25
fs/ecryptfs/crypto.c
View file

@ -282,10 +282,8 @@ int virt_to_scatterlist(const void *addr, int size, struct scatterlist *sg,
while (size > 0 && i < sg_size) { while (size > 0 && i < sg_size) {
pg = virt_to_page(addr); pg = virt_to_page(addr);
offset = offset_in_page(addr); offset = offset_in_page(addr);
if (sg) { if (sg)
sg_set_page(&sg[i], pg); sg_set_page(&sg[i], pg, 0, offset);
sg[i].offset = offset;
}
remainder_of_page = PAGE_CACHE_SIZE - offset; remainder_of_page = PAGE_CACHE_SIZE - offset;
if (size >= remainder_of_page) { if (size >= remainder_of_page) {
if (sg) if (sg)
@ -716,12 +714,8 @@ ecryptfs_encrypt_page_offset(struct ecryptfs_crypt_stat *crypt_stat,
sg_init_table(&src_sg, 1); sg_init_table(&src_sg, 1);
sg_init_table(&dst_sg, 1); sg_init_table(&dst_sg, 1);
sg_set_page(&src_sg, src_page); sg_set_page(&src_sg, src_page, size, src_offset);
src_sg.offset = src_offset; sg_set_page(&dst_sg, dst_page, size, dst_offset);
src_sg.length = size;
sg_set_page(&dst_sg, dst_page);
dst_sg.offset = dst_offset;
dst_sg.length = size;
return encrypt_scatterlist(crypt_stat, &dst_sg, &src_sg, size, iv); return encrypt_scatterlist(crypt_stat, &dst_sg, &src_sg, size, iv);
} }
@ -746,14 +740,11 @@ ecryptfs_decrypt_page_offset(struct ecryptfs_crypt_stat *crypt_stat,
struct scatterlist src_sg, dst_sg; struct scatterlist src_sg, dst_sg;
sg_init_table(&src_sg, 1); sg_init_table(&src_sg, 1);
sg_init_table(&dst_sg, 1); sg_set_page(&src_sg, src_page, size, src_offset);
sg_init_table(&dst_sg, 1);
sg_set_page(&dst_sg, dst_page, size, dst_offset);
sg_set_page(&src_sg, src_page);
src_sg.offset = src_offset;
src_sg.length = size;
sg_set_page(&dst_sg, dst_page);
dst_sg.offset = dst_offset;
dst_sg.length = size;
return decrypt_scatterlist(crypt_stat, &dst_sg, &src_sg, size, iv); return decrypt_scatterlist(crypt_stat, &dst_sg, &src_sg, size, iv);
} }

3
include/asm-frv/scatterlist.h
View file

@ -16,8 +16,7 @@
* *
* can be rewritten as * can be rewritten as
* *
* sg_set_page(virt_to_page(some_ptr)); * sg_set_buf(sg, some_ptr, length);
* sg->offset = (unsigned long) some_ptr & ~PAGE_MASK;
* *
* and that's it. There's no excuse for not highmem enabling YOUR driver. /jens * and that's it. There's no excuse for not highmem enabling YOUR driver. /jens
*/ */

40
include/linux/scatterlist.h
View file

@ -26,18 +26,16 @@
#define SG_MAGIC 0x87654321 #define SG_MAGIC 0x87654321
/** /**
* sg_set_page - Set sg entry to point at given page * sg_assign_page - Assign a given page to an SG entry
* @sg: SG entry * @sg: SG entry
* @page: The page * @page: The page
* *
* Description: * Description:
* Use this function to set an sg entry pointing at a page, never assign * Assign page to sg entry. Also see sg_set_page(), the most commonly used
* the page directly. We encode sg table information in the lower bits * variant.
* of the page pointer. See sg_page() for looking up the page belonging
* to an sg entry.
* *
**/ **/
static inline void sg_set_page(struct scatterlist *sg, struct page *page) static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
{ {
unsigned long page_link = sg->page_link & 0x3; unsigned long page_link = sg->page_link & 0x3;
@ -52,6 +50,28 @@ static inline void sg_set_page(struct scatterlist *sg, struct page *page)
sg->page_link = page_link | (unsigned long) page; sg->page_link = page_link | (unsigned long) page;
} }
/**
* sg_set_page - Set sg entry to point at given page
* @sg: SG entry
* @page: The page
* @len: Length of data
* @offset: Offset into page
*
* Description:
* Use this function to set an sg entry pointing at a page, never assign
* the page directly. We encode sg table information in the lower bits
* of the page pointer. See sg_page() for looking up the page belonging
* to an sg entry.
*
**/
static inline void sg_set_page(struct scatterlist *sg, struct page *page,
unsigned int len, unsigned int offset)
{
sg_assign_page(sg, page);
sg->offset = offset;
sg->length = len;
}
#define sg_page(sg) ((struct page *) ((sg)->page_link & ~0x3)) #define sg_page(sg) ((struct page *) ((sg)->page_link & ~0x3))
/** /**
@ -64,9 +84,7 @@ static inline void sg_set_page(struct scatterlist *sg, struct page *page)
static inline void sg_set_buf(struct scatterlist *sg, const void *buf, static inline void sg_set_buf(struct scatterlist *sg, const void *buf,
unsigned int buflen) unsigned int buflen)
{ {
sg_set_page(sg, virt_to_page(buf)); sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
sg->offset = offset_in_page(buf);
sg->length = buflen;
} }
/* /*

9
net/core/skbuff.c
View file

@ -2045,9 +2045,7 @@ skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
if (copy > 0) { if (copy > 0) {
if (copy > len) if (copy > len)
copy = len; copy = len;
sg_set_page(&sg[elt], virt_to_page(skb->data + offset)); sg_set_buf(sg, skb->data + offset, copy);
sg[elt].offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
sg[elt].length = copy;
elt++; elt++;
if ((len -= copy) == 0) if ((len -= copy) == 0)
return elt; return elt;
@ -2065,9 +2063,8 @@ skb_to_sgvec(struct sk_buff *skb, struct scatterlist *sg, int offset, int len)
if (copy > len) if (copy > len)
copy = len; copy = len;
sg_set_page(&sg[elt], frag->page); sg_set_page(&sg[elt], frag->page, copy,
sg[elt].offset = frag->page_offset+offset-start; frag->page_offset+offset-start);
sg[elt].length = copy;
elt++; elt++;
if (!(len -= copy)) if (!(len -= copy))
return elt; return elt;

9
net/ieee80211/ieee80211_crypt_tkip.c
View file

@ -537,13 +537,8 @@ static int michael_mic(struct crypto_hash *tfm_michael, u8 * key, u8 * hdr,
return -1; return -1;
} }
sg_init_table(sg, 2); sg_init_table(sg, 2);
sg_set_page(&sg[0], virt_to_page(hdr)); sg_set_buf(&sg[0], hdr, 16);
sg[0].offset = offset_in_page(hdr); sg_set_buf(&sg[1], data, data_len);
sg[0].length = 16;
sg_set_page(&sg[1], virt_to_page(data));
sg[1].offset = offset_in_page(data);
sg[1].length = data_len;
if (crypto_hash_setkey(tfm_michael, key, 8)) if (crypto_hash_setkey(tfm_michael, key, 8))
return -1; return -1;

4
net/sctp/auth.c
View file

@ -727,9 +727,7 @@ void sctp_auth_calculate_hmac(const struct sctp_association *asoc,
/* set up scatter list */ /* set up scatter list */
end = skb_tail_pointer(skb); end = skb_tail_pointer(skb);
sg_init_table(&sg, 1); sg_init_table(&sg, 1);
sg_set_page(&sg, virt_to_page(auth)); sg_set_buf(&sg, auth, end - (unsigned char *)auth);
sg.offset = (unsigned long)(auth) % PAGE_SIZE;
sg.length = end - (unsigned char *)auth;
desc.tfm = asoc->ep->auth_hmacs[hmac_id]; desc.tfm = asoc->ep->auth_hmacs[hmac_id];
desc.flags = 0; desc.flags = 0;

8
net/sctp/sm_make_chunk.c
View file

@ -1514,9 +1514,7 @@ static sctp_cookie_param_t *sctp_pack_cookie(const struct sctp_endpoint *ep,
/* Sign the message. */ /* Sign the message. */
sg_init_table(&sg, 1); sg_init_table(&sg, 1);
sg_set_page(&sg, virt_to_page(&cookie->c)); sg_set_buf(&sg, &cookie->c, bodysize);
sg.offset = (unsigned long)(&cookie->c) % PAGE_SIZE;
sg.length = bodysize;
keylen = SCTP_SECRET_SIZE; keylen = SCTP_SECRET_SIZE;
key = (char *)ep->secret_key[ep->current_key]; key = (char *)ep->secret_key[ep->current_key];
desc.tfm = sctp_sk(ep->base.sk)->hmac; desc.tfm = sctp_sk(ep->base.sk)->hmac;
@ -1587,9 +1585,7 @@ struct sctp_association *sctp_unpack_cookie(
/* Check the signature. */ /* Check the signature. */
keylen = SCTP_SECRET_SIZE; keylen = SCTP_SECRET_SIZE;
sg_init_table(&sg, 1); sg_init_table(&sg, 1);
sg_set_page(&sg, virt_to_page(bear_cookie)); sg_set_buf(&sg, bear_cookie, bodysize);
sg.offset = (unsigned long)(bear_cookie) % PAGE_SIZE;
sg.length = bodysize;
key = (char *)ep->secret_key[ep->current_key]; key = (char *)ep->secret_key[ep->current_key];
desc.tfm = sctp_sk(ep->base.sk)->hmac; desc.tfm = sctp_sk(ep->base.sk)->hmac;
desc.flags = 0; desc.flags = 0;

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

@ -199,7 +199,7 @@ encryptor(struct scatterlist *sg, void *data)
} else { } else {
in_page = sg_page(sg); in_page = sg_page(sg);
} }
sg_set_page(&desc->infrags[desc->fragno], in_page); sg_assign_page(&desc->infrags[desc->fragno], in_page);
desc->fragno++; desc->fragno++;
desc->fraglen += sg->length; desc->fraglen += sg->length;
desc->pos += sg->length; desc->pos += sg->length;
@ -215,11 +215,10 @@ encryptor(struct scatterlist *sg, void *data)
if (ret) if (ret)
return ret; return ret;
if (fraglen) { if (fraglen) {
sg_set_page(&desc->outfrags[0], sg_page(sg)); sg_set_page(&desc->outfrags[0], sg_page(sg), fraglen,
desc->outfrags[0].offset = sg->offset + sg->length - fraglen; sg->offset + sg->length - fraglen);
desc->outfrags[0].length = fraglen;
desc->infrags[0] = desc->outfrags[0]; desc->infrags[0] = desc->outfrags[0];
sg_set_page(&desc->infrags[0], in_page); sg_assign_page(&desc->infrags[0], in_page);
desc->fragno = 1; desc->fragno = 1;
desc->fraglen = fraglen; desc->fraglen = fraglen;
} else { } else {
@ -287,9 +286,8 @@ decryptor(struct scatterlist *sg, void *data)
if (ret) if (ret)
return ret; return ret;
if (fraglen) { if (fraglen) {
sg_set_page(&desc->frags[0], sg_page(sg)); sg_set_page(&desc->frags[0], sg_page(sg), fraglen,
desc->frags[0].offset = sg->offset + sg->length - fraglen; sg->offset + sg->length - fraglen);
desc->frags[0].length = fraglen;
desc->fragno = 1; desc->fragno = 1;
desc->fraglen = fraglen; desc->fraglen = fraglen;
} else { } else {

4
net/sunrpc/xdr.c
View file

@ -1059,9 +1059,7 @@ xdr_process_buf(struct xdr_buf *buf, unsigned int offset, unsigned int len,
do { do {
if (thislen > page_len) if (thislen > page_len)
thislen = page_len; thislen = page_len;
sg_set_page(sg, buf->pages[i]); sg_set_page(sg, buf->pages[i], thislen, page_offset);
sg->offset = page_offset;
sg->length = thislen;
ret = actor(sg, data); ret = actor(sg, data);
if (ret) if (ret)
goto out; goto out;

9
net/xfrm/xfrm_algo.c
View file

@ -553,9 +553,7 @@ int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
if (copy > len) if (copy > len)
copy = len; copy = len;
sg_set_page(&sg, virt_to_page(skb->data + offset)); sg_set_buf(&sg, skb->data + offset, copy);
sg.offset = (unsigned long)(skb->data + offset) % PAGE_SIZE;
sg.length = copy;
err = icv_update(desc, &sg, copy); err = icv_update(desc, &sg, copy);
if (unlikely(err)) if (unlikely(err))
@ -578,9 +576,8 @@ int skb_icv_walk(const struct sk_buff *skb, struct hash_desc *desc,
if (copy > len) if (copy > len)
copy = len; copy = len;
sg_set_page(&sg, frag->page); sg_set_page(&sg, frag->page, copy,
sg.offset = frag->page_offset + offset-start; frag->page_offset + offset-start);
sg.length = copy;
err = icv_update(desc, &sg, copy); err = icv_update(desc, &sg, copy);
if (unlikely(err)) if (unlikely(err))