arch/arm/mm/dma-mapping.c

1202

phys_addr_t phys = page_to_phys(sg_page(s));

arch/sparc/kernel/ldc.c

2122

unsigned long base = page_to_pfn(sg_page(sg)) << PAGE_SHIFT;

arch/sparc/kernel/ldc.c

2185

fill_cookies(&state, page_to_pfn(sg_page(s)) << PAGE_SHIFT,

crypto/adiantum.c

404

void *virt = kmap_local_page(sg_page(src)) + src->offset;

crypto/adiantum.c

468

struct page *page = sg_page(dst);

crypto/af_alg.c

1036

err = memcpy_from_msg(page_address(sg_page(sg + i)),

crypto/af_alg.c

1039

__free_page(sg_page(sg + i));

crypto/af_alg.c

549

unpin_user_page(sg_page(&sgl->sgt.sgl[i]));

crypto/af_alg.c

699

struct page *page = sg_page(sg + i);

crypto/af_alg.c

764

if (!sg_page(sg))

crypto/af_alg.c

766

put_page(sg_page(sg));

crypto/af_alg.c

985

err = memcpy_from_msg(page_address(sg_page(sg)) +

crypto/ahash.c

223

page = sg_page(sg);

crypto/ahash.c

91

walk->pg = sg_page(walk->sg) + (walk->offset >> PAGE_SHIFT);

crypto/essiv.c

232

sg_set_page(rctx->sg, sg_page(req->src), ssize,

crypto/krb5/selftest.c

47

const void *p = kmap_local_page(sg_page(sg));

crypto/scatterwalk.c

115

struct page *src_page = sg_page(src);

crypto/scatterwalk.c

116

struct page *dst_page = sg_page(dst);

crypto/scatterwalk.c

199

sg_set_page(dst, sg_page(src), src->length - len, src->offset + len);

crypto/scompress.c

193

dpage = sg_page(req->dst);

crypto/scompress.c

215

spage = sg_page(req->src);

crypto/skcipher.c

196

diff |= (u8 *)(sg_page(walk->in.sg) + (walk->in.offset >> PAGE_SHIFT)) -

crypto/skcipher.c

197

(u8 *)(sg_page(walk->out.sg) + (walk->out.offset >> PAGE_SHIFT));

crypto/testmgr.c

703

actual_output = page_address(sg_page(sg)) + offset;

drivers/accel/amdxdna/amdxdna_iommu.c

62

if (!sg_page(sgt->sgl)) {

drivers/accel/habanalabs/common/device.c

210

page_to_phys(sg_page(sg)),

drivers/accel/habanalabs/common/device.c

253

page_to_phys(sg_page(sg)),

drivers/accel/qaic/qaic_data.c

233

sg_set_page(sg, sg_page(sgn), sg_dma_len(sg), offf);

drivers/accel/qaic/qaic_data.c

239

sg_set_page(sg, sg_page(sgn), offl - offf, offf);

drivers/accel/qaic/qaic_data.c

587

if (sg_page(sg))

drivers/accel/qaic/qaic_data.c

588

__free_pages(sg_page(sg), get_order(sg->length));

drivers/accel/qaic/qaic_data.c

620

if (sg_page(sg)) {

drivers/accel/qaic/qaic_data.c

637

ret = remap_pfn_range(vma, vma->vm_start + offset, page_to_pfn(sg_page(sg)),

drivers/ata/libata-sff.c

613

page = sg_page(qc->cursg);

drivers/ata/libata-sff.c

750

page = sg_page(sg);

drivers/block/xen-blkfront.c

1446

data.bvec_data = kmap_atomic(sg_page(sg));

drivers/block/xen-blkfront.c

1448

gnttab_foreach_grant_in_range(sg_page(sg),

drivers/block/xen-blkfront.c

836

setup.bvec_data = kmap_atomic(sg_page(sg));

drivers/block/xen-blkfront.c

839

gnttab_foreach_grant_in_range(sg_page(sg),

drivers/char/virtio_console.c

354

struct page *page = sg_page(&buf->sg[i]);

drivers/crypto/amcc/crypto4xx_core.c

807

sg_page(sg), sg->offset, len, DMA_TO_DEVICE);

drivers/crypto/amcc/crypto4xx_core.c

820

pd->src = (u32)dma_map_page(dev->core_dev->device, sg_page(src),

drivers/crypto/amcc/crypto4xx_core.c

840

sg_page(dst), dst->offset,

drivers/crypto/axis/artpec6_crypto.c

855

sg_page(walk->sg),

drivers/crypto/axis/artpec6_crypto.c

912

sg_page(walk->sg),

drivers/crypto/bcm/util.c

156

sg_set_page(to++, sg_page(sg), frag_len, offset);

drivers/crypto/caam/error.c

30

it_page = kmap_atomic(sg_page(it));

drivers/crypto/ccp/ccp-crypto-main.c

308

if (!sg_page(sg))

drivers/crypto/ccp/ccp-crypto-main.c

314

sg_set_page(sg, sg_page(sg_add), sg_add->length,

drivers/crypto/ccree/cc_buffer_mgr.c

303

sg_page(&areq_ctx->ccm_adata_sg),

drivers/crypto/ccree/cc_buffer_mgr.c

327

&sg_dma_address(areq_ctx->buff_sg), sg_page(areq_ctx->buff_sg),

drivers/crypto/hifn_795x.c

1314

spage = sg_page(src);

drivers/crypto/hifn_795x.c

1328

BUG_ON(!sg_page(t));

drivers/crypto/hifn_795x.c

1329

dpage = sg_page(t);

drivers/crypto/hifn_795x.c

1333

BUG_ON(!sg_page(dst));

drivers/crypto/hifn_795x.c

1334

dpage = sg_page(dst);

drivers/crypto/hifn_795x.c

1384

__free_page(sg_page(s));

drivers/crypto/hifn_795x.c

1611

daddr = kmap_atomic(sg_page(dst));

drivers/crypto/hifn_795x.c

1665

__func__, sg_page(t), t->length,

drivers/crypto/hifn_795x.c

1666

sg_page(dst), dst->length, nbytes);

drivers/crypto/hifn_795x.c

1674

saddr = kmap_atomic(sg_page(t));

drivers/crypto/intel/qat/qat_common/qat_comp_algs.c

371

buffer = kmap_local_page(sg_page(req->src)) + req->src->offset;

drivers/crypto/omap-crypto.c

105

if (page_zonenum(sg_page(sg)) != ZONE_DMA)

drivers/crypto/omap-crypto.c

181

srcb = kmap_atomic(sg_page(src)) + srco + src->offset;

drivers/crypto/omap-crypto.c

182

dstb = kmap_atomic(sg_page(dst)) + dsto + dst->offset;

drivers/crypto/omap-crypto.c

186

flush_dcache_page(sg_page(dst));

drivers/crypto/omap-crypto.c

41

sg_set_page(tmp, sg_page(*sg), len, (*sg)->offset);

drivers/crypto/omap-sham.c

669

sg_set_page(tmp, sg_page(sg), len, sg->offset + offset);

drivers/crypto/omap-sham.c

781

if (page_zonenum(sg_page(sg_tmp)) != ZONE_DMA) {

drivers/crypto/qce/dma.c

63

if (!sg_page(sg))

drivers/crypto/qce/dma.c

73

sg_set_page(sg, sg_page(new_sgl), new_len, new_sgl->offset);

drivers/crypto/s5p-sss.c

1088

sg_set_page(tmp, sg_page(sg), len, sg->offset + skip);

drivers/crypto/sa2ul.c

1161

sg_set_page(src, sg_page(req->src), split_size,

drivers/crypto/sa2ul.c

1209

sg_set_page(dst, sg_page(req->dst), split_size,

drivers/crypto/stm32/stm32-cryp.c

1524

sg_set_page(cur, sg_page(sg), len, offset);

drivers/dma-buf/heaps/system_heap.c

107

sg_set_page(new_sg, sg_page(sg), sg->length, sg->offset);

drivers/dma-buf/heaps/system_heap.c

252

struct page *page = sg_page(sg) + pgoff;

drivers/dma-buf/heaps/system_heap.c

349

struct page *page = sg_page(sg);

drivers/dma-buf/heaps/system_heap.c

464

ret = system_heap_set_page_decrypted(sg_page(sg));

drivers/dma-buf/heaps/system_heap.c

485

struct page *p = sg_page(sg);

drivers/gpu/drm/amd/amdgpu/amdgpu_dma_buf.c

271

if (sg_page(sgt->sgl)) {

drivers/gpu/drm/armada/armada_gem.c

444

if (sg_page(sg))

drivers/gpu/drm/armada/armada_gem.c

445

put_page(sg_page(sg));

drivers/gpu/drm/armada/armada_gem.c

467

put_page(sg_page(sg));

drivers/gpu/drm/i915/gem/i915_gem_dmabuf.c

51

sg_set_page(dst, sg_page(src), src->length, 0);

drivers/gpu/drm/i915/gem/i915_gem_internal.c

24

if (sg_page(sg))

drivers/gpu/drm/i915/gem/i915_gem_internal.c

25

__free_pages(sg_page(sg), get_order(sg->length));

drivers/gpu/drm/i915/gem/i915_gem_pages.c

306

if (n_pages == 1 && !PageHighMem(sg_page(obj->mm.pages->sgl)))

drivers/gpu/drm/i915/gem/i915_gem_pages.c

307

return page_address(sg_page(obj->mm.pages->sgl));

drivers/gpu/drm/i915/gem/i915_gem_pages.c

770

return sg_page(sg) + offset;

drivers/gpu/drm/i915/gem/i915_gem_phys.c

29

return (void *)sg_page(sg);

drivers/gpu/drm/i915/gem/selftests/huge_gem_object.c

65

sg_set_page(sg, sg_page(src), PAGE_SIZE, 0);

drivers/gpu/drm/i915/gem/selftests/huge_pages.c

70

if (sg_page(sg))

drivers/gpu/drm/i915/gem/selftests/huge_pages.c

71

__free_pages(sg_page(sg), get_order(sg->length));

drivers/gpu/drm/i915/gt/intel_gtt.c

334

return sg_page(p->mm.pages->sgl);

drivers/gpu/drm/i915/gt/intel_ring_submission.c

71

return sg_page(obj->mm.pages->sgl);

drivers/gpu/drm/i915/gt/selftest_timeline.c

32

return sg_page(obj->mm.pages->sgl);

drivers/gpu/drm/i915/i915_gpu_error.c

1049

memcpy(buf, page_address(sg_page(sg)) + start, len);

drivers/gpu/drm/i915/i915_scatterlist.c

29

sg_set_page(new_sg, sg_page(sg), sg->length, 0);

drivers/gpu/drm/i915/i915_scatterlist.h

42

s.pfn = page_to_pfn(sg_page(s.sgp));

drivers/gpu/drm/i915/selftests/i915_gem_gtt.c

88

sg_dma_address(sg) = page_to_phys(sg_page(sg));

drivers/gpu/drm/i915/selftests/scatterlist.c

256

GEM_BUG_ON(page_to_pfn(sg_page(sg)) != pfn);

drivers/gpu/drm/i915/selftests/scatterlist.c

52

struct page *page = sg_page(sg);

drivers/gpu/drm/nouveau/nvkm/subdev/gsp/rm/r535/gsp.c

1578

struct page *page = sg_page(sgl);

drivers/gpu/drm/renesas/rcar-du/rcar_du_vsp.c

289

sg_set_page(dst, sg_page(src), src->length,

drivers/gpu/drm/xe/xe_dma_buf.c

157

if (sg_page(sgt->sgl)) {

drivers/hv/hv_balloon.c

1615

sg_page(sg)) >> HV_LARGE_REPORTING_ORDER;

drivers/hv/hv_balloon.c

1620

range->page.basepfn = page_to_hvpfn(sg_page(sg));

drivers/hwtracing/intel_th/msu.c

1087

return sg_page(sg);

drivers/infiniband/core/umem.c

61

unpin_user_page_range_dirty_lock(sg_page(sg),

drivers/infiniband/hw/irdma/verbs.c

2782

iwpbl->qp_mr.sq_page = sg_page(region->sgt_append.sgt.sgl);

drivers/infiniband/hw/mthca/mthca_memfree.c

309

page = sg_page(&chunk->mem[i]);

drivers/infiniband/hw/mthca/mthca_memfree.c

495

unpin_user_page(sg_page(&db_tab->page[i].mem));

drivers/infiniband/hw/mthca/mthca_memfree.c

562

unpin_user_page(sg_page(&db_tab->page[i].mem));

drivers/infiniband/hw/mthca/mthca_memfree.c

73

__free_pages(sg_page(&chunk->mem[i]),

drivers/infiniband/hw/mthca/mthca_memfree.c

83

lowmem_page_address(sg_page(&chunk->mem[i])),

drivers/infiniband/hw/usnic/usnic_uiom.c

75

page = sg_page(sg);

drivers/iommu/dma-iommu.c

1450

switch (pci_p2pdma_state(&p2pdma_state, dev, sg_page(s))) {

drivers/iommu/dma-iommu.c

993

arch_dma_prep_coherent(sg_page(sg), sg->length);

drivers/md/dm-crypt.c

554

src = kmap_local_page(sg_page(sg));

drivers/md/dm-crypt.c

572

dst = kmap_local_page(sg_page(sg));

drivers/md/dm-crypt.c

672

src = kmap_local_page(sg_page(sg));

drivers/md/dm-crypt.c

697

dst = kmap_local_page(sg_page(sg));

drivers/md/dm-crypt.c

952

data = kmap_local_page(sg_page(sg));

drivers/md/dm-crypt.c

958

data2 = kmap_local_page(sg_page(sg2));

drivers/media/common/videobuf2/videobuf2-dma-contig.c

345

sg_set_page(wr, sg_page(rd), rd->length, rd->offset);

drivers/media/common/videobuf2/videobuf2-dma-sg.c

396

sg_set_page(wr, sg_page(rd), rd->length, rd->offset);

drivers/memstick/core/ms_block.c

52

sg_set_page(sg_to, sg_page(sg_from),

drivers/memstick/core/ms_block.c

70

sg_set_page(sg_to, sg_page(sg_from),

drivers/memstick/core/ms_block.c

81

sg_set_page(sg_to, sg_page(sg_from), len, sg_from->offset);

drivers/memstick/core/mspro_block.c

563

sg_page(&(msb->req_sg[msb->current_seg])) + (t_offset >> PAGE_SHIFT),

drivers/memstick/host/jmb38x_ms.c

320

pg = sg_page(&host->req->sg) + (off >> PAGE_SHIFT);

drivers/memstick/host/tifm_ms.c

204

pg = sg_page(&host->req->sg) + (off >> PAGE_SHIFT);

drivers/mmc/host/atmel-mci.c

1962

flush_dcache_page(sg_page(sg));

drivers/mmc/host/atmel-mci.c

1976

flush_dcache_page(sg_page(sg));

drivers/mmc/host/au1xmmc.c

392

sg_ptr = kmap_local_page(sg_page(sg)) + sg->offset + host->pio.offset;

drivers/mmc/host/au1xmmc.c

450

sg_ptr = kmap_local_page(sg_page(sg)) + sg->offset + host->pio.offset;

drivers/mmc/host/bcm2835.c

484

host->drain_page = sg_page(sg);

drivers/mmc/host/mmc_spi.c

802

kmap_addr = kmap(sg_page(sg));

drivers/mmc/host/mmc_spi.c

832

flush_dcache_page(sg_page(sg));

drivers/mmc/host/mmc_spi.c

833

kunmap(sg_page(sg));

drivers/mmc/host/renesas_sdhi_sys_dmac.c

259

void *sg_vaddr = kmap_local_page(sg_page(sg));

drivers/mmc/host/sdhci.c

710

return kmap_local_page(sg_page(sg)) + sg->offset;

drivers/mmc/host/sdricoh_cs.c

305

page = sg_page(data->sg);

drivers/mmc/host/tifm_sd.c

194

pg = sg_page(&sg[host->sg_pos]) + (off >> PAGE_SHIFT);

drivers/mmc/host/tifm_sd.c

241

pg = sg_page(&sg[host->sg_pos]) + (off >> PAGE_SHIFT);

drivers/mmc/host/tifm_sd.c

248

tifm_sd_copy_page(sg_page(&host->bounce_buf),

drivers/mmc/host/tifm_sd.c

252

tifm_sd_copy_page(pg, p_off, sg_page(&host->bounce_buf),

drivers/mmc/host/tmio_mmc_core.c

458

sg_virt = kmap_local_page(sg_page(host->sg_ptr));

drivers/mmc/host/tmio_mmc_core.c

482

void *sg_virt = kmap_local_page(sg_page(host->sg_orig));

drivers/mmc/host/usdhi6rol0.c

368

host->pg.page = sg_page(sg);

drivers/mmc/host/usdhi6rol0.c

506

host->pg.page = sg_page(host->sg) + host->page_idx;

drivers/mmc/host/wbsd.c

270

return kmap_local_page(sg_page(host->cur_sg)) + host->cur_sg->offset;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4009

page = sg_page(iter);

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

4105

newpage = sg_page(iter);

drivers/net/ethernet/mellanox/mlx4/icm.c

354

page = sg_page(&chunk->sg[i]);

drivers/net/ethernet/mellanox/mlx4/icm.c

64

__free_pages(sg_page(&chunk->sg[i]),

drivers/net/wireless/mediatek/mt76/usb.c

542

sg_page(&urb->sg[nsgs]),

drivers/nvme/target/io-cmd-bdev.c

287

if (is_pci_p2pdma_page(sg_page(req->sg)))

drivers/nvme/target/io-cmd-bdev.c

310

while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)

drivers/nvme/target/io-cmd-file.c

142

bvec_set_page(&req->f.bvec[bv_cnt], sg_page(sg), sg->length,

drivers/nvme/target/passthru.c

282

if (bio_add_page(bio, sg_page(sg), sg->length, sg->offset) <

drivers/nvme/target/rdma.c

268

if (sg_page(sg))

drivers/nvme/target/rdma.c

269

__free_page(sg_page(sg));

drivers/nvme/target/rdma.c

310

if (sg_page(sg))

drivers/nvme/target/rdma.c

311

__free_page(sg_page(sg));

drivers/nvme/target/tcp.c

380

bvec_set_page(iov, sg_page(sg), iov_len,

drivers/nvme/target/tcp.c

664

struct page *page = sg_page(cmd->cur_sg);

drivers/nvme/target/zns.c

585

if (bio_add_page(bio, sg_page(sg), len, sg->offset) != len) {

drivers/scsi/arcmsr/arcmsr_hba.c

3009

buffer = kmap_atomic(sg_page(sg)) + sg->offset;

drivers/scsi/arcmsr/arcmsr_hba.c

3295

buffer = kmap_atomic(sg_page(sg)) + sg->offset;

drivers/scsi/csiostor/csio_scsi.c

1532

sg_addr = kmap_atomic(sg_page(sg) + (sg_off >> PAGE_SHIFT));

drivers/scsi/cxgbi/libcxgbi.c

1767

struct page *page = sg_page(sg);

drivers/scsi/cxgbi/libcxgbi.c

1783

page = sg_page(sg);

drivers/scsi/cxgbi/libcxgbi.c

1831

if (page_count(sg_page(sg)) < 1) {

drivers/scsi/hisi_sas/hisi_sas_v1_hw.c

1280

void *to = page_address(sg_page(sg_resp));

drivers/scsi/hisi_sas/hisi_sas_v2_hw.c

2435

void *to = page_address(sg_page(sg_resp));

drivers/scsi/hisi_sas/hisi_sas_v3_hw.c

2439

void *to = page_address(sg_page(sg_resp));

drivers/scsi/ipr.c

3836

struct page *page = sg_page(sg);

drivers/scsi/ipr.c

3849

struct page *page = sg_page(sg);

drivers/scsi/ips.c

1487

buffer = kmap_local_page(sg_page(sg)) + sg->offset;

drivers/scsi/isci/request.c

1420

struct page *page = sg_page(sg);

drivers/scsi/isci/request.c

1771

kaddr = kmap_atomic(sg_page(sg));

drivers/scsi/isci/request.c

2917

kaddr = kmap_atomic(sg_page(sg));

drivers/scsi/isci/request.c

3186

kaddr = kmap_atomic(sg_page(sg));

drivers/scsi/iscsi_tcp.c

322

bvec_set_page(&bv, sg_page(sg), copy, offset);

drivers/scsi/libfc/fc_fcp.c

677

page = sg_page(sg) + (off >> PAGE_SHIFT);

drivers/scsi/libfc/fc_libfc.c

132

page_addr = kmap_atomic(sg_page(sg) + (off >> PAGE_SHIFT));

drivers/scsi/libiscsi_tcp.c

131

if (!recv && sendpage_ok(sg_page(sg)))

drivers/scsi/libiscsi_tcp.c

136

segment->sg_mapped = kmap_atomic(sg_page(sg));

drivers/scsi/libiscsi_tcp.c

140

segment->sg_mapped = kmap(sg_page(sg));

drivers/scsi/libiscsi_tcp.c

152

kunmap(sg_page(segment->sg));

drivers/scsi/libiscsi_tcp.c

207

data = kmap_local_page(sg_page(segment->sg));

drivers/scsi/megaraid.c

1554

if( sg_page(sgl) ) {

drivers/scsi/megaraid.c

666

buf = kmap_atomic(sg_page(sg)) + sg->offset;

drivers/scsi/megaraid/megaraid_mbox.c

1547

if (sg_page(sgl)) {

drivers/scsi/megaraid/megaraid_mbox.c

2262

if (sg_page(sgl)) {

drivers/scsi/mvsas/mv_sas.c

1602

to = kmap_atomic(sg_page(sg_resp));

drivers/scsi/pm8001/pm80xx_hwi.c

2958

to = kmap_atomic(sg_page(sg_resp));

drivers/scsi/pm8001/pm80xx_hwi.c

4225

to = kmap_atomic(sg_page(smp_req));

drivers/scsi/qla2xxx/qla_isr.c

3123

spt = page_address(sg_page(sg)) + sg->offset;

drivers/scsi/qla2xxx/qla_target.c

5671

i, sg, sg_page(sg), sg->length, sg->offset);

drivers/scsi/qla2xxx/qla_target.c

5720

sg_set_page(&sg_srr[0], sg_page(sg_srr_start),

drivers/scsi/qla2xxx/qla_target.c

5731

sg_set_page(&sg_srr[1], sg_page(sg), sg->length,

drivers/scsi/scsi_lib.c

3242

page = sg_page(sg) + (*offset >> PAGE_SHIFT);

drivers/scsi/xen-scsifront.c

541

page = sg_page(sg);

drivers/staging/media/ipu3/ipu3-mmu.c

309

phys_addr_t phys = page_to_phys(sg_page(s)) + s->offset;

drivers/target/iscsi/cxgbit/cxgbit_ddp.c

269

put_page(sg_page(&ccmd->sg));

drivers/target/iscsi/cxgbit/cxgbit_target.c

361

page = sg_page(sg);

drivers/target/iscsi/iscsi_target.c

1422

virt = kmap_local_page(sg_page(sg)) + sg->offset + page_off;

drivers/target/iscsi/iscsi_target.c

914

iov[i].iov_base = kmap(sg_page(sg)) + sg->offset + page_off;

drivers/target/iscsi/iscsi_target.c

946

kunmap(sg_page(&sg[i]));

drivers/target/iscsi/iscsi_target_util.c

1140

bvec_set_page(&bvec, sg_page(sg), sub_len, sg->offset + offset);

drivers/target/target_core_file.c

284

bvec_set_page(&aio_cmd->bvecs[i], sg_page(sg), sg->length,

drivers/target/target_core_file.c

330

bvec_set_page(&bvec[i], sg_page(sg), sg->length, sg->offset);

drivers/target/target_core_file.c

463

bvec_set_page(&bvec[i], sg_page(&cmd->t_data_sg[0]),

drivers/target/target_core_iblock.c

463

buf = kmap(sg_page(sg)) + sg->offset;

drivers/target/target_core_iblock.c

471

kunmap(sg_page(sg));

drivers/target/target_core_iblock.c

540

while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)

drivers/target/target_core_iblock.c

816

while (bio_add_page(bio, sg_page(sg), sg->length, sg->offset)

drivers/target/target_core_pscsi.c

841

page = sg_page(sg);

drivers/target/target_core_rd.c

75

pg = sg_page(&sg[j]);

drivers/target/target_core_sbc.c

1225

paddr = kmap_atomic(sg_page(psg)) + psg->offset;

drivers/target/target_core_sbc.c

1226

daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;

drivers/target/target_core_sbc.c

1241

daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;

drivers/target/target_core_sbc.c

1254

daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;

drivers/target/target_core_sbc.c

1339

paddr = kmap_atomic(sg_page(psg)) + psg->offset;

drivers/target/target_core_sbc.c

1343

addr = kmap_atomic(sg_page(sg)) + sg->offset + offset;

drivers/target/target_core_sbc.c

1382

paddr = kmap_atomic(sg_page(psg)) + psg->offset;

drivers/target/target_core_sbc.c

1383

daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;

drivers/target/target_core_sbc.c

1399

daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;

drivers/target/target_core_sbc.c

1423

daddr = kmap_atomic(sg_page(dsg)) + dsg->offset;

drivers/target/target_core_sbc.c

409

unsigned char *addr = kmap_atomic(sg_page(sg));

drivers/target/target_core_transport.c

1648

buf = kmap_local_page(sg_page(sgl));

drivers/target/target_core_transport.c

2778

return kmap(sg_page(sg)) + sg->offset;

drivers/target/target_core_transport.c

2787

pages[i] = sg_page(sg);

drivers/target/target_core_transport.c

2804

kunmap(sg_page(cmd->t_data_sg));

drivers/target/tcm_fc/tfc_cmd.c

51

sg_page(sg), sg->length, sg->offset);

drivers/target/tcm_fc/tfc_io.c

102

page = sg_page(sg);

drivers/target/tcm_fc/tfc_io.c

279

page = sg_page(sg);

drivers/target/tcm_fc/tfc_io.c

287

page = sg_page(sg);

drivers/target/tcm_fc/tfc_io.c

84

page = sg_page(sg);

drivers/tee/tee_heap.c

82

sg_set_page(dst_sg, sg_page(src_sg), src_sg->length,

drivers/usb/core/devio.c

424

if (sg_page(&as->urb->sg[i]))

drivers/usb/core/hcd.c

1475

sg_page(sg),

drivers/usb/core/message.c

634

if (!PageHighMem(sg_page(sg)))

drivers/usb/gadget/function/uvc_video.c

170

sg_set_page(iter, sg_page(buf->sg), part, buf->offset);

drivers/usb/host/xhci-sideband.c

53

pages[i] = sg_page(sgt->sgl);

drivers/usb/misc/usbtest.c

528

if (!sg_page(&sg[i]))

drivers/usb/mon/mon_bin.c

434

if (length == 0 || PageHighMem(sg_page(sg)))

drivers/usb/mon/mon_text.c

170

if (PageHighMem(sg_page(sg)))

drivers/vfio/pci/pds/lm.c

154

return sg_page(sg) + (offset - cur_offset) / PAGE_SIZE;

drivers/vfio/pci/virtio/migrate.c

56

return sg_page(sg) + (offset - cur_offset) / PAGE_SIZE;

drivers/vhost/scsi.c

430

page = sg_page(sg);

drivers/vhost/scsi.c

445

page = sg_page(sg);

drivers/vhost/scsi.c

665

page = sg_page(sg);

drivers/vhost/scsi.c

782

page = sg_page(curr);

drivers/vhost/scsi.c

936

page = sg_page(sg);

drivers/virtio/virtio_ring.c

523

*addr = virtqueue_map_page_attrs(&vq->vq, sg_page(sg),

include/crypto/scatterwalk.h

102

struct page *base_page = sg_page(walk->sg);

include/crypto/scatterwalk.h

219

__scatterwalk_flush_dcache_pages(sg_page(walk->sg),

include/crypto/scatterwalk.h

94

sg_set_page(sg_out, sg_page(walk->sg),

include/linux/devcoredump.h

35

page = sg_page(iter);

include/linux/scatterlist.h

412

return page_to_phys(sg_page(sg)) + sg->offset;

include/linux/scatterlist.h

427

return page_address(sg_page(sg)) + sg->offset;

include/linux/scatterlist.h

606

return sg_page(piter->sg) + piter->sg_pgoffset;

include/linux/skmsg.h

241

return sg_page(sk_msg_elem(msg, which));

kernel/dma/debug.c

1370

if (!PageHighMem(sg_page(s)))

kernel/dma/direct.c

472

switch (pci_p2pdma_state(&p2pdma_state, dev, sg_page(sg))) {

kernel/dma/mapping.c

827

__dma_free_pages(dev, size, sg_page(sgt->sgl), sgt->sgl->dma_address,

kernel/dma/mapping.c

853

return page_address(sg_page(sgt->sgl));

kernel/dma/mapping.c

869

return dma_mmap_pages(dev, vma, size, sg_page(sgt->sgl));

lib/scatterlist.c

1158

unpin_user_page(sg_page(&sgtable->sgl[--sgtable->nents]));

lib/scatterlist.c

696

page = sg_page(sg);

lib/tests/kunit_iov_iter.c

1042

unpin_user_page(sg_page(&sgt->sgl[i]));

mm/page_reporting.c

115

struct page *page = sg_page(sg);

net/core/filter.c

2771

put_page(sg_page(sge));

net/core/filter.c

2910

put_page(sg_page(psge));

net/core/filter.c

2981

get_page(sg_page(&rsge));

net/core/filter.c

3008

put_page(sg_page(sge));

net/core/filter.c

3109

get_page(sg_page(sge));

net/core/filter.c

3111

sg_page(sge),

net/core/filter.c

3124

orig = sg_page(sge);

net/core/skmsg.c

114

(sg_page(sge) == sg_page(sgd)) &&

net/core/skmsg.c

120

sk_msg_page_add(dst, sg_page(sge), sge_len, sge_off);

net/core/skmsg.c

187

put_page(sg_page(sge));

net/core/skmsg.c

440

page = sg_page(sge);

net/core/skmsg.c

56

sg_page(sge) == pfrag->page &&

net/ipv4/esp4.c

120

skb_page_unref(page_to_netmem(sg_page(sg)),

net/ipv4/tcp_bpf.c

109

page = sg_page(sge);

net/ipv6/esp6.c

137

skb_page_unref(page_to_netmem(sg_page(sg)),

net/rds/ib_rdma.c

250

struct page *page = sg_page(&ibmr->sg[i]);

net/rds/ib_recv.c

196

rdsdebug("frag %p page %p\n", frag, sg_page(&frag->f_sg));

net/rds/ib_recv.c

416

recv->r_ibinc, sg_page(&recv->r_frag->f_sg),

net/rds/ib_recv.c

560

ret = copy_page_to_iter(sg_page(&frag->f_sg),

net/rds/ib_recv.c

817

addr = kmap_atomic(sg_page(&frag->f_sg));

net/rds/message.c

168

__free_page(sg_page(&rm->data.op_sg[i]));

net/rds/message.c

170

put_page(sg_page(&rm->data.op_sg[i]));

net/rds/message.c

450

put_page(sg_page(&rm->data.op_sg[i]));

net/rds/message.c

488

if (!sg_page(sg)) {

net/rds/message.c

501

nbytes = copy_page_from_iter(sg_page(sg), sg->offset + sg_off,

net/rds/message.c

538

ret = copy_page_to_iter(sg_page(sg), sg->offset + vec_off,

net/rds/page.c

106

get_page(sg_page(scat));

net/rds/page.c

150

ret ? NULL : sg_page(scat), ret ? 0 : scat->offset,

net/rds/rdma.c

494

struct page *page = sg_page(&ro->op_sg[i]);

net/rds/rdma.c

512

struct page *page = sg_page(ao->op_sg);

net/rds/tcp_send.c

120

bvec_set_page(&bvec, sg_page(&rm->data.op_sg[sg]),

net/rds/tcp_send.c

126

rdsdebug("tcp sendpage %p:%u:%u ret %d\n", (void *)sg_page(&rm->data.op_sg[sg]),

net/rxrpc/output.c

950

bvec_set_page(&bvec[i], sg_page(&sg[i]), sg[i].length, sg[i].offset);

net/tls/tls_device_fallback.c

401

put_page(sg_page(&sg_in[--resync_sgs]));

net/tls/tls_main.c

190

p = sg_page(sg);

net/tls/tls_main.c

286

put_page(sg_page(sg));

net/tls/tls_sw.c

1417

put_page(sg_page(&sgout[pages]));

net/tls/tls_sw.c

233

put_page(sg_page(sg));

net/tls/tls_sw.c

682

page_address(sg_page(&msg_en->sg.data[i])) +

net/xfrm/espintcp.c

224

bvec_set_page(&bvec, sg_page(sg), sg->length, sg->offset);

net/xfrm/xfrm_ipcomp.c

79

page = sg_page(dsg);

net/xfrm/xfrm_ipcomp.c

92

for (; dsg && sg_page(dsg); dsg = sg_next(dsg))

net/xfrm/xfrm_ipcomp.c

93

__free_page(sg_page(dsg));

samples/kfifo/dma-example.c

108

i, sg_page(&sg[i]), sg[i].offset, sg[i].length);

samples/kfifo/dma-example.c

79

i, sg_page(&sg[i]), sg[i].offset, sg[i].length);

sound/usb/qcom/qc_audio_offload.c

1159

pg = sg_page(sgt->sgl);

sound/usb/qcom/qc_audio_offload.c

1229

pg = sg_page(sgt->sgl);

sound/usb/qcom/qc_audio_offload.c

635

pa_sg = page_to_phys(sg_page(sg));

tools/virtio/linux/scatterlist.h

158

return page_to_phys(sg_page(sg)) + sg->offset;