arch/arm/kernel/atags_compat.c

122

tag->u.core.pagesize = params->u1.s.page_size;

arch/arm/kernel/atags_compat.c

42

unsigned long page_size; /* 0 */

arch/arm/kernel/atags_compat.c

96

if (params->u1.s.page_size != PAGE_SIZE) {

arch/arm/mach-rpc/include/mach/uncompress.h

116

unsigned int nr_pages = 0, page_size = PAGE_SIZE;

arch/arm/mach-rpc/include/mach/uncompress.h

129

page_size = PAGE_SIZE;

arch/arm/mach-rpc/include/mach/uncompress.h

135

page_size = params->page_size;

arch/arm/mach-rpc/include/mach/uncompress.h

179

if (nr_pages * page_size < 4096*1024) error("<4M of mem\n");

arch/arm/mach-rpc/include/mach/uncompress.h

19

unsigned long page_size;

arch/powerpc/include/asm/book3s/64/hash.h

289

unsigned long page_size,

arch/powerpc/include/asm/book3s/64/hash.h

292

unsigned long page_size);

arch/powerpc/include/asm/book3s/64/mmu-hash.h

500

extern void pseries_add_gpage(u64 addr, u64 page_size, unsigned long number_of_pages);

arch/powerpc/include/asm/book3s/64/pgtable.h

1005

unsigned long page_size = 1 << mmu_psize_defs[mmu_io_psize].shift;

arch/powerpc/include/asm/book3s/64/pgtable.h

1006

WARN((page_size != PAGE_SIZE), "I/O page size != PAGE_SIZE");

arch/powerpc/include/asm/book3s/64/pgtable.h

1016

unsigned long page_size,

arch/powerpc/include/asm/book3s/64/pgtable.h

1020

return radix__vmemmap_create_mapping(start, page_size, phys);

arch/powerpc/include/asm/book3s/64/pgtable.h

1021

return hash__vmemmap_create_mapping(start, page_size, phys);

arch/powerpc/include/asm/book3s/64/pgtable.h

1026

unsigned long page_size)

arch/powerpc/include/asm/book3s/64/pgtable.h

1029

return radix__vmemmap_remove_mapping(start, page_size);

arch/powerpc/include/asm/book3s/64/pgtable.h

1030

return hash__vmemmap_remove_mapping(start, page_size);

arch/powerpc/include/asm/book3s/64/radix.h

321

unsigned long page_size,

arch/powerpc/include/asm/book3s/64/radix.h

328

unsigned long page_size);

arch/powerpc/include/asm/book3s/64/tlbflush-radix.h

37

unsigned long page_size);

arch/powerpc/include/asm/book3s/64/tlbflush-radix.h

45

unsigned long page_size)

arch/powerpc/include/asm/kvm_host.h

385

u8 page_size; /* MMU_PAGE_xxx */

arch/powerpc/include/asm/nohash/64/pgtable.h

202

unsigned long page_size,

arch/powerpc/include/asm/nohash/64/pgtable.h

205

unsigned long page_size);

arch/powerpc/include/asm/pgtable.h

191

unsigned long page_size);

arch/powerpc/include/asm/pnv-ocxl.h

84

unsigned long page_size);

arch/powerpc/include/asm/ps3.h

122

struct ps3_dma_region *r, enum ps3_dma_page_size page_size,

arch/powerpc/include/asm/ps3.h

151

enum ps3_mmio_page_size page_size;

arch/powerpc/include/asm/ps3.h

170

enum ps3_mmio_page_size page_size);

arch/powerpc/include/asm/ps3.h

86

enum ps3_dma_page_size page_size;

arch/powerpc/kvm/book3s_32_mmu.c

298

pte->page_size = MMU_PAGE_4K;

arch/powerpc/kvm/book3s_64_mmu.c

220

gpte->page_size = MMU_PAGE_4K;

arch/powerpc/kvm/book3s_64_mmu.c

298

gpte->page_size = pgsize;

arch/powerpc/kvm/book3s_64_mmu_radix.c

211

gpte->page_size = ps;

arch/powerpc/kvm/book3s_64_mmu_radix.c

431

unsigned long page_size = PAGE_SIZE;

arch/powerpc/kvm/book3s_64_mmu_radix.c

447

page_size = 1ul << shift;

arch/powerpc/kvm/book3s_64_mmu_radix.c

454

gpa &= ~(page_size - 1);

arch/powerpc/kvm/book3s_64_mmu_radix.c

456

kvmhv_remove_nest_rmap_range(kvm, memslot, gpa, hpa, page_size);

arch/powerpc/kvm/book3s_64_mmu_radix.c

459

kvmppc_update_dirty_map(memslot, gfn, page_size);

arch/powerpc/kvm/book3s_hv_nested.c

1317

unsigned long psize, ap, page_size;

arch/powerpc/kvm/book3s_hv_nested.c

1332

page_size = 1UL << def->shift;

arch/powerpc/kvm/book3s_hv_nested.c

1338

addr += page_size;

arch/powerpc/kvm/book3s_pr.c

707

pte.page_size = MMU_PAGE_64K;

arch/powerpc/kvm/book3s_xive_native.c

574

unsigned long page_size;

arch/powerpc/kvm/book3s_xive_native.c

649

page_size = kvm_host_page_size(vcpu, gfn);

arch/powerpc/kvm/book3s_xive_native.c

650

if (1ull << kvm_eq.qshift > page_size) {

arch/powerpc/kvm/book3s_xive_native.c

652

pr_warn("Incompatible host page size %lx!\n", page_size);

arch/powerpc/mm/book3s64/hash_pgtable.c

108

unsigned long page_size,

arch/powerpc/mm/book3s64/hash_pgtable.c

113

if ((start + page_size) >= H_VMEMMAP_END) {

arch/powerpc/mm/book3s64/hash_pgtable.c

118

rc = htab_bolt_mapping(start, start + page_size, phys,

arch/powerpc/mm/book3s64/hash_pgtable.c

122

int rc2 = htab_remove_mapping(start, start + page_size,

arch/powerpc/mm/book3s64/hash_pgtable.c

132

unsigned long page_size)

arch/powerpc/mm/book3s64/hash_pgtable.c

134

int rc = htab_remove_mapping(start, start + page_size,

arch/powerpc/mm/book3s64/radix_pgtable.c

1415

void __meminit radix__vmemmap_remove_mapping(unsigned long start, unsigned long page_size)

arch/powerpc/mm/book3s64/radix_pgtable.c

1417

remove_pagetable(start, start + page_size, true, NULL);

arch/powerpc/mm/book3s64/radix_pgtable.c

962

unsigned long page_size,

arch/powerpc/mm/book3s64/radix_pgtable.c

969

if ((start + page_size) >= RADIX_VMEMMAP_END) {

arch/powerpc/mm/book3s64/radix_pgtable.c

974

ret = __map_kernel_page_nid(start, phys, PAGE_KERNEL, page_size, nid);

arch/powerpc/mm/book3s64/radix_tlb.c

1017

unsigned long page_size = 1UL << page_shift;

arch/powerpc/mm/book3s64/radix_tlb.c

1084

__tlbiel_va_range(start, end, pid, page_size, mmu_virtual_psize);

arch/powerpc/mm/book3s64/radix_tlb.c

1093

__tlbie_va_range(start, end, pid, page_size, mmu_virtual_psize);

arch/powerpc/mm/book3s64/radix_tlb.c

1100

start, end, pid, page_size, mmu_virtual_psize, flush_pwc);

arch/powerpc/mm/book3s64/radix_tlb.c

1124

static int radix_get_mmu_psize(int page_size)

arch/powerpc/mm/book3s64/radix_tlb.c

1128

if (page_size == (1UL << mmu_psize_defs[mmu_virtual_psize].shift))

arch/powerpc/mm/book3s64/radix_tlb.c

1130

else if (page_size == (1UL << mmu_psize_defs[MMU_PAGE_2M].shift))

arch/powerpc/mm/book3s64/radix_tlb.c

1132

else if (page_size == (1UL << mmu_psize_defs[MMU_PAGE_1G].shift))

arch/powerpc/mm/book3s64/radix_tlb.c

1144

unsigned long page_size)

arch/powerpc/mm/book3s64/radix_tlb.c

1146

int psize = radix_get_mmu_psize(page_size);

arch/powerpc/mm/book3s64/radix_tlb.c

1182

int page_size = tlb->page_size;

arch/powerpc/mm/book3s64/radix_tlb.c

1216

} else if ( (psize = radix_get_mmu_psize(page_size)) == -1) {

arch/powerpc/mm/book3s64/radix_tlb.c

1235

unsigned long page_size = 1UL << page_shift;

arch/powerpc/mm/book3s64/radix_tlb.c

1285

_tlbiel_va_range(start, end, pid, page_size, psize, also_pwc);

arch/powerpc/mm/book3s64/radix_tlb.c

1287

_tlbie_va_range(start, end, pid, page_size, psize, also_pwc);

arch/powerpc/mm/book3s64/radix_tlb.c

1290

start, end, pid, page_size, psize, also_pwc);

arch/powerpc/mm/book3s64/radix_tlb.c

1492

unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

1498

for (addr = start; addr < end; addr += page_size)

arch/powerpc/mm/book3s64/radix_tlb.c

1501

fixup_tlbie_va_range_pid_lpid(addr - page_size, pid, lpid, ap);

arch/powerpc/mm/book3s64/radix_tlb.c

1506

unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

1512

__tlbie_va_range_pid_lpid(start, end, pid, lpid, page_size, psize);

arch/powerpc/mm/book3s64/radix_tlb.c

430

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

436

for (addr = start; addr < end; addr += page_size)

arch/powerpc/mm/book3s64/radix_tlb.c

451

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

457

__tlbiel_va_range(start, end, pid, page_size, psize);

arch/powerpc/mm/book3s64/radix_tlb.c

462

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

468

for (addr = start; addr < end; addr += page_size)

arch/powerpc/mm/book3s64/radix_tlb.c

471

fixup_tlbie_va_range(addr - page_size, pid, ap);

arch/powerpc/mm/book3s64/radix_tlb.c

519

unsigned long page_size;

arch/powerpc/mm/book3s64/radix_tlb.c

528

_tlbiel_va_range(t->start, t->end, t->pid, t->page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

544

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

550

__tlbie_va_range(start, end, pid, page_size, psize);

arch/powerpc/mm/book3s64/radix_tlb.c

556

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

561

.pid = pid, .page_size = page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

566

_tlbie_va_range(start, end, pid, page_size, psize, also_pwc);

arch/powerpc/mm/book3s64/slice.c

435

unsigned long page_size = 1UL << pshift;

arch/powerpc/mm/book3s64/slice.c

446

if (len & (page_size - 1))

arch/powerpc/mm/book3s64/slice.c

449

if (addr & (page_size - 1))

arch/powerpc/mm/book3s64/slice.c

477

addr = ALIGN(addr, page_size);

arch/powerpc/mm/hugetlbpage.c

103

addr += page_size;

arch/powerpc/mm/hugetlbpage.c

95

void __init pseries_add_gpage(u64 addr, u64 page_size, unsigned long number_of_pages)

arch/powerpc/mm/init_64.c

188

unsigned long page_size)

arch/powerpc/mm/init_64.c

190

unsigned long nr_pfn = page_size / sizeof(struct page);

arch/powerpc/mm/init_64.c

206

unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;

arch/powerpc/mm/init_64.c

209

start = ALIGN_DOWN(start, page_size);

arch/powerpc/mm/init_64.c

213

for (; start < end; start += page_size) {

arch/powerpc/mm/init_64.c

223

if (vmemmap_populated(start, page_size))

arch/powerpc/mm/init_64.c

231

if (altmap && !altmap_cross_boundary(altmap, start, page_size)) {

arch/powerpc/mm/init_64.c

232

p = vmemmap_alloc_block_buf(page_size, node, altmap);

arch/powerpc/mm/init_64.c

239

p = vmemmap_alloc_block_buf(page_size, node, NULL);

arch/powerpc/mm/init_64.c

252

int nr_pfns = page_size >> PAGE_SHIFT;

arch/powerpc/mm/init_64.c

253

unsigned long page_order = get_order(page_size);

arch/powerpc/mm/init_64.c

263

start, start + page_size, p);

arch/powerpc/mm/init_64.c

265

rc = vmemmap_create_mapping(start, page_size, __pa(p));

arch/powerpc/mm/init_64.c

322

unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;

arch/powerpc/mm/init_64.c

323

unsigned long page_order = get_order(page_size);

arch/powerpc/mm/init_64.c

327

start = ALIGN_DOWN(start, page_size);

arch/powerpc/mm/init_64.c

335

for (; start < end; start += page_size) {

arch/powerpc/mm/init_64.c

345

if (vmemmap_populated(start, page_size))

arch/powerpc/mm/init_64.c

360

if (page_size < PAGE_SIZE) {

arch/powerpc/mm/init_64.c

374

vmemmap_remove_mapping(start, page_size);

arch/powerpc/mm/nohash/book3e_pgtable.c

24

unsigned long page_size,

arch/powerpc/mm/nohash/book3e_pgtable.c

41

for (i = 0; i < page_size; i += PAGE_SIZE)

arch/powerpc/mm/nohash/book3e_pgtable.c

49

unsigned long page_size)

arch/powerpc/platforms/powernv/ocxl.c

528

unsigned long page_size)

arch/powerpc/platforms/powernv/ocxl.c

565

if (page_size == 0x1000)

arch/powerpc/platforms/powernv/ocxl.c

567

if (page_size == 0x200000)

arch/powerpc/platforms/powernv/ocxl.c

569

if (page_size == 0x40000000)

arch/powerpc/platforms/ps3/mm.c

1120

struct ps3_dma_region *r, enum ps3_dma_page_size page_size,

arch/powerpc/platforms/ps3/mm.c

1129

r->page_size = page_size;

arch/powerpc/platforms/ps3/mm.c

1134

r->len = len ? len : ALIGN(map.total, 1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

353

DBG("%s:%d: page_size %u\n", func, line, r->page_size);

arch/powerpc/platforms/ps3/mm.c

389

DBG("%s:%d: r.page_size %u\n", func, line, c->region->page_size);

arch/powerpc/platforms/ps3/mm.c

401

unsigned long aligned_bus = ALIGN_DOWN(bus_addr, 1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

403

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

430

unsigned long aligned_lpar = ALIGN_DOWN(lpar_addr, 1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

432

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

479

for (iopage = 0; iopage < (c->len >> r->page_size); iopage++) {

arch/powerpc/platforms/ps3/mm.c

480

offset = (1 << r->page_size) * iopage;

arch/powerpc/platforms/ps3/mm.c

589

pages = len >> r->page_size;

arch/powerpc/platforms/ps3/mm.c

591

r->page_size, r->len, pages, iopte_flag);

arch/powerpc/platforms/ps3/mm.c

593

offset = (1 << r->page_size) * iopage;

arch/powerpc/platforms/ps3/mm.c

618

offset = (1 << r->page_size) * iopage;

arch/powerpc/platforms/ps3/mm.c

655

__LINE__, r->len, r->page_size, r->offset);

arch/powerpc/platforms/ps3/mm.c

658

BUG_ON(!r->page_size);

arch/powerpc/platforms/ps3/mm.c

665

roundup_pow_of_two(r->len), r->page_size, r->region_type,

arch/powerpc/platforms/ps3/mm.c

688

r->page_size,

arch/powerpc/platforms/ps3/mm.c

697

r->len, r->page_size, r->bus_addr);

arch/powerpc/platforms/ps3/mm.c

783

unsigned long aligned_phys = ALIGN_DOWN(phys_addr, 1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

785

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

838

unsigned long aligned_phys = ALIGN_DOWN(phys_addr, 1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

840

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

898

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

900

- aligned_bus, 1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

935

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

938

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

978

if (r->page_size != PS3_DMA_16M) {

arch/powerpc/platforms/ps3/mm.c

981

r->page_size = PS3_DMA_16M;

arch/powerpc/platforms/ps3/mm.c

982

r->len = ALIGN(r->len, 1 << r->page_size);

arch/powerpc/platforms/ps3/system-bus.c

247

r->bus_addr, r->len, r->page_size, &lpar_addr);

arch/powerpc/platforms/ps3/system-bus.c

314

enum ps3_mmio_page_size page_size)

arch/powerpc/platforms/ps3/system-bus.c

319

r->page_size = page_size;

arch/powerpc/platforms/pseries/iommu.c

1222

query->page_size = query_out[2];

arch/powerpc/platforms/pseries/iommu.c

1229

query->page_size = query_out[3];

arch/powerpc/platforms/pseries/iommu.c

1237

query->page_size, query->windows_available);

arch/powerpc/platforms/pseries/iommu.c

1566

page_shift = iommu_get_page_shift(query.page_size);

arch/powerpc/platforms/pseries/iommu.c

1569

query.page_size);

arch/powerpc/platforms/pseries/iommu.c

1845

table_group->pgsizes |= query_page_size_to_mask(query.page_size);

arch/powerpc/platforms/pseries/iommu.c

422

u32 page_size;

arch/powerpc/platforms/pseries/lpar.c

728

unsigned long page_size, unsigned long table_size)

arch/powerpc/platforms/pseries/lpar.c

743

page_size, table_size);

arch/riscv/include/asm/kvm_gstage.h

63

gpa_t gpa, phys_addr_t hpa, unsigned long page_size,

arch/riscv/include/asm/tlbflush.h

49

unsigned long end, unsigned int page_size);

arch/riscv/kernel/machine_kexec.c

67

control_code_buffer_sz = page_size(image->control_code_page);

arch/riscv/kvm/gstage.c

209

gpa_t gpa, phys_addr_t hpa, unsigned long page_size,

arch/riscv/kvm/gstage.c

222

ret = gstage_page_size_to_level(gstage, page_size, &out_map->level);

arch/riscv/kvm/gstage.c

281

} else if (ALIGN_DOWN(PFN_PHYS(pte_pfn(ptep_get(ptep))), page_size) == hpa) {

arch/riscv/kvm/gstage.c

369

unsigned long next_page_size, page_size;

arch/riscv/kvm/gstage.c

372

ret = gstage_level_to_page_size(gstage, ptep_level, &page_size);

arch/riscv/kvm/gstage.c

376

WARN_ON(addr & (page_size - 1));

arch/riscv/kvm/gstage.c

415

unsigned long page_size;

arch/riscv/kvm/gstage.c

421

ret = gstage_level_to_page_size(gstage, ptep_level, &page_size);

arch/riscv/kvm/gstage.c

426

addr = ALIGN(addr + 1, page_size);

arch/riscv/kvm/gstage.c

428

if (!(addr & (page_size - 1)) && ((end - addr) >= page_size))

arch/riscv/kvm/gstage.c

433

addr, end, page_size);

arch/riscv/kvm/gstage.c

436

addr += page_size;

arch/riscv/kvm/gstage.c

44

static int gstage_page_size_to_level(struct kvm_gstage *gstage, unsigned long page_size,

arch/riscv/kvm/gstage.c

457

unsigned long page_size;

arch/riscv/kvm/gstage.c

462

ret = gstage_level_to_page_size(gstage, ptep_level, &page_size);

arch/riscv/kvm/gstage.c

467

addr = ALIGN(addr + 1, page_size);

arch/riscv/kvm/gstage.c

469

addr = ALIGN_DOWN(addr, page_size);

arch/riscv/kvm/gstage.c

472

addr += page_size;

arch/riscv/kvm/gstage.c

51

if (page_size == (psz << (i * kvm_riscv_gstage_index_bits))) {

arch/riscv/mm/tlbflush.c

159

unsigned int page_size)

arch/riscv/mm/tlbflush.c

161

__flush_tlb_range(mm, mm_cpumask(mm), start, end - start, page_size);

arch/s390/include/asm/tlb.h

27

struct page *page, int page_size);

arch/s390/include/asm/tlb.h

48

struct page *page, int page_size)

arch/sparc/include/asm/iommu_64.h

37

u64 page_size; /* IO PAGE size for IOTSB */

arch/sparc/kernel/pci_sun4v.c

779

iotsb->page_size = IO_PAGE_SIZE;

arch/sparc/kernel/pci_sun4v.c

785

iotsb->page_size,

arch/sparc/kernel/pci_sun4v.c

817

const u32 *page_size;

arch/sparc/kernel/pci_sun4v.c

827

page_size = of_get_property(pbm->op->dev.of_node, "iommu-pagesizes",

arch/sparc/kernel/pci_sun4v.c

829

if (!page_size) {

arch/sparc/kernel/pci_sun4v.h

97

unsigned long page_size,

arch/sparc/mm/init_64.c

2731

pte_t mk_pte_io(unsigned long page, pgprot_t prot, int space, unsigned long page_size)

arch/sparc/mm/init_64.c

2737

pte_val(pte) |= pte_sz_bits(page_size);

arch/x86/boot/startup/sev-shared.c

617

pc->entry[0].page_size = RMP_PG_SIZE_4K;

arch/x86/coco/sev/internal.h

113

static inline void __pval_terminate(u64 pfn, bool action, unsigned int page_size,

arch/x86/coco/sev/internal.h

117

pfn, action, page_size, ret, svsm_ret);

arch/x86/coco/sev/svsm.c

103

pe->page_size = RMP_PG_SIZE_4K;

arch/x86/coco/sev/svsm.c

134

pe->page_size = e->pagesize ? RMP_PG_SIZE_2M : RMP_PG_SIZE_4K;

arch/x86/coco/sev/svsm.c

154

unsigned int page_size;

arch/x86/coco/sev/svsm.c

160

page_size = pc->entry[pc->cur_index].page_size;

arch/x86/coco/sev/svsm.c

162

__pval_terminate(pfn, action, page_size, ret, svsm_ret);

arch/x86/coco/sev/svsm.c

213

pc->entry[pc->cur_index].page_size == RMP_PG_SIZE_2M) {

arch/x86/coco/tdx/tdx-shared.c

25

page_size = TDX_PS_4K;

arch/x86/coco/tdx/tdx-shared.c

28

page_size = TDX_PS_2M;

arch/x86/coco/tdx/tdx-shared.c

31

page_size = TDX_PS_1G;

arch/x86/coco/tdx/tdx-shared.c

37

args.rcx = start | page_size;

arch/x86/coco/tdx/tdx-shared.c

9

u8 page_size;

arch/x86/include/asm/sev.h

350

u64 page_size : 2,

arch/x86/kvm/svm/sev.c

2363

fw_args.page_size = PG_LEVEL_TO_RMP(PG_LEVEL_4K);

drivers/accel/habanalabs/common/command_buffer.c

21

u32 page_size = prop->pmmu.page_size;

drivers/accel/habanalabs/common/command_buffer.c

33

cb->roundup_size = roundup(cb->size, page_size);

drivers/accel/habanalabs/common/command_buffer.c

519

ctx->cb_va_pool = gen_pool_create(__ffs(prop->pmmu.page_size), -1);

drivers/accel/habanalabs/common/debugfs.c

311

phys_pg_pack->page_size);

drivers/accel/habanalabs/common/habanalabs.h

1767

u32 page_size, u32 *real_page_size, bool is_dram_addr);

drivers/accel/habanalabs/common/habanalabs.h

1813

u32 page_size;

drivers/accel/habanalabs/common/habanalabs.h

2242

u32 page_size;

drivers/accel/habanalabs/common/habanalabs.h

2941

int (*map)(struct hl_ctx *ctx, u64 virt_addr, u64 phys_addr, u32 page_size,

drivers/accel/habanalabs/common/habanalabs.h

3923

u32 page_size, bool flush_pte);

drivers/accel/habanalabs/common/habanalabs.h

3925

u32 page_size, u32 *real_page_size, bool is_dram_addr);

drivers/accel/habanalabs/common/habanalabs.h

3926

int hl_mmu_unmap_page(struct hl_ctx *ctx, u64 virt_addr, u32 page_size,

drivers/accel/habanalabs/common/habanalabs.h

530

u32 page_size;

drivers/accel/habanalabs/common/memory.c

100

rc = set_alloc_page_size(hdev, args, &page_size);

drivers/accel/habanalabs/common/memory.c

1011

u32 page_size;

drivers/accel/habanalabs/common/memory.c

1014

page_size = phys_pg_pack->page_size;

drivers/accel/habanalabs/common/memory.c

1017

for (i = 0 ; i < phys_pg_pack->npages ; i++, next_vaddr += page_size) {

drivers/accel/habanalabs/common/memory.c

1018

if (hl_mmu_unmap_page(ctx, next_vaddr, page_size,

drivers/accel/habanalabs/common/memory.c

104

num_pgs = DIV_ROUND_UP_ULL(args->alloc.mem_size, page_size);

drivers/accel/habanalabs/common/memory.c

105

total_size = num_pgs * page_size;

drivers/accel/habanalabs/common/memory.c

1074

u32 page_size = hdev->asic_prop.pmmu.page_size,

drivers/accel/habanalabs/common/memory.c

1075

huge_page_size = hdev->asic_prop.pmmu_huge.page_size;

drivers/accel/habanalabs/common/memory.c

1095

if (phys_pg_pack->page_size == page_size) {

drivers/accel/habanalabs/common/memory.c

1103

va_block_align = page_size;

drivers/accel/habanalabs/common/memory.c

1139

va_block_align = hdev->asic_prop.dmmu.page_size;

drivers/accel/habanalabs/common/memory.c

115

if (is_power_of_2(page_size))

drivers/accel/habanalabs/common/memory.c

117

total_size, NULL, page_size);

drivers/accel/habanalabs/common/memory.c

1321

if (phys_pg_pack->page_size ==

drivers/accel/habanalabs/common/memory.c

1322

hdev->asic_prop.pmmu.page_size)

drivers/accel/habanalabs/common/memory.c

1344

if (!is_userptr && !is_power_of_2(phys_pg_pack->page_size))

drivers/accel/habanalabs/common/memory.c

1347

phys_pg_pack->page_size) *

drivers/accel/habanalabs/common/memory.c

1348

phys_pg_pack->page_size;

drivers/accel/habanalabs/common/memory.c

1350

vaddr &= ~(((u64) phys_pg_pack->page_size) - 1);

drivers/accel/habanalabs/common/memory.c

137

phys_pg_pack->page_size = page_size;

drivers/accel/habanalabs/common/memory.c

150

phys_pg_pack->pages[i] = paddr + i * page_size;

drivers/accel/habanalabs/common/memory.c

153

if (is_power_of_2(page_size))

drivers/accel/habanalabs/common/memory.c

1535

u64 page_size, u64 exported_size, u64 offset,

drivers/accel/habanalabs/common/memory.c

156

page_size, NULL,

drivers/accel/habanalabs/common/memory.c

1562

if (offset < page_size)

drivers/accel/habanalabs/common/memory.c

1566

offset -= page_size;

drivers/accel/habanalabs/common/memory.c

157

page_size);

drivers/accel/habanalabs/common/memory.c

1573

left_size_in_page = page_size - offset;

drivers/accel/habanalabs/common/memory.c

1588

if (pages[curr_page] + page_size != pages[curr_page + 1])

drivers/accel/habanalabs/common/memory.c

1592

left_size_in_page = page_size;

drivers/accel/habanalabs/common/memory.c

160

page_size);

drivers/accel/habanalabs/common/memory.c

1614

left_size_in_page = page_size - offset;

drivers/accel/habanalabs/common/memory.c

1634

if (pages[curr_page] + page_size != pages[curr_page + 1]) {

drivers/accel/habanalabs/common/memory.c

1639

left_size_in_page = page_size;

drivers/accel/habanalabs/common/memory.c

1727

u64 *pages, npages, page_size, exported_size, offset;

drivers/accel/habanalabs/common/memory.c

1749

page_size = phys_pg_pack->page_size;

drivers/accel/habanalabs/common/memory.c

1753

page_size = hl_dmabuf->dmabuf->size;

drivers/accel/habanalabs/common/memory.c

1756

sgt = alloc_sgt_from_device_pages(hdev, pages, npages, page_size, exported_size, offset,

drivers/accel/habanalabs/common/memory.c

1977

if ((bar_address + phys_pg_pack->page_size) >

drivers/accel/habanalabs/common/memory.c

1979

(bar_address + phys_pg_pack->page_size) < bar_address) {

drivers/accel/habanalabs/common/memory.c

1982

phys_pg_pack->pages[i], phys_pg_pack->page_size);

drivers/accel/habanalabs/common/memory.c

201

page_size);

drivers/accel/habanalabs/common/memory.c

2516

u64 end, u32 page_size)

drivers/accel/habanalabs/common/memory.c

2529

if (is_power_of_2(page_size)) {

drivers/accel/habanalabs/common/memory.c

2530

start = round_up(start, page_size);

drivers/accel/habanalabs/common/memory.c

2538

end = round_down(end + 1, page_size) - 1;

drivers/accel/habanalabs/common/memory.c

2555

va_range->page_size = page_size;

drivers/accel/habanalabs/common/memory.c

2715

prop->dram_page_size : prop->dmmu.page_size;

drivers/accel/habanalabs/common/memory.c

2718

host_page_size = prop->pmmu.page_size;

drivers/accel/habanalabs/common/memory.c

2721

host_huge_page_size = prop->pmmu_huge.page_size;

drivers/accel/habanalabs/common/memory.c

29

static int set_alloc_page_size(struct hl_device *hdev, struct hl_mem_in *args, u32 *page_size)

drivers/accel/habanalabs/common/memory.c

332

phys_pg_pack->page_size);

drivers/accel/habanalabs/common/memory.c

38

if (prop->supports_user_set_page_size && args->alloc.page_size) {

drivers/accel/habanalabs/common/memory.c

39

psize = args->alloc.page_size;

drivers/accel/habanalabs/common/memory.c

49

*page_size = psize;

drivers/accel/habanalabs/common/memory.c

605

bool is_align_pow_2 = is_power_of_2(va_range->page_size);

drivers/accel/habanalabs/common/memory.c

618

size = DIV_ROUND_UP_ULL(size, va_range->page_size) *

drivers/accel/habanalabs/common/memory.c

619

va_range->page_size;

drivers/accel/habanalabs/common/memory.c

626

do_div(tmp_hint_addr, va_range->page_size))) {

drivers/accel/habanalabs/common/memory.c

760

max(alignment, ctx->va_range[type]->page_size),

drivers/accel/habanalabs/common/memory.c

843

u32 npages, page_size = PAGE_SIZE,

drivers/accel/habanalabs/common/memory.c

844

huge_page_size = ctx->hdev->asic_prop.pmmu_huge.page_size;

drivers/accel/habanalabs/common/memory.c

845

u32 pgs_in_huge_page = huge_page_size >> __ffs(page_size);

drivers/accel/habanalabs/common/memory.c

882

page_size = huge_page_size;

drivers/accel/habanalabs/common/memory.c

886

page_mask = ~(((u64) page_size) - 1);

drivers/accel/habanalabs/common/memory.c

896

phys_pg_pack->page_size = page_size;

drivers/accel/habanalabs/common/memory.c

897

phys_pg_pack->total_size = total_npages * page_size;

drivers/accel/habanalabs/common/memory.c

906

phys_pg_pack->offset = dma_addr & (page_size - 1);

drivers/accel/habanalabs/common/memory.c

912

dma_addr += page_size;

drivers/accel/habanalabs/common/memory.c

94

u32 num_curr_pgs, page_size;

drivers/accel/habanalabs/common/memory.c

947

u32 page_size = phys_pg_pack->page_size;

drivers/accel/habanalabs/common/memory.c

954

rc = hl_mmu_map_page(ctx, next_vaddr, paddr, page_size,

drivers/accel/habanalabs/common/memory.c

965

next_vaddr += page_size;

drivers/accel/habanalabs/common/memory.c

975

if (hl_mmu_unmap_page(ctx, next_vaddr, page_size,

drivers/accel/habanalabs/common/memory.c

980

phys_pg_pack->pages[i], page_size);

drivers/accel/habanalabs/common/memory.c

982

next_vaddr += page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

176

u32 page_size, u32 *real_page_size, bool is_dram_addr)

drivers/accel/habanalabs/common/mmu/mmu.c

182

if ((page_size % mmu_prop->page_size) == 0) {

drivers/accel/habanalabs/common/mmu/mmu.c

183

*real_page_size = mmu_prop->page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

188

page_size, mmu_prop->page_size >> 10);

drivers/accel/habanalabs/common/mmu/mmu.c

193

static struct hl_mmu_properties *hl_mmu_get_prop(struct hl_device *hdev, u32 page_size,

drivers/accel/habanalabs/common/mmu/mmu.c

200

else if ((page_size % prop->pmmu_huge.page_size) == 0)

drivers/accel/habanalabs/common/mmu/mmu.c

227

int hl_mmu_unmap_page(struct hl_ctx *ctx, u64 virt_addr, u32 page_size, bool flush_pte)

drivers/accel/habanalabs/common/mmu/mmu.c

241

mmu_prop = hl_mmu_get_prop(hdev, page_size, is_dram_addr);

drivers/accel/habanalabs/common/mmu/mmu.c

246

rc = hdev->asic_funcs->mmu_get_real_page_size(hdev, mmu_prop, page_size, &real_page_size,

drivers/accel/habanalabs/common/mmu/mmu.c

251

npages = page_size / real_page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

266

trace_habanalabs_mmu_unmap(&hdev->pdev->dev, virt_addr, 0, page_size, flush_pte);

drivers/accel/habanalabs/common/mmu/mmu.c

293

int hl_mmu_map_page(struct hl_ctx *ctx, u64 virt_addr, u64 phys_addr, u32 page_size,

drivers/accel/habanalabs/common/mmu/mmu.c

309

mmu_prop = hl_mmu_get_prop(hdev, page_size, is_dram_addr);

drivers/accel/habanalabs/common/mmu/mmu.c

314

rc = hdev->asic_funcs->mmu_get_real_page_size(hdev, mmu_prop, page_size, &real_page_size,

drivers/accel/habanalabs/common/mmu/mmu.c

326

(mmu_prop->page_size - 1)) ||

drivers/accel/habanalabs/common/mmu/mmu.c

328

(mmu_prop->page_size - 1)))) ||

drivers/accel/habanalabs/common/mmu/mmu.c

33

return hl_mem_area_inside_range(virt_addr, prop->dmmu.page_size,

drivers/accel/habanalabs/common/mmu/mmu.c

335

npages = page_size / real_page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

353

trace_habanalabs_mmu_map(&hdev->pdev->dev, virt_addr, phys_addr, page_size, flush_pte);

drivers/accel/habanalabs/common/mmu/mmu.c

388

u32 page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

394

page_size = prop->dmmu.page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

397

page_size = prop->pmmu.page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

400

page_size = prop->pmmu_huge.page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

404

for (off = 0 ; off < size ; off += page_size) {

drivers/accel/habanalabs/common/mmu/mmu.c

407

flush_pte = (off + page_size) >= size;

drivers/accel/habanalabs/common/mmu/mmu.c

408

rc = hl_mmu_map_page(ctx, curr_va, curr_pa, page_size,

drivers/accel/habanalabs/common/mmu/mmu.c

415

off -= page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

423

for (; off >= 0 ; off -= page_size) {

drivers/accel/habanalabs/common/mmu/mmu.c

425

flush_pte = (off - (s32) page_size) < 0;

drivers/accel/habanalabs/common/mmu/mmu.c

426

if (hl_mmu_unmap_page(ctx, curr_va, page_size, flush_pte))

drivers/accel/habanalabs/common/mmu/mmu.c

448

u32 page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

454

page_size = prop->dmmu.page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

457

page_size = prop->pmmu.page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

460

page_size = prop->pmmu_huge.page_size;

drivers/accel/habanalabs/common/mmu/mmu.c

464

for (off = 0 ; off < size ; off += page_size) {

drivers/accel/habanalabs/common/mmu/mmu.c

466

flush_pte = (off + page_size) >= size;

drivers/accel/habanalabs/common/mmu/mmu.c

467

rc = hl_mmu_unmap_page(ctx, curr_va, page_size, flush_pte);

drivers/accel/habanalabs/common/mmu/mmu.c

564

is_dram_addr = hl_mem_area_inside_range(virt_addr, prop->dmmu.page_size,

drivers/accel/habanalabs/common/mmu/mmu_v1.c

324

u32 page_size, bool is_dram_addr)

drivers/accel/habanalabs/common/mmu/mmu_v1.c

343

} else if (page_size == prop->pmmu_huge.page_size) {

drivers/accel/habanalabs/common/mmu/mmu_v1.c

462

is_dram_addr = hl_mem_area_inside_range(virt_addr, prop->dmmu.page_size,

drivers/accel/habanalabs/common/mmu/mmu_v1.c

465

is_pmmu_addr = hl_mem_area_inside_range(virt_addr, prop->pmmu.page_size,

drivers/accel/habanalabs/common/mmu/mmu_v1.c

469

prop->pmmu_huge.page_size,

drivers/accel/habanalabs/common/mmu/mmu_v2.c

131

u32 page_size, bool is_dram_addr)

drivers/accel/habanalabs/common/mmu/mmu_v2.c

253

is_dram_addr = hl_mem_area_inside_range(virt_addr, prop->dmmu.page_size,

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

190

static int hl_mmu_v2_get_last_hop(struct hl_mmu_properties *mmu_prop, u32 page_size)

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

198

if (page_size <= (1 << mmu_prop->hop_shifts[hop]))

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

207

u32 page_size, bool is_dram_addr)

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

227

else if (page_size == prop->pmmu_huge.page_size)

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

232

hop_last = hl_mmu_v2_get_last_hop(mmu_prop, page_size);

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

341

is_dram_addr = hl_mem_area_inside_range(virt_addr, prop->dmmu.page_size,

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

344

is_pmmu_addr = hl_mem_area_inside_range(virt_addr, prop->pmmu.page_size,

drivers/accel/habanalabs/common/mmu/mmu_v2_hr.c

348

prop->pmmu_huge.page_size,

drivers/accel/habanalabs/gaudi/gaudi.c

633

prop->pmmu.page_size = PAGE_SIZE_4KB;

drivers/accel/habanalabs/gaudi/gaudi.c

642

prop->pmmu_huge.page_size = PAGE_SIZE_2MB;

drivers/accel/habanalabs/gaudi/gaudi.c

648

prop->dmmu.page_size = PAGE_SIZE_2MB;

drivers/accel/habanalabs/gaudi2/gaudi2.c

11231

gaudi2->virt_msix_db_dma_addr, prop->pmmu.page_size, true);

drivers/accel/habanalabs/gaudi2/gaudi2.c

11246

prop->pmmu.page_size, true);

drivers/accel/habanalabs/gaudi2/gaudi2.c

11833

u32 page_size, u32 *real_page_size, bool is_dram_addr)

drivers/accel/habanalabs/gaudi2/gaudi2.c

11839

if (page_size % mmu_prop->page_size)

drivers/accel/habanalabs/gaudi2/gaudi2.c

11842

*real_page_size = mmu_prop->page_size;

drivers/accel/habanalabs/gaudi2/gaudi2.c

11846

if ((page_size % prop->dram_page_size) || (prop->dram_page_size > mmu_prop->page_size))

drivers/accel/habanalabs/gaudi2/gaudi2.c

11863

page_size, mmu_prop->page_size >> 10);

drivers/accel/habanalabs/gaudi2/gaudi2.c

2725

div_u64((VA_HBM_SPACE_END - prop->dmmu.start_addr), prop->dmmu.page_size);

drivers/accel/habanalabs/gaudi2/gaudi2.c

2829

prop->dmmu.page_size = PAGE_SIZE_1GB;

drivers/accel/habanalabs/gaudi2/gaudi2.c

2876

prop->pmmu.page_size = PAGE_SIZE_64KB;

drivers/accel/habanalabs/gaudi2/gaudi2.c

2880

prop->pmmu_huge.page_size = PAGE_SIZE_16MB;

drivers/accel/habanalabs/gaudi2/gaudi2.c

2898

prop->pmmu.page_size = PAGE_SIZE_4KB;

drivers/accel/habanalabs/gaudi2/gaudi2.c

2902

prop->pmmu_huge.page_size = PAGE_SIZE_2MB;

drivers/accel/habanalabs/gaudi2/gaudi2.c

4113

gaudi2->virt_msix_db_cpu_addr = hl_cpu_accessible_dma_pool_alloc(hdev, prop->pmmu.page_size,

drivers/accel/habanalabs/gaudi2/gaudi2.c

4160

hl_cpu_accessible_dma_pool_free(hdev, prop->pmmu.page_size, gaudi2->virt_msix_db_cpu_addr);

drivers/accel/habanalabs/gaudi2/gaudi2.c

4182

hl_cpu_accessible_dma_pool_free(hdev, prop->pmmu.page_size, gaudi2->virt_msix_db_cpu_addr);

drivers/accel/habanalabs/goya/goya.c

431

prop->dmmu.page_size = PAGE_SIZE_2MB;

drivers/accel/habanalabs/goya/goya.c

442

prop->pmmu.page_size = PAGE_SIZE_4KB;

drivers/accel/habanalabs/goya/goya.c

451

prop->pmmu_huge.page_size = PAGE_SIZE_2MB;

drivers/block/ps3vram.c

318

if (ps3vram_upload(dev, CACHE_OFFSET + entry * cache->page_size,

drivers/block/ps3vram.c

320

cache->page_size / DMA_PAGE_SIZE) < 0) {

drivers/block/ps3vram.c

323

entry * cache->page_size, cache->tags[entry].address,

drivers/block/ps3vram.c

324

cache->page_size);

drivers/block/ps3vram.c

337

CACHE_OFFSET + entry * cache->page_size,

drivers/block/ps3vram.c

339

cache->page_size / DMA_PAGE_SIZE) < 0) {

drivers/block/ps3vram.c

342

address, entry * cache->page_size, cache->page_size);

drivers/block/ps3vram.c

373

offset = (unsigned int) (address & (cache->page_size - 1));

drivers/block/ps3vram.c

403

priv->cache.page_size = CACHE_PAGE_SIZE;

drivers/block/ps3vram.c

443

offset = (unsigned int) (from & (priv->cache.page_size - 1));

drivers/block/ps3vram.c

444

avail = priv->cache.page_size - offset;

drivers/block/ps3vram.c

447

cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;

drivers/block/ps3vram.c

484

offset = (unsigned int) (to & (priv->cache.page_size - 1));

drivers/block/ps3vram.c

485

avail = priv->cache.page_size - offset;

drivers/block/ps3vram.c

488

cached = CACHE_OFFSET + entry * priv->cache.page_size + offset;

drivers/block/ps3vram.c

63

unsigned int page_size;

drivers/crypto/ccp/sev-dev-tio.c

24

#define SLA_SZ(s) ((s).page_size == SLA_PAGE_SIZE_2M ? SZ_2M : SZ_4K)

drivers/crypto/ccp/sev-dev-tio.c

54

.page_size = SLA_PAGE_SIZE_4K, /* Do not do SLA_PAGE_SIZE_2M ATM */

drivers/crypto/ccp/sev-dev-tio.h

15

page_size :1,

drivers/dma-buf/heaps/system_heap.c

446

size_remaining -= page_size(page);

drivers/dma-buf/heaps/system_heap.c

457

sg_set_page(sg, page, page_size(page), 0);

drivers/gpu/drm/drm_pagemap.c

357

state->offset, page_size(page),

drivers/gpu/drm/drm_pagemap.c

363

state->offset += page_size(page);

drivers/gpu/drm/drm_pagemap.c

365

dma_addr = dma_map_page(dev, page, 0, page_size(page),

drivers/gpu/drm/drm_pagemap.c

910

addr += page_size(page);

drivers/gpu/drm/i915/display/intel_vbt_defs.h

631

u16 page_size;

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

78

resource_size_t page_size,

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

82

size, page_size, flags);

drivers/gpu/drm/i915/gem/i915_gem_lmem.h

29

resource_size_t page_size,

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

109

resource_size_t page_size,

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

113

size, page_size, flags);

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

36

resource_size_t page_size,

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

60

if (page_size)

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

61

default_page_size = page_size;

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

94

err = mem->ops->init_object(mem, obj, offset, size, page_size, flags);

drivers/gpu/drm/i915/gem/i915_gem_region.h

57

resource_size_t page_size,

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

552

resource_size_t page_size,

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

765

resource_size_t page_size,

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

1292

resource_size_t page_size,

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

1321

GEM_BUG_ON(page_size && obj->mm.n_placements);

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

1339

&i915_sys_placement, page_size >> PAGE_SHIFT,

drivers/gpu/drm/i915/gem/i915_gem_ttm.h

59

resource_size_t page_size,

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

112

unsigned int page_size = BIT(bit);

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

113

int order = get_order(page_size);

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

123

sg_set_page(sg, page, page_size, 0);

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

124

sg_page_sizes |= page_size;

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

127

rem -= page_size;

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

134

} while ((rem - ((page_size-1) & page_mask)) >= page_size);

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

136

page_mask &= (page_size-1);

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

237

unsigned int page_size = get_largest_page_size(i915, rem);

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

238

unsigned int len = min(page_size * div_u64(rem, page_size),

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

241

GEM_BUG_ON(!page_size);

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

246

sg_dma_address(sg) = page_size;

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

271

unsigned int page_size;

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

285

page_size = get_largest_page_size(i915, obj->base.size);

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

286

GEM_BUG_ON(!page_size);

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

291

sg_dma_address(sg) = page_size;

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

516

unsigned int page_size = BIT(bit);

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

522

page_size, page_size,

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

544

if (!IS_ALIGNED(phys, page_size)) {

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

546

__func__, &phys, page_size);

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

551

if (vma->resource->page_sizes_gtt != page_size) {

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

554

page_size);

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

56

unsigned int page_size = page_sizes[i];

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

58

if (HAS_PAGE_SIZES(i915, page_size) && rem >= page_size)

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

59

return page_size;

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

596

unsigned int page_size = BIT(bit);

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

600

round_up(page_size, I915_GTT_PAGE_SIZE_2M) << 1;

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

619

obj->mm.page_sizes.sg = page_size;

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

634

if (vma->resource->page_sizes_gtt != page_size) {

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

636

vma->resource->page_sizes_gtt, page_size);

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

650

for (offset = 4096; offset < page_size; offset += 4096) {

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

675

__func__, offset, page_size))

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

794

unsigned int page_size = page_sizes[i];

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

796

if (HAS_PAGE_SIZES(i915, page_size) &&

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

797

size >= page_size) {

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

798

expected_gtt |= page_size;

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

799

size &= page_size-1;

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

524

unsigned int page_size;

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

537

page_size = I915_GTT_PAGE_SIZE_2M;

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

542

page_size = I915_GTT_PAGE_SIZE;

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

557

page_size = I915_GTT_PAGE_SIZE_64K;

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

569

page_size = I915_GTT_PAGE_SIZE_64K;

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

578

GEM_BUG_ON(rem < page_size);

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

586

start += page_size;

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

587

iter->dma += page_size;

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

588

rem -= page_size;

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

601

if (unlikely(!IS_ALIGNED(iter->dma, page_size)))

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

604

} while (rem >= page_size && index < max);

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

607

vma_res->page_sizes_gtt |= page_size;

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

630

unsigned int page_size;

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

640

page_size = I915_GTT_PAGE_SIZE_2M;

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

648

page_size = I915_GTT_PAGE_SIZE;

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

661

GEM_BUG_ON(sg_dma_len(iter->sg) < page_size);

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

664

start += page_size;

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

665

iter->dma += page_size;

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

666

rem -= page_size;

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

685

if (unlikely(!IS_ALIGNED(iter->dma, page_size)))

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

688

} while (rem >= page_size && index < I915_PDES);

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

707

page_size = I915_GTT_PAGE_SIZE_64K;

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

731

vma_res->page_sizes_gtt |= page_size;

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

375

u32 page_size;

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

380

page_size = I915_GTT_PAGE_SIZE;

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

392

page_size = I915_GTT_PAGE_SIZE_64K;

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

436

dword_rem /= page_size;

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

449

GEM_BUG_ON(!IS_ALIGNED(it->dma, page_size));

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

455

total += page_size;

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

457

it->dma += page_size;

drivers/gpu/drm/i915/intel_memory_region.h

55

resource_size_t page_size,

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

58

resource_size_t page_size;

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

65

page_size = PAGE_SIZE;

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

66

max_pages = div64_u64(total, page_size);

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

70

resource_size_t size = page_num * page_size;

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

92

if (page_num * page_size <= rem) {

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

64

resource_size_t page_size,

drivers/gpu/drm/imagination/pvr_rogue_mips.h

286

#define ROGUE_MIPSFW_TLB_GET_PAGE_MASK(page_size) ((((page_size) << 11) - 1) & ~0x7FF)

drivers/gpu/drm/nouveau/nouveau_dmem.c

165

dma_info->dma_addr = dma_map_page(dev, dpage, 0, page_size(dpage),

drivers/gpu/drm/nouveau/nouveau_dmem.c

167

dma_info->size = page_size(dpage);

drivers/gpu/drm/nouveau/nouveau_dmem.c

175

dma_unmap_page(dev, dma_info->dma_addr, page_size(dpage),

drivers/gpu/drm/nouveau/nouveau_dmem.c

748

dma_info->dma_addr = dma_map_page(dev, spage, 0, page_size(spage),

drivers/gpu/drm/nouveau/nouveau_dmem.c

750

dma_info->size = page_size(spage);

drivers/gpu/drm/nouveau/nouveau_dmem.c

759

if (drm->dmem->migrate.clear_func(drm, page_size(dpage),

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

110

ctrl->pageSize = page_size;

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

79

const u64 page_size = BIT_ULL(page_shift);

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

93

ret = nvkm_vmm_get_locked(vmm, true, false, false, page_shift, 32, page_size,

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmmgp100.c

126

gp100_vmm_pte_comptagline_incr(u32 page_size)

drivers/gpu/drm/nouveau/nvkm/subdev/mmu/vmmgp100.c

128

return gp100_vmm_comptag_nr(page_size) << 36; /* NV_MMU_VER2_PTE_COMPTAGLINE */

drivers/gpu/drm/v3d/v3d_mmu.c

120

unsigned int i, page_size;

drivers/gpu/drm/v3d/v3d_mmu.c

126

page_size = SZ_1M;

drivers/gpu/drm/v3d/v3d_mmu.c

130

page_size = SZ_64K;

drivers/gpu/drm/v3d/v3d_mmu.c

133

page_size = SZ_4K;

drivers/gpu/drm/v3d/v3d_mmu.c

136

for (i = 0; i < page_size >> V3D_MMU_PAGE_SHIFT; i++) {

drivers/gpu/drm/v3d/v3d_mmu.c

141

len -= page_size;

drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c

188

size_t page_size;

drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c

776

ret = drm_mm_insert_node(&man->mm, info->node, info->page_size);

drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c

779

ret = drm_mm_insert_node(&man->mm, info->node, info->page_size);

drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c

807

info.page_size = PFN_UP(size);

drivers/gpu/drm/xe/display/xe_initial_plane.c

32

u64 page_size = xe->info.vram_flags & XE_VRAM_FLAGS_NEED64K ? SZ_64K : SZ_4K;

drivers/gpu/drm/xe/display/xe_initial_plane.c

39

base = round_down(plane_config->base, page_size);

drivers/gpu/drm/xe/display/xe_initial_plane.c

49

phys_base = pte & ~(page_size - 1);

drivers/gpu/drm/xe/display/xe_initial_plane.c

83

page_size);

drivers/gpu/drm/xe/xe_bo.c

3180

dma_addr_t __xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size)

drivers/gpu/drm/xe/xe_bo.c

3186

xe_assert(xe, page_size <= PAGE_SIZE);

drivers/gpu/drm/xe/xe_bo.c

3194

page_size, &cur);

drivers/gpu/drm/xe/xe_bo.c

3200

page_size, &cur);

drivers/gpu/drm/xe/xe_bo.c

3205

dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size)

drivers/gpu/drm/xe/xe_bo.c

3209

return __xe_bo_addr(bo, offset, page_size);

drivers/gpu/drm/xe/xe_bo.c

3889

u32 page_size = max_t(u32, PAGE_SIZE,

drivers/gpu/drm/xe/xe_bo.c

3892

err = drm_mode_size_dumb(dev, args, SZ_64, page_size);

drivers/gpu/drm/xe/xe_bo.h

373

dma_addr_t __xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size);

drivers/gpu/drm/xe/xe_bo.h

374

dma_addr_t xe_bo_addr(struct xe_bo *bo, u64 offset, size_t page_size);

drivers/gpu/drm/xe/xe_bo.h

377

xe_bo_main_addr(struct xe_bo *bo, size_t page_size)

drivers/gpu/drm/xe/xe_bo.h

379

return xe_bo_addr(bo, 0, page_size);

drivers/gpu/drm/xe/xe_lmtt.c

486

u64 page_size = lmtt_page_size(lmtt);

drivers/gpu/drm/xe/xe_lmtt.c

491

lmtt_assert(lmtt, IS_ALIGNED(start, page_size));

drivers/gpu/drm/xe/xe_lmtt.c

492

lmtt_assert(lmtt, IS_ALIGNED(xe_bo_size(bo), page_size));

drivers/gpu/drm/xe/xe_lmtt.c

506

xe_res_next(&cur, page_size);

drivers/gpu/drm/xe/xe_lmtt.c

507

start += page_size;

drivers/gpu/drm/xe/xe_pt.c

1232

u64 page_size = 1ull << xe_pt_shift(xe_pt->level);

drivers/gpu/drm/xe/xe_pt.c

1237

start = entry->ofs * page_size;

drivers/gpu/drm/xe/xe_pt.c

1238

end = start + page_size * entry->qwords;

drivers/hv/hv_balloon.c

1613

range->page_size = HV_GPA_PAGE_RANGE_PAGE_SIZE_2MB;

drivers/infiniband/core/umem.c

103

unsigned int page_size = BIT(to_ib_umem_odp(umem)->page_shift);

drivers/infiniband/core/umem.c

106

if (!(pgsz_bitmap & page_size))

drivers/infiniband/core/umem.c

108

return page_size;

drivers/infiniband/core/umem_odp.c

62

size_t page_size = 1UL << umem_odp->page_shift;

drivers/infiniband/core/umem_odp.c

72

start = ALIGN_DOWN(umem_odp->umem.address, page_size);

drivers/infiniband/core/umem_odp.c

76

end = ALIGN(end, page_size);

drivers/infiniband/core/umem_odp.c

77

if (unlikely(end < page_size))

drivers/infiniband/core/umem_odp.c

92

if (!(nr_entries * PAGE_SIZE / page_size))

drivers/infiniband/core/verbs.c

2721

unsigned int *meta_sg_offset, unsigned int page_size)

drivers/infiniband/core/verbs.c

2727

mr->page_size = page_size;

drivers/infiniband/core/verbs.c

2762

unsigned int *sg_offset, unsigned int page_size)

drivers/infiniband/core/verbs.c

2767

mr->page_size = page_size;

drivers/infiniband/core/verbs.c

2802

u64 page_mask = ~((u64)mr->page_size - 1);

drivers/infiniband/core/verbs.c

2847

page_addr += mr->page_size;

drivers/infiniband/hw/bng_re/bng_dev.c

151

req.page_size = BNGE_PAGE_SHIFT;

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1149

unsigned long page_size;

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1154

page_size = ib_umem_find_best_pgsz(umem, SZ_4K, 0);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1155

if (!page_size || page_size != SZ_4K)

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1159

sginfo->npages = ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1160

sginfo->pgsize = page_size;

drivers/infiniband/hw/bnxt_re/ib_verbs.c

1161

sginfo->pgshft = __builtin_ctz(page_size);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

3124

wqe->frmr.pg_sz_log = ilog2(wr->mr->page_size >> PAGE_SHIFT_4K);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4618

unsigned long page_size;

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4629

page_size = ib_umem_find_best_pgsz(umem, BNXT_RE_PAGE_SIZE_SUPPORTED, virt_addr);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4630

if (!page_size) {

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4663

umem_pgs = ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4665

umem_pgs, page_size,

drivers/infiniband/hw/bnxt_re/main.c

955

req.page_size = BNXT_PAGE_SHIFT;

drivers/infiniband/hw/cxgb4/iw_cxgb4.h

386

u32 page_size:5;

drivers/infiniband/hw/cxgb4/mem.c

274

u64 len, u8 page_size, u32 pbl_size, u32 pbl_addr,

drivers/infiniband/hw/cxgb4/mem.c

323

FW_RI_TPTE_PS_V(page_size));

drivers/infiniband/hw/cxgb4/mem.c

386

mhp->ibmr.page_size = 1U << (mhp->attr.page_size + 12);

drivers/infiniband/hw/cxgb4/mem.c

464

mhp->attr.page_size = 0;

drivers/infiniband/hw/cxgb4/mem.c

579

mhp->attr.page_size = shift - 12;

drivers/infiniband/hw/cxgb4/qp.c

802

FW_RI_TPTE_PS_V(ilog2(wr->mr->page_size) - 12));

drivers/infiniband/hw/cxgb4/qp.c

831

wqe->fr.pgsz_shift = ilog2(wr->mr->page_size) - 12;

drivers/infiniband/hw/erdma/erdma_verbs.c

1181

mr->mem.page_size = PAGE_SIZE; /* update it later. */

drivers/infiniband/hw/erdma/erdma_verbs.c

167

ilog2(mr->mem.page_size)) |

drivers/infiniband/hw/erdma/erdma_verbs.c

197

u32 page_size;

drivers/infiniband/hw/erdma/erdma_verbs.c

207

page_size = SZ_32M;

drivers/infiniband/hw/erdma/erdma_verbs.c

209

ilog2(page_size) - ERDMA_HW_PAGE_SHIFT);

drivers/infiniband/hw/erdma/erdma_verbs.c

223

ilog2(mem->page_size) - ERDMA_HW_PAGE_SHIFT);

drivers/infiniband/hw/erdma/erdma_verbs.c

598

rdma_umem_for_each_dma_block(mem->umem, &biter, mem->page_size)

drivers/infiniband/hw/erdma/erdma_verbs.c

846

mem->page_size = ib_umem_find_best_pgsz(mem->umem, req_page_size, virt);

drivers/infiniband/hw/erdma/erdma_verbs.c

847

mem->page_offset = start & (mem->page_size - 1);

drivers/infiniband/hw/erdma/erdma_verbs.c

848

mem->mtt_nents = ib_umem_num_dma_blocks(mem->umem, mem->page_size);

drivers/infiniband/hw/erdma/erdma_verbs.c

92

ilog2(user_qp->sq_mem.page_size) - ERDMA_HW_PAGE_SHIFT);

drivers/infiniband/hw/erdma/erdma_verbs.c

98

ilog2(user_qp->rq_mem.page_size) - ERDMA_HW_PAGE_SHIFT);

drivers/infiniband/hw/erdma/erdma_verbs.h

115

u32 page_size;

drivers/infiniband/hw/hns/hns_roce_alloc.c

126

buf->npages = DIV_ROUND_UP(alloced_size, page_size);

drivers/infiniband/hw/hns/hns_roce_alloc.c

69

u32 trunk_size, page_size, alloced_size;

drivers/infiniband/hw/hns/hns_roce_alloc.c

85

page_size = 1 << buf->page_shift;

drivers/infiniband/hw/hns/hns_roce_alloc.c

92

buf->trunk_shift = order_base_2(ALIGN(page_size, PAGE_SIZE));

drivers/infiniband/hw/hns/hns_roce_mr.c

460

ibmr->page_size < HNS_HW_PAGE_SIZE ||

drivers/infiniband/hw/hns/hns_roce_mr.c

461

ibmr->page_size > HNS_HW_MAX_PAGE_SIZE)

drivers/infiniband/hw/hns/hns_roce_mr.c

486

mr->pbl_mtr.hem_cfg.buf_pg_shift = (u32)ilog2(ibmr->page_size);

drivers/infiniband/hw/hns/hns_roce_mr.c

562

size_t page_size = 1 << page_shift;

drivers/infiniband/hw/hns/hns_roce_mr.c

566

if (pages[i] - pages[i - 1] != page_size)

drivers/infiniband/hw/ionic/ionic_controlpath.c

1107

mr->buf.page_size_log2 = order_base_2(ibmr->page_size);

drivers/infiniband/hw/ionic/ionic_datapath.c

1113

wqe->reg_mr.page_size_log2 = order_base_2(mr->ibmr.page_size);

drivers/infiniband/hw/ionic/ionic_ibdev.h

515

u64 page_size);

drivers/infiniband/hw/ionic/ionic_pgtbl.c

107

u64 page_size)

drivers/infiniband/hw/ionic/ionic_pgtbl.c

114

limit = ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/ionic/ionic_pgtbl.c

115

buf->page_size_log2 = order_base_2(page_size);

drivers/infiniband/hw/irdma/ctrl.c

1457

enum irdma_page_size page_size;

drivers/infiniband/hw/irdma/ctrl.c

1462

if (info->page_size == 0x40000000)

drivers/infiniband/hw/irdma/ctrl.c

1463

page_size = IRDMA_PAGE_SIZE_1G;

drivers/infiniband/hw/irdma/ctrl.c

1464

else if (info->page_size == 0x200000)

drivers/infiniband/hw/irdma/ctrl.c

1465

page_size = IRDMA_PAGE_SIZE_2M;

drivers/infiniband/hw/irdma/ctrl.c

1467

page_size = IRDMA_PAGE_SIZE_4K;

drivers/infiniband/hw/irdma/ctrl.c

1491

FIELD_PREP(IRDMA_CQPSQ_STAG_HPAGESIZE, page_size) |

drivers/infiniband/hw/irdma/ctrl.c

1528

enum irdma_page_size page_size;

drivers/infiniband/hw/irdma/ctrl.c

1533

if (info->page_size == 0x40000000)

drivers/infiniband/hw/irdma/ctrl.c

1534

page_size = IRDMA_PAGE_SIZE_1G;

drivers/infiniband/hw/irdma/ctrl.c

1535

else if (info->page_size == 0x200000)

drivers/infiniband/hw/irdma/ctrl.c

1536

page_size = IRDMA_PAGE_SIZE_2M;

drivers/infiniband/hw/irdma/ctrl.c

1537

else if (info->page_size == 0x1000)

drivers/infiniband/hw/irdma/ctrl.c

1538

page_size = IRDMA_PAGE_SIZE_4K;

drivers/infiniband/hw/irdma/ctrl.c

1556

fbo = info->va & (info->page_size - 1);

drivers/infiniband/hw/irdma/ctrl.c

1583

FIELD_PREP(IRDMA_CQPSQ_STAG_HPAGESIZE, page_size) |

drivers/infiniband/hw/irdma/ctrl.c

1701

enum irdma_page_size page_size;

drivers/infiniband/hw/irdma/ctrl.c

1704

if (info->page_size == 0x40000000)

drivers/infiniband/hw/irdma/ctrl.c

1705

page_size = IRDMA_PAGE_SIZE_1G;

drivers/infiniband/hw/irdma/ctrl.c

1706

else if (info->page_size == 0x200000)

drivers/infiniband/hw/irdma/ctrl.c

1707

page_size = IRDMA_PAGE_SIZE_2M;

drivers/infiniband/hw/irdma/ctrl.c

1709

page_size = IRDMA_PAGE_SIZE_4K;

drivers/infiniband/hw/irdma/ctrl.c

1743

FIELD_PREP(IRDMAQPSQ_HPAGESIZE, page_size) |

drivers/infiniband/hw/irdma/type.h

1134

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1147

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1158

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1179

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1211

u32 page_size;

drivers/infiniband/hw/irdma/verbs.c

2784

rdma_umem_for_each_dma_block(region, &biter, iwmr->page_size) {

drivers/infiniband/hw/irdma/verbs.c

2911

pg_size = iwmr->page_size;

drivers/infiniband/hw/irdma/verbs.c

3011

info->page_size = PAGE_SIZE;

drivers/infiniband/hw/irdma/verbs.c

3109

info->page_size = PAGE_SIZE;

drivers/infiniband/hw/irdma/verbs.c

3271

stag_info->page_size = iwmr->page_size;

drivers/infiniband/hw/irdma/verbs.c

3316

iwmr->page_size);

drivers/infiniband/hw/irdma/verbs.c

3376

iwmr->page_size = ib_umem_find_best_pgsz(region, pgsz_bitmap, virt);

drivers/infiniband/hw/irdma/verbs.c

3377

if (unlikely(!iwmr->page_size)) {

drivers/infiniband/hw/irdma/verbs.c

3384

iwmr->page_cnt = ib_umem_num_dma_blocks(region, iwmr->page_size);

drivers/infiniband/hw/irdma/verbs.c

3736

iwmr->page_size = ib_umem_find_best_pgsz(region,

drivers/infiniband/hw/irdma/verbs.c

3739

if (unlikely(!iwmr->page_size)) {

drivers/infiniband/hw/irdma/verbs.c

3746

iwmr->page_cnt = ib_umem_num_dma_blocks(region, iwmr->page_size);

drivers/infiniband/hw/irdma/verbs.c

3901

iwmr->page_size = SZ_4K;

drivers/infiniband/hw/irdma/verbs.c

4188

stag_info.page_size = reg_wr(ib_wr)->mr->page_size;

drivers/infiniband/hw/irdma/verbs.h

117

u64 page_size;

drivers/infiniband/hw/mlx4/mr.c

186

mr->ibmr.page_size = 1U << shift;

drivers/infiniband/hw/mlx4/qp.c

3302

fseg->page_size = cpu_to_be32(ilog2(mr->ibmr.page_size));

drivers/infiniband/hw/mlx5/cq.c

1372

unsigned long page_size;

drivers/infiniband/hw/mlx5/cq.c

1378

page_size = mlx5_umem_find_best_cq_quantized_pgoff(

drivers/infiniband/hw/mlx5/cq.c

1382

if (!page_size) {

drivers/infiniband/hw/mlx5/cq.c

1386

npas = ib_umem_num_dma_blocks(cq->resize_umem, page_size);

drivers/infiniband/hw/mlx5/cq.c

1387

page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/cq.c

725

unsigned long page_size;

drivers/infiniband/hw/mlx5/cq.c

756

page_size = mlx5_umem_find_best_cq_quantized_pgoff(

drivers/infiniband/hw/mlx5/cq.c

759

if (!page_size) {

drivers/infiniband/hw/mlx5/cq.c

770

ncont = ib_umem_num_dma_blocks(cq->buf.umem, page_size);

drivers/infiniband/hw/mlx5/cq.c

775

ib_umem_num_pages(cq->buf.umem), page_size, ncont);

drivers/infiniband/hw/mlx5/cq.c

786

mlx5_ib_populate_pas(cq->buf.umem, page_size, pas, 0);

drivers/infiniband/hw/mlx5/cq.c

790

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/devx.c

2300

unsigned long page_size;

drivers/infiniband/hw/mlx5/devx.c

2311

page_size = ib_umem_find_best_pgoff(umem, pgsz_bitmap, U64_MAX);

drivers/infiniband/hw/mlx5/devx.c

2312

if (!page_size)

drivers/infiniband/hw/mlx5/devx.c

2321

while ((ib_umem_dma_offset(umem, page_size) != 0 ||

drivers/infiniband/hw/mlx5/devx.c

2322

(umem->length % page_size) != 0) &&

drivers/infiniband/hw/mlx5/devx.c

2323

page_size > PAGE_SIZE)

drivers/infiniband/hw/mlx5/devx.c

2324

page_size /= 2;

drivers/infiniband/hw/mlx5/devx.c

2326

return page_size;

drivers/infiniband/hw/mlx5/devx.c

2336

unsigned int page_size;

drivers/infiniband/hw/mlx5/devx.c

2360

page_size = devx_umem_find_best_pgsize(obj->umem, pgsz_bitmap);

drivers/infiniband/hw/mlx5/devx.c

2361

if (!page_size)

drivers/infiniband/hw/mlx5/devx.c

2366

ib_umem_num_dma_blocks(obj->umem, page_size));

drivers/infiniband/hw/mlx5/devx.c

2376

ib_umem_num_dma_blocks(obj->umem, page_size));

drivers/infiniband/hw/mlx5/devx.c

2378

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/devx.c

2380

ib_umem_dma_offset(obj->umem, page_size));

drivers/infiniband/hw/mlx5/devx.c

2385

mlx5_ib_populate_pas(obj->umem, page_size, mtt,

drivers/infiniband/hw/mlx5/mem.c

41

void mlx5_ib_populate_pas(struct ib_umem *umem, size_t page_size, __be64 *pas,

drivers/infiniband/hw/mlx5/mem.c

46

rdma_umem_for_each_dma_block (umem, &biter, page_size) {

drivers/infiniband/hw/mlx5/mem.c

64

unsigned long page_size;

drivers/infiniband/hw/mlx5/mem.c

67

page_size = ib_umem_find_best_pgoff(umem, pgsz_bitmap, pgoff_bitmask);

drivers/infiniband/hw/mlx5/mem.c

68

if (!page_size)

drivers/infiniband/hw/mlx5/mem.c

78

page_offset = ib_umem_dma_offset(umem, page_size);

drivers/infiniband/hw/mlx5/mem.c

79

while (page_offset & ~(u64)(page_offset_mask * (page_size / scale))) {

drivers/infiniband/hw/mlx5/mem.c

80

page_size /= 2;

drivers/infiniband/hw/mlx5/mem.c

81

page_offset = ib_umem_dma_offset(umem, page_size);

drivers/infiniband/hw/mlx5/mem.c

88

if (!(pgsz_bitmap & page_size))

drivers/infiniband/hw/mlx5/mem.c

92

(unsigned long)page_offset / (page_size / scale);

drivers/infiniband/hw/mlx5/mem.c

95

return page_size;

drivers/infiniband/hw/mlx5/mlx5_ib.h

1380

void mlx5_ib_populate_pas(struct ib_umem *umem, size_t page_size, __be64 *pas,

drivers/infiniband/hw/mlx5/mr.c

1097

unsigned long *page_size)

drivers/infiniband/hw/mlx5/mr.c

1113

*page_size =

drivers/infiniband/hw/mlx5/mr.c

1115

if (WARN_ON(!*page_size))

drivers/infiniband/hw/mlx5/mr.c

1118

ib_umem_num_dma_blocks(new_umem, *page_size);

drivers/infiniband/hw/mlx5/mr.c

1123

u64 iova, unsigned long page_size)

drivers/infiniband/hw/mlx5/mr.c

1148

mr->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/mr.c

1253

unsigned long page_size;

drivers/infiniband/hw/mlx5/mr.c

1262

&page_size)) {

drivers/infiniband/hw/mlx5/mr.c

1264

new_umem, iova, page_size);

drivers/infiniband/hw/mlx5/mr.c

173

unsigned long page_size, u16 st_index, u8 ph)

drivers/infiniband/hw/mlx5/mr.c

186

ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/mlx5/mr.c

2063

pi_mr->ibmr.page_size = ibmr->page_size;

drivers/infiniband/hw/mlx5/mr.c

2075

u64 page_mask = ~((u64)ibmr->page_size - 1);

drivers/infiniband/hw/mlx5/mr.c

2089

pi_mr->mmkey.ndescs * ibmr->page_size +

drivers/infiniband/hw/mlx5/mr.c

411

u64 page_size = 1ULL << page_shift;

drivers/infiniband/hw/mlx5/mr.c

415

offset = addr & (page_size - 1);

drivers/infiniband/hw/mlx5/mr.c

416

npages = ALIGN(len + offset, page_size) >> page_shift;

drivers/infiniband/hw/mlx5/mr.c

449

unsigned long page_size;

drivers/infiniband/hw/mlx5/mr.c

452

page_size = mlx5_umem_dmabuf_default_pgsz(umem, iova);

drivers/infiniband/hw/mlx5/mr.c

454

page_size = mlx5_umem_mkc_find_best_pgsz(dev, umem, iova,

drivers/infiniband/hw/mlx5/mr.c

456

if (WARN_ON(!page_size))

drivers/infiniband/hw/mlx5/mr.c

460

page_size, st_index, ph);

drivers/infiniband/hw/mlx5/mr.c

467

mr->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/mr.c

536

unsigned long page_size, bool populate,

drivers/infiniband/hw/mlx5/mr.c

551

if (!page_size)

drivers/infiniband/hw/mlx5/mr.c

559

mr->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/mr.c

564

roundup(ib_umem_num_dma_blocks(umem, page_size), 2);

drivers/infiniband/hw/mlx5/mr.c

59

unsigned long page_size, bool populate,

drivers/infiniband/hw/mlx5/mr.c

762

unsigned long page_size = mlx5_umem_mkc_find_best_pgsz(

drivers/infiniband/hw/mlx5/mr.c

766

mr = reg_create(pd, umem, iova, access_flags, page_size,

drivers/infiniband/hw/mlx5/odp.c

846

unsigned long page_size;

drivers/infiniband/hw/mlx5/odp.c

860

page_size = mlx5_umem_dmabuf_find_best_pgsz(umem_dmabuf, access_mode);

drivers/infiniband/hw/mlx5/odp.c

861

if (!page_size) {

drivers/infiniband/hw/mlx5/odp.c

865

page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/qp.c

1027

page_size = mlx5_umem_find_best_quantized_pgoff(

drivers/infiniband/hw/mlx5/qp.c

1031

if (!page_size) {

drivers/infiniband/hw/mlx5/qp.c

1035

ncont = ib_umem_num_dma_blocks(ubuffer->umem, page_size);

drivers/infiniband/hw/mlx5/qp.c

1051

mlx5_ib_populate_pas(ubuffer->umem, page_size, pas, 0);

drivers/infiniband/hw/mlx5/qp.c

1053

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/qp.c

1367

unsigned long page_size;

drivers/infiniband/hw/mlx5/qp.c

1380

page_size = mlx5_umem_find_best_quantized_pgoff(

drivers/infiniband/hw/mlx5/qp.c

1383

if (!page_size) {

drivers/infiniband/hw/mlx5/qp.c

1390

ib_umem_num_dma_blocks(sq->ubuffer.umem, page_size);

drivers/infiniband/hw/mlx5/qp.c

1420

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/qp.c

1424

mlx5_ib_populate_pas(sq->ubuffer.umem, page_size, pas, 0);

drivers/infiniband/hw/mlx5/qp.c

1462

unsigned long page_size = 0;

drivers/infiniband/hw/mlx5/qp.c

1471

page_size = mlx5_umem_find_best_quantized_pgoff(umem, wq, log_wq_pg_sz,

drivers/infiniband/hw/mlx5/qp.c

1475

if (!page_size)

drivers/infiniband/hw/mlx5/qp.c

1479

sizeof(u64) * ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/mlx5/qp.c

1507

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/qp.c

1511

mlx5_ib_populate_pas(umem, page_size, pas, 0);

drivers/infiniband/hw/mlx5/qp.c

889

unsigned long page_size = 0;

drivers/infiniband/hw/mlx5/qp.c

903

page_size = mlx5_umem_find_best_quantized_pgoff(

drivers/infiniband/hw/mlx5/qp.c

906

if (!page_size) {

drivers/infiniband/hw/mlx5/qp.c

912

rwq->rq_num_pas = ib_umem_num_dma_blocks(rwq->umem, page_size);

drivers/infiniband/hw/mlx5/qp.c

913

rwq->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/qp.c

921

ib_umem_num_pages(rwq->umem), page_size, rwq->rq_num_pas,

drivers/infiniband/hw/mlx5/qp.c

963

unsigned long page_size = 0;

drivers/infiniband/hw/mlx5/srq_cmd.c

100

in->log_page_size = order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT;

drivers/infiniband/hw/mlx5/srq_cmd.c

103

ib_umem_num_dma_blocks(in->umem, page_size) * sizeof(u64)))

drivers/infiniband/hw/mlx5/srq_cmd.c

20

u32 page_size = 1 << log_page_size;

drivers/infiniband/hw/mlx5/srq_cmd.c

22

u32 rq_num_pas = DIV_ROUND_UP(rq_sz_po, page_size);

drivers/infiniband/hw/mlx5/srq_cmd.c

96

unsigned long page_size)

drivers/infiniband/hw/mlx5/srq_cmd.c

98

if (!page_size)

drivers/infiniband/hw/mlx5/wr.c

198

seg->log2_page_size = ilog2(mr->ibmr.page_size);

drivers/infiniband/hw/mthca/mthca_mr.c

463

mpt_entry->page_size = cpu_to_be32(buffer_size_shift - 12);

drivers/infiniband/hw/mthca/mthca_mr.c

52

__be32 page_size;

drivers/infiniband/hw/ocrdma/ocrdma_hw.c

1615

int *num_pages, int *page_size)

drivers/infiniband/hw/ocrdma/ocrdma_hw.c

1633

*page_size = ((OCRDMA_Q_PAGE_BASE_SIZE << i) / OCRDMA_MAX_Q_PAGES);

drivers/infiniband/hw/ocrdma/ocrdma_hw.c

1785

u32 hw_pages, cqe_size, page_size, cqe_count;

drivers/infiniband/hw/ocrdma/ocrdma_hw.c

1819

page_size = cq->len / hw_pages;

drivers/infiniband/hw/ocrdma/ocrdma_hw.c

1820

cmd->cmd.pgsz_pgcnt = (page_size / OCRDMA_MIN_Q_PAGE_SIZE) <<

drivers/infiniband/hw/ocrdma/ocrdma_hw.c

1866

ocrdma_build_q_pages(&cmd->cmd.pa[0], hw_pages, cq->pa, page_size);

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

2051

fast_reg->size_sge = get_encoded_page_size(mr->ibmr.page_size);

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

941

uresp.page_size = PAGE_ALIGN(cq->len);

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

954

status = ocrdma_add_mmap(uctx, uresp.page_addr[0], uresp.page_size);

drivers/infiniband/hw/qedr/main.c

580

u32 page_size;

drivers/infiniband/hw/qedr/main.c

586

page_size = ~qed_attr->page_size_caps + 1;

drivers/infiniband/hw/qedr/main.c

587

if (page_size > PAGE_SIZE) {

drivers/infiniband/hw/qedr/main.c

590

PAGE_SIZE, page_size);

drivers/infiniband/hw/qedr/verbs.c

1521

u32 page_cnt, page_size;

drivers/infiniband/hw/qedr/verbs.c

1557

page_size = PAGE_SIZE;

drivers/infiniband/hw/qedr/verbs.c

1569

page_size = QED_CHAIN_PAGE_SIZE;

drivers/infiniband/hw/qedr/verbs.c

1576

in_params.page_size = page_size;

drivers/infiniband/hw/qedr/verbs.c

3429

ilog2(mr->ibmr.page_size) - 12);

drivers/infiniband/hw/usnic/usnic_uiom.h

70

int page_size;

drivers/infiniband/sw/rxe/rxe_mr.c

291

unsigned int page_size = mr_page_size(mr);

drivers/infiniband/sw/rxe/rxe_mr.c

298

if (!IS_ALIGNED(page_size, PAGE_SIZE) &&

drivers/infiniband/sw/rxe/rxe_mr.c

299

!IS_ALIGNED(PAGE_SIZE, page_size)) {

drivers/infiniband/sw/rxe/rxe_mr.c

301

page_size, PAGE_SIZE);

drivers/infiniband/sw/rxe/rxe_mr.c

307

u32 map_mr_pages = (page_size >> PAGE_SHIFT) * mr->num_buf;

drivers/infiniband/sw/rxe/rxe_mr.c

319

mr->page_shift = ilog2(page_size);

drivers/infiniband/sw/rxe/rxe_mr.c

320

mr->page_mask = ~((u64)page_size - 1);

drivers/infiniband/sw/rxe/rxe_mr.c

61

mr->ibmr.page_size = PAGE_SIZE;

drivers/infiniband/sw/rxe/rxe_verbs.h

370

return mr ? mr->ibmr.page_size : PAGE_SIZE;

drivers/input/mouse/elan_i2c_core.c

130

u32 *signature_address, u16 *page_size)

drivers/input/mouse/elan_i2c_core.c

172

*page_size = 0;

drivers/input/mouse/elan_i2c_core.c

181

*page_size = ETP_FW_PAGE_SIZE_512;

drivers/input/mouse/elan_i2c_core.c

184

*page_size = ETP_FW_PAGE_SIZE_128;

drivers/input/mouse/elan_i2c_core.c

186

*page_size = ETP_FW_PAGE_SIZE;

drivers/input/mouse/elan_i2c_core.c

481

static int elan_write_fw_block(struct elan_tp_data *data, u16 page_size,

drivers/input/mouse/elan_i2c_core.c

488

error = data->ops->write_fw_block(data->client, page_size,

drivers/input/touchscreen/wdt87xx_i2c.c

693

int page_size;

drivers/input/touchscreen/wdt87xx_i2c.c

717

page_size = min_t(u32, size, PG_SIZE);

drivers/input/touchscreen/wdt87xx_i2c.c

718

size -= page_size;

drivers/input/touchscreen/wdt87xx_i2c.c

732

page_size);

drivers/input/touchscreen/wdt87xx_i2c.c

736

start_addr, page_size);

drivers/input/touchscreen/wdt87xx_i2c.c

741

start_addr, page_size);

drivers/input/touchscreen/wdt87xx_i2c.c

745

start_addr, page_size);

drivers/input/touchscreen/wdt87xx_i2c.c

750

wdt87xx_calculate_checksum(data, page_size);

drivers/input/touchscreen/wdt87xx_i2c.c

766

start_addr = start_addr + page_size;

drivers/input/touchscreen/wdt87xx_i2c.c

767

data = data + page_size;

drivers/iommu/iommu-debug-pagealloc.c

102

size_t page_size = iommu_debug_page_size(domain);

drivers/iommu/iommu-debug-pagealloc.c

107

for (off = 0 ; off < size ; off += page_size)

drivers/iommu/iommu-debug-pagealloc.c

115

size_t page_size = iommu_debug_page_size(domain);

drivers/iommu/iommu-debug-pagealloc.c

120

for (off = 0 ; off < size ; off += page_size) {

drivers/iommu/iommufd/io_pagetable.c

581

bitmap->page_size,

drivers/iommu/iommufd/io_pagetable.c

618

if (!bitmap->page_size)

drivers/iommu/iommufd/io_pagetable.c

621

if ((bitmap->iova & (bitmap->page_size - 1)) ||

drivers/iommu/iommufd/io_pagetable.c

622

((last_iova + 1) & (bitmap->page_size - 1)))

drivers/iommu/iommufd/iommufd_test.h

147

__aligned_u64 page_size;

drivers/iommu/iommufd/iova_bitmap.c

244

unsigned long page_size, u64 __user *data)

drivers/iommu/iommufd/iova_bitmap.c

255

mapped->pgshift = __ffs(page_size);

drivers/iommu/iommufd/selftest.c

1182

unsigned int page_size;

drivers/iommu/iommufd/selftest.c

1190

page_size = 1 << __ffs(mock->domain.pgsize_bitmap);

drivers/iommu/iommufd/selftest.c

1191

if (iova % page_size || length % page_size ||

drivers/iommu/iommufd/selftest.c

1192

(uintptr_t)uptr % page_size ||

drivers/iommu/iommufd/selftest.c

1198

for (; length; length -= page_size) {

drivers/iommu/iommufd/selftest.c

1223

iova += page_size;

drivers/iommu/iommufd/selftest.c

1224

uptr += page_size;

drivers/iommu/iommufd/selftest.c

1685

unsigned long page_size, void __user *uptr,

drivers/iommu/iommufd/selftest.c

1695

if (!page_size || !length || iova % page_size || length % page_size ||

drivers/iommu/iommufd/selftest.c

1708

max = length / page_size;

drivers/iommu/iommufd/selftest.c

1724

mock->iommu.ops->set_dirty(&mock->iommu, iova + i * page_size);

drivers/iommu/iommufd/selftest.c

2124

cmd->dirty.page_size,

drivers/iommu/omap-iommu.c

213

u32 page_size = cr->cam & MMU_CAM_PGSZ_MASK;

drivers/iommu/omap-iommu.c

214

u32 mask = get_cam_va_mask(cr->cam & page_size);

drivers/md/dm-vdo/indexer/volume.c

1594

size_t page_size = sizeof(struct delta_index_page) + geometry->bytes_per_page;

drivers/md/dm-vdo/indexer/volume.c

1605

page_size * geometry->index_pages_per_chapter * config->cache_chapters;

drivers/memstick/core/ms_block.c

1005

BUG_ON(sg->length < msb->page_size);

drivers/memstick/core/ms_block.c

1182

p->attr.page_size = be16_to_cpu(p->attr.page_size);

drivers/memstick/core/ms_block.c

1277

page = data_offset / msb->page_size;

drivers/memstick/core/ms_block.c

1278

page_offset = data_offset % msb->page_size;

drivers/memstick/core/ms_block.c

1280

DIV_ROUND_UP(data_size + page_offset, msb->page_size) *

drivers/memstick/core/ms_block.c

1281

msb->page_size;

drivers/memstick/core/ms_block.c

1299

offset += msb->page_size;

drivers/memstick/core/ms_block.c

1563

offset = page * msb->page_size;

drivers/memstick/core/ms_block.c

1641

msb_sg_copy(sg, sg_tmp, ARRAY_SIZE(sg_tmp), offset, msb->page_size);

drivers/memstick/core/ms_block.c

1644

msb->cache + page * msb->page_size, msb->page_size);

drivers/memstick/core/ms_block.c

1665

offset, msb->page_size);

drivers/memstick/core/ms_block.c

1667

msb->cache + msb->page_size * page,

drivers/memstick/core/ms_block.c

1668

msb->page_size);

drivers/memstick/core/ms_block.c

1726

msb->page_size = sizeof(struct ms_boot_page);

drivers/memstick/core/ms_block.c

1737

msb->page_size = boot_block->attr.page_size;

drivers/memstick/core/ms_block.c

1740

msb->block_size = msb->page_size * msb->pages_in_block;

drivers/memstick/core/ms_block.c

1742

if ((size_t)msb->page_size > PAGE_SIZE) {

drivers/memstick/core/ms_block.c

1744

dbg("device page %d size isn't supported", msb->page_size);

drivers/memstick/core/ms_block.c

1773

dbg("Page size = %d bytes", msb->page_size);

drivers/memstick/core/ms_block.c

1842

offset += msb->page_size;

drivers/memstick/core/ms_block.c

1843

*sucessfuly_written += msb->page_size;

drivers/memstick/core/ms_block.c

1867

offset += msb->page_size;

drivers/memstick/core/ms_block.c

1868

*sucessfuly_read += msb->page_size;

drivers/memstick/core/ms_block.c

1914

sector_div(lba, msb->page_size / 512);

drivers/memstick/core/ms_block.c

2085

.logical_block_size = msb->page_size,

drivers/memstick/core/ms_block.c

2088

.max_segment_size = MS_BLOCK_MAX_PAGES * msb->page_size,

drivers/memstick/core/ms_block.c

2116

capacity *= (msb->page_size / 512);

drivers/memstick/core/ms_block.c

435

msb->page_size);

drivers/memstick/core/ms_block.c

443

msb->current_sg_offset += msb->page_size;

drivers/memstick/core/ms_block.c

454

msb->current_sg_offset += msb->page_size;

drivers/memstick/core/ms_block.c

561

msb->page_size) < msb->page_size)

drivers/memstick/core/ms_block.c

571

msb->current_sg_offset += msb->page_size;

drivers/memstick/core/ms_block.c

867

size_t len = msb->page_size;

drivers/memstick/core/ms_block.c

987

NULL, &sg, page * msb->page_size);

drivers/memstick/core/ms_block.h

112

unsigned short page_size;

drivers/memstick/core/ms_block.h

169

unsigned short page_size;

drivers/memstick/core/ms_block.h

79

unsigned short page_size;

drivers/memstick/core/mspro_block.c

1003

attr_len = (((addr + s_attr->size) / msb->page_size)

drivers/memstick/core/mspro_block.c

1004

+ 1 ) * msb->page_size - attr_offset;

drivers/memstick/core/mspro_block.c

1030

memcpy(s_attr->data, buffer + addr % msb->page_size,

drivers/memstick/core/mspro_block.c

1085

msb->page_size = 512;

drivers/memstick/core/mspro_block.c

1103

.logical_block_size = msb->page_size,

drivers/memstick/core/mspro_block.c

1106

.max_segment_size = MSPRO_BLOCK_MAX_PAGES * msb->page_size,

drivers/memstick/core/mspro_block.c

1130

msb->page_size = be16_to_cpu(sys_info->unit_size);

drivers/memstick/core/mspro_block.c

1159

capacity *= msb->page_size >> 9;

drivers/memstick/core/mspro_block.c

143

unsigned short page_size;

drivers/memstick/core/mspro_block.c

298

rc += sysfs_emit_at(buffer, rc, "page size: %x\n", be16_to_cpu(x_sys->page_size));

drivers/memstick/core/mspro_block.c

536

/ msb->page_size)) {

drivers/memstick/core/mspro_block.c

560

t_offset += msb->current_page * msb->page_size;

drivers/memstick/core/mspro_block.c

564

msb->page_size, offset_in_page(t_offset));

drivers/memstick/core/mspro_block.c

603

.data_count = cpu_to_be16((uint16_t)(length / msb->page_size)),

drivers/memstick/core/mspro_block.c

609

do_div(offset, msb->page_size);

drivers/memstick/core/mspro_block.c

683

/ msb->page_size;

drivers/memstick/core/mspro_block.c

688

t_len *= msb->page_size;

drivers/memstick/core/mspro_block.c

74

__be16 page_size;

drivers/memstick/core/mspro_block.c

906

unsigned int addr, attr_offset = 0, attr_len = msb->page_size;

drivers/memstick/core/mspro_block.c

908

attr = kmalloc(msb->page_size, GFP_KERNEL);

drivers/memstick/core/mspro_block.c

912

sg_init_one(&msb->req_sg[0], attr, msb->page_size);

drivers/memstick/core/mspro_block.c

991

if (((addr / msb->page_size) == (attr_offset / msb->page_size))

drivers/memstick/core/mspro_block.c

992

&& (((addr + s_attr->size - 1) / msb->page_size)

drivers/memstick/core/mspro_block.c

993

== (attr_offset / msb->page_size))) {

drivers/memstick/core/mspro_block.c

994

memcpy(s_attr->data, buffer + addr % msb->page_size,

drivers/memstick/core/mspro_block.c

999

attr_offset = (addr / msb->page_size) * msb->page_size;

drivers/misc/eeprom/at24.c

399

next_page = roundup(offset + 1, at24->page_size);

drivers/misc/eeprom/at24.c

599

u32 byte_len, page_size, flags, addrw;

drivers/misc/eeprom/at24.c

619

err = device_property_read_u32(dev, "pagesize", &page_size);

drivers/misc/eeprom/at24.c

626

page_size = 1;

drivers/misc/eeprom/at24.c

657

page_size = 1;

drivers/misc/eeprom/at24.c

659

if (!page_size)

drivers/misc/eeprom/at24.c

662

if (!is_power_of_2(page_size))

drivers/misc/eeprom/at24.c

693

at24->page_size = page_size;

drivers/misc/eeprom/at24.c

708

page_size, at24_io_limit);

drivers/misc/eeprom/at24.c

81

u16 page_size;

drivers/misc/eeprom/at25.c

253

buf_size = at25->chip.page_size;

drivers/misc/eeprom/at25.c

356

chip->page_size = val;

drivers/misc/eeprom/at25.c

464

chip->page_size = PAGE_SIZE;

drivers/misc/eeprom/at25.c

563

at25->chip.page_size);

drivers/misc/eeprom/m24lr.c

101

.page_size = 4,

drivers/misc/eeprom/m24lr.c

250

n = min_t(unsigned int, size, m24lr->page_size);

drivers/misc/eeprom/m24lr.c

251

next_sector = roundup(offset + 1, m24lr->page_size);

drivers/misc/eeprom/m24lr.c

268

n = min_t(unsigned int, size, m24lr->page_size);

drivers/misc/eeprom/m24lr.c

38

unsigned int page_size;

drivers/misc/eeprom/m24lr.c

542

m24lr->page_size = chip->page_size;

drivers/misc/eeprom/m24lr.c

59

unsigned int page_size;

drivers/misc/eeprom/m24lr.c

87

.page_size = 4,

drivers/misc/eeprom/m24lr.c

94

.page_size = 4,

drivers/misc/lkdtm/powerpc.c

10

static void insert_slb_entry(unsigned long p, int ssize, int page_size)

drivers/misc/lkdtm/powerpc.c

14

flags = SLB_VSID_KERNEL | mmu_psize_defs[page_size].sllp;

drivers/misc/ocxl/link.c

500

unsigned long addr, pid, page_size = PAGE_SIZE;

drivers/misc/ocxl/link.c

506

for (addr = start; addr < end; addr += page_size)

drivers/misc/ocxl/link.c

507

pnv_ocxl_tlb_invalidate(link->arva, pid, addr, page_size);

drivers/misc/vmw_balloon.c

1035

enum vmballoon_page_size_type page_size,

drivers/misc/vmw_balloon.c

1042

if (page_size == VMW_BALLOON_4K_PAGE) {

drivers/misc/vmw_balloon.c

1079

order = vmballoon_page_order(ctl->page_size);

drivers/misc/vmw_balloon.c

1102

.page_size = b->max_page_size,

drivers/misc/vmw_balloon.c

1113

page_in_frames = vmballoon_page_in_frames(ctl.page_size);

drivers/misc/vmw_balloon.c

1137

ctl.page_size);

drivers/misc/vmw_balloon.c

1145

if (ctl.page_size == VMW_BALLOON_4K_PAGE)

drivers/misc/vmw_balloon.c

1153

ctl.page_size--;

drivers/misc/vmw_balloon.c

1167

vmballoon_release_page_list(&ctl.prealloc_pages, NULL, ctl.page_size);

drivers/misc/vmw_balloon.c

1190

.page_size = VMW_BALLOON_4K_PAGE,

drivers/misc/vmw_balloon.c

1201

page_in_frames = vmballoon_page_in_frames(ctl.page_size);

drivers/misc/vmw_balloon.c

1230

ctl.page_size, to_deflate_pages);

drivers/misc/vmw_balloon.c

1262

ctl.page_size, ctl.n_pages);

drivers/misc/vmw_balloon.c

1266

ctl.page_size);

drivers/misc/vmw_balloon.c

1271

ctl.page_size);

drivers/misc/vmw_balloon.c

1275

if (ctl.page_size == b->max_page_size)

drivers/misc/vmw_balloon.c

1277

ctl.page_size++;

drivers/misc/vmw_balloon.c

245

enum vmballoon_page_size_type page_size;

drivers/misc/vmw_balloon.c

570

unsigned int vmballoon_page_order(enum vmballoon_page_size_type page_size)

drivers/misc/vmw_balloon.c

572

return page_size == VMW_BALLOON_2M_PAGE ? VMW_BALLOON_2M_ORDER : 0;

drivers/misc/vmw_balloon.c

582

vmballoon_page_in_frames(enum vmballoon_page_size_type page_size)

drivers/misc/vmw_balloon.c

584

return 1 << vmballoon_page_order(page_size);

drivers/misc/vmw_balloon.c

594

enum vmballoon_page_size_type page_size)

drivers/misc/vmw_balloon.c

598

for (i = 0; i < vmballoon_page_in_frames(page_size); i++)

drivers/misc/vmw_balloon.c

609

enum vmballoon_page_size_type page_size)

drivers/misc/vmw_balloon.c

613

for (i = 0; i < vmballoon_page_in_frames(page_size); i++)

drivers/misc/vmw_balloon.c

673

if (ctl->page_size == VMW_BALLOON_2M_PAGE)

drivers/misc/vmw_balloon.c

680

ctl->page_size);

drivers/misc/vmw_balloon.c

691

ctl->page_size);

drivers/misc/vmw_balloon.c

709

enum vmballoon_page_size_type page_size,

drivers/misc/vmw_balloon.c

718

vmballoon_page_size_names[page_size]);

drivers/misc/vmw_balloon.c

722

page_size);

drivers/misc/vmw_balloon.c

778

enum vmballoon_page_size_type page_size,

drivers/misc/vmw_balloon.c

787

cmd = page_size == VMW_BALLOON_2M_PAGE ?

drivers/misc/vmw_balloon.c

791

cmd = page_size == VMW_BALLOON_2M_PAGE ?

drivers/misc/vmw_balloon.c

866

batch_status = vmballoon_lock_op(b, ctl->n_pages, ctl->page_size,

drivers/misc/vmw_balloon.c

887

if (!vmballoon_handle_one_result(b, page, ctl->page_size,

drivers/misc/vmw_balloon.c

916

enum vmballoon_page_size_type page_size)

drivers/misc/vmw_balloon.c

922

__free_pages(page, vmballoon_page_order(page_size));

drivers/misc/vmw_balloon.c

938

ctl->page_size);

drivers/misc/vmw_balloon.c

941

ctl->page_size);

drivers/misc/vmw_balloon.c

993

enum vmballoon_page_size_type page_size)

drivers/misc/vmw_balloon.c

997

if (page_size == VMW_BALLOON_4K_PAGE) {

drivers/mtd/devices/mchp48l640.c

225

size_t page_sz = flash->caps->page_size;

drivers/mtd/devices/mchp48l640.c

283

size_t page_sz = flash->caps->page_size;

drivers/mtd/devices/mchp48l640.c

30

unsigned int page_size;

drivers/mtd/devices/mchp48l640.c

303

.page_size = 32,

drivers/mtd/devices/mchp48l640.c

309

.page_size = 256,

drivers/mtd/devices/mchp48l640.c

346

flash->mtd.writesize = flash->caps->page_size;

drivers/mtd/devices/mtd_dataflash.c

160

unsigned blocksize = priv->page_size << 3;

drivers/mtd/devices/mtd_dataflash.c

167

div_u64_rem(instr->len, priv->page_size, &rem);

drivers/mtd/devices/mtd_dataflash.c

170

div_u64_rem(instr->addr, priv->page_size, &rem);

drivers/mtd/devices/mtd_dataflash.c

189

pageaddr = div_u64(instr->addr, priv->page_size);

drivers/mtd/devices/mtd_dataflash.c

219

instr->addr += priv->page_size;

drivers/mtd/devices/mtd_dataflash.c

220

instr->len -= priv->page_size;

drivers/mtd/devices/mtd_dataflash.c

249

addr = (((unsigned)from / priv->page_size) << priv->page_offset)

drivers/mtd/devices/mtd_dataflash.c

250

+ ((unsigned)from % priv->page_size);

drivers/mtd/devices/mtd_dataflash.c

321

pageaddr = ((unsigned)to / priv->page_size);

drivers/mtd/devices/mtd_dataflash.c

322

offset = ((unsigned)to % priv->page_size);

drivers/mtd/devices/mtd_dataflash.c

323

if (offset + len > priv->page_size)

drivers/mtd/devices/mtd_dataflash.c

324

writelen = priv->page_size - offset;

drivers/mtd/devices/mtd_dataflash.c

352

if (writelen != priv->page_size) {

drivers/mtd/devices/mtd_dataflash.c

428

if (remaining > priv->page_size)

drivers/mtd/devices/mtd_dataflash.c

429

writelen = priv->page_size;

drivers/mtd/devices/mtd_dataflash.c

636

priv->page_size = pagesize;

drivers/mtd/devices/mtd_dataflash.c

90

unsigned int page_size; /* of bytes per page */

drivers/mtd/devices/spear_smi.c

202

u32 page_size;

drivers/mtd/devices/spear_smi.c

680

u32 page_offset, page_size;

drivers/mtd/devices/spear_smi.c

695

page_offset = (u32)to % flash->page_size;

drivers/mtd/devices/spear_smi.c

698

if (page_offset + len <= flash->page_size) {

drivers/mtd/devices/spear_smi.c

706

page_size = flash->page_size - page_offset;

drivers/mtd/devices/spear_smi.c

709

page_size);

drivers/mtd/devices/spear_smi.c

713

*retlen += page_size;

drivers/mtd/devices/spear_smi.c

716

for (i = page_size; i < len; i += page_size) {

drivers/mtd/devices/spear_smi.c

717

page_size = len - i;

drivers/mtd/devices/spear_smi.c

718

if (page_size > flash->page_size)

drivers/mtd/devices/spear_smi.c

719

page_size = flash->page_size;

drivers/mtd/devices/spear_smi.c

722

buf + i, page_size);

drivers/mtd/devices/spear_smi.c

726

*retlen += page_size;

drivers/mtd/devices/spear_smi.c

895

flash->page_size = flash_devices[flash_index].pagesize;

drivers/mtd/devices/spear_smi.c

896

flash->mtd.writebufsize = flash->page_size;

drivers/mtd/devices/sst25l.c

375

flash->mtd.writesize = flash_info->page_size;

drivers/mtd/devices/sst25l.c

376

flash->mtd.writebufsize = flash_info->page_size;

drivers/mtd/devices/sst25l.c

377

flash->mtd.size = flash_info->page_size * flash_info->nr_pages;

drivers/mtd/devices/sst25l.c

55

unsigned page_size;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1294

int sectors = cfg->page_size / (512 << cfg->sector_size_1k);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1312

int sectors = cfg->page_size / (512 << cfg->sector_size_1k);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1325

if (cfg->page_size > 512) {

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1352

int sectors = cfg->page_size / (512 << cfg->sector_size_1k);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1370

int sectors = cfg->page_size / (512 << cfg->sector_size_1k);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1429

int sectors = p->page_size / (512 << p->sector_size_1k);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

1447

if (p->page_size == 512)

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2763

u8 block_size = 0, page_size = 0, device_size = 0;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2794

if (ctrl->page_sizes[i] == cfg->page_size) {

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2795

page_size = i;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2800

cfg->page_size);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2804

page_size = ffs(cfg->page_size) - ffs(BRCMNAND_MIN_PAGESIZE);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2807

if (cfg->page_size < BRCMNAND_MIN_PAGESIZE || (ctrl->max_page_size &&

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2808

cfg->page_size > ctrl->max_page_size)) {

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2809

dev_warn(ctrl->dev, "invalid page size %u\n", cfg->page_size);

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2826

tmp |= (page_size << ctrl->page_size_shift) |

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2831

tmp = (page_size << CFG_EXT_PAGE_SIZE_SHIFT) |

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2860

cfg->page_size >= 1024 ? cfg->page_size >> 10 : cfg->page_size,

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2861

cfg->page_size >= 1024 ? "KiB" : "B",

drivers/mtd/nand/raw/brcmnand/brcmnand.c

2940

cfg->page_size = mtd->writesize;

drivers/mtd/nand/raw/brcmnand/brcmnand.c

322

unsigned int page_size;

drivers/mtd/nand/raw/fsl_elbc_nand.c

162

if (priv->page_size) {

drivers/mtd/nand/raw/fsl_elbc_nand.c

189

elbc_fcm_ctrl->index += priv->page_size ? 2048 : 512;

drivers/mtd/nand/raw/fsl_elbc_nand.c

281

if (priv->page_size) {

drivers/mtd/nand/raw/fsl_elbc_nand.c

43

int page_size; /* NAND page size (0=512, 1=2048) */

drivers/mtd/nand/raw/fsl_elbc_nand.c

442

if (priv->page_size) {

drivers/mtd/nand/raw/fsl_elbc_nand.c

821

priv->page_size = 0;

drivers/mtd/nand/raw/fsl_elbc_nand.c

824

priv->page_size = 1;

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1103

oobregion->length = geo->page_size - mtd->writesize;

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1119

if (geo->page_size < mtd->writesize + mtd->oobsize) {

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1120

oobregion->offset = geo->page_size - mtd->writesize;

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1539

BF_BCH_FLASH0LAYOUT1_PAGE_SIZE(geo->page_size) |

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1557

ret = nand_read_page_op(chip, page, 0, buf, geo->page_size);

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1593

int meta, n, page_size;

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1649

page_size = meta + ecc_parity_size

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1652

page_size = meta + (size + ecc_parity_size) * n;

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1664

this->bch_flashlayout1 = BF_BCH_FLASH0LAYOUT1_PAGE_SIZE(page_size) |

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1671

ret = nand_read_page_op(chip, page, col, buf, page_size);

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1676

page, offs, len, col, first, n, page_size);

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

1708

return nand_prog_page_op(chip, page, 0, buf, nfc_geo->page_size);

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

234

geo->page_size,

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

401

geo->page_size = mtd->writesize + geo->metadata_size +

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

522

geo->page_size = mtd->writesize + geo->metadata_size +

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

566

geo->page_size,

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.c

622

geo->page_size = mtd->writesize + geo->metadata_size +

drivers/mtd/nand/raw/gpmi-nand/gpmi-nand.h

51

unsigned int page_size;

drivers/mtd/nand/raw/meson_nand.c

64

#define CMDRWGEN(cmd_dir, ran, bch, short_mode, page_size, pages) \

drivers/mtd/nand/raw/meson_nand.c

70

(((page_size) & 0x7f) << 6) | \

drivers/mtd/nand/raw/qcom_nandc.c

2124

&boot_partition->page_size);

drivers/mtd/nand/raw/qcom_nandc.c

2131

if (boot_partition->page_size % mtd->writesize) {

drivers/mtd/nand/raw/qcom_nandc.c

2138

boot_partition->page_size /= mtd->writesize;

drivers/mtd/nand/raw/qcom_nandc.c

30

u32 page_size;

drivers/mtd/nand/raw/qcom_nandc.c

847

end = start + boot_partition->page_size;

drivers/mtd/nand/raw/qcom_nandc.c

861

end = start + boot_partition->page_size;

drivers/mtd/nand/raw/sh_flctl.c

1000

flctl->page_size = 0;

drivers/mtd/nand/raw/sh_flctl.c

1014

flctl->page_size = 1;

drivers/mtd/nand/raw/sh_flctl.c

233

if (flctl->page_size) {

drivers/mtd/nand/raw/sh_flctl.c

345

if (flctl->page_size)

drivers/mtd/nand/raw/sh_flctl.c

545

if (flctl->page_size)

drivers/mtd/nand/raw/sh_flctl.c

627

page_sectors = flctl->page_size ? 4 : 1;

drivers/mtd/nand/raw/sh_flctl.c

673

int page_sectors = flctl->page_size ? 4 : 1;

drivers/mtd/nand/raw/sh_flctl.c

697

page_sectors = flctl->page_size ? 4 : 1;

drivers/mtd/nand/raw/sh_flctl.c

723

page_sectors = flctl->page_size ? 4 : 1;

drivers/mtd/nand/raw/sh_flctl.c

760

if (flctl->page_size)

drivers/mtd/nand/raw/sh_flctl.c

781

if (flctl->page_size) {

drivers/mtd/nand/raw/sh_flctl.c

796

if (flctl->page_size)

drivers/mtd/nand/raw/sh_flctl.c

836

if (!flctl->page_size) {

drivers/mtd/nand/raw/sh_flctl.c

855

if (!flctl->page_size) {

drivers/mtd/spi-nor/core.c

2214

tmp_buf = kmalloc(nor->params->page_size, GFP_KERNEL);

drivers/mtd/spi-nor/core.c

2218

memset(tmp_buf, 0xff, nor->params->page_size);

drivers/mtd/spi-nor/core.c

2269

u32 page_size = nor->params->page_size;

drivers/mtd/spi-nor/core.c

2280

size_t page_offset = addr & (page_size - 1);

drivers/mtd/spi-nor/core.c

2282

size_t page_remain = min_t(size_t, page_size - page_offset, len - i);

drivers/mtd/spi-nor/core.c

3119

params->page_size = info->page_size ?: SPI_NOR_DEFAULT_PAGE_SIZE;

drivers/mtd/spi-nor/core.c

3211

if (WARN_ON(!is_power_of_2(nor->params->page_size)))

drivers/mtd/spi-nor/core.c

3595

mtd->writebufsize = nor->params->page_size;

drivers/mtd/spi-nor/core.c

3831

if (nor->params->page_size > PAGE_SIZE) {

drivers/mtd/spi-nor/core.c

3832

nor->bouncebuf_size = nor->params->page_size;

drivers/mtd/spi-nor/core.h

389

u32 page_size;

drivers/mtd/spi-nor/core.h

531

u16 page_size;

drivers/mtd/spi-nor/debugfs.c

98

seq_printf(s, "page size\t%u\n", params->page_size);

drivers/mtd/spi-nor/sfdp.c

562

params->page_size = 1U << val;

drivers/mtd/spi-nor/spansion.c

515

params->page_size = 256;

drivers/mtd/spi-nor/spansion.c

527

params->page_size = 512;

drivers/mtd/spi-nor/spansion.c

788

nor->params->page_size = 256;

drivers/net/ethernet/atheros/atl1e/atl1e.h

413

u32 page_size; /* bytes length of rxf page */

drivers/net/ethernet/atheros/atl1e/atl1e_main.c

1480

if (rx_page->read_offset >= rx_ring->page_size) {

drivers/net/ethernet/atheros/atl1e/atl1e_main.c

725

rx_ring->real_page_size = adapter->rx_ring.page_size

drivers/net/ethernet/atheros/atl1e/atl1e_main.c

924

AT_WRITE_REG(hw, REG_HOST_RXFPAGE_SIZE, rx_ring->page_size);

drivers/net/ethernet/atheros/atl1e/atl1e_param.c

212

adapter->rx_ring.page_size = (u32)val * 1024;

drivers/net/ethernet/atheros/atl1e/atl1e_param.c

214

adapter->rx_ring.page_size = (u32)opt.def * 1024;

drivers/net/ethernet/broadcom/bnge/bnge_hwrm_lib.c

1331

req->page_size = BNGE_PAGE_SHIFT;

drivers/net/ethernet/broadcom/bnge/bnge_netdev.c

582

rmem->page_size = HW_CMPD_RING_SIZE;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

102

rmem->page_size);

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

133

rmem->page_size = BNGE_PAGE_SIZE;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

443

rmem->page_size = HW_CMPD_RING_SIZE;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

455

rmem->page_size = HW_RXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

464

rmem->page_size = HW_RXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

475

rmem->page_size = HW_TXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

48

dma_free_coherent(&pdev->dev, rmem->page_size,

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

58

pg_tbl_size = rmem->page_size;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

82

pg_tbl_size = rmem->page_size;

drivers/net/ethernet/broadcom/bnge/bnge_rmem.c

94

rmem->page_size,

drivers/net/ethernet/broadcom/bnge/bnge_rmem.h

18

int page_size;

drivers/net/ethernet/broadcom/bnx2.c

251

.page_size = BCM5709_FLASH_PAGE_SIZE,

drivers/net/ethernet/broadcom/bnx2.c

4255

offset = ((offset / bp->flash_info->page_size) <<

drivers/net/ethernet/broadcom/bnx2.c

4257

(offset % bp->flash_info->page_size);

drivers/net/ethernet/broadcom/bnx2.c

4301

offset = ((offset / bp->flash_info->page_size) <<

drivers/net/ethernet/broadcom/bnx2.c

4303

(offset % bp->flash_info->page_size);

drivers/net/ethernet/broadcom/bnx2.c

4586

page_start -= (page_start % bp->flash_info->page_size);

drivers/net/ethernet/broadcom/bnx2.c

4588

page_end = page_start + bp->flash_info->page_size;

drivers/net/ethernet/broadcom/bnx2.c

4608

for (j = 0; j < bp->flash_info->page_size; j += 4) {

drivers/net/ethernet/broadcom/bnx2.c

4609

if (j == (bp->flash_info->page_size - 4)) {

drivers/net/ethernet/broadcom/bnx2.h

6706

u32 page_size;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_init.h

509

u32 page_size;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_init_ops.h

650

ilt_cli->page_size, memop);

drivers/net/ethernet/broadcom/bnx2x/bnx2x_init_ops.h

826

REG_WR(bp, psz_reg, ILOG2(ilt_cli->page_size >> 12));

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8651

ilt_client->page_size = CDU_ILT_PAGE_SZ;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8663

ilt_client->page_size,

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8665

ilog2(ilt_client->page_size >> 12));

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8671

ilt_client->page_size = QM_ILT_PAGE_SZ;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8685

ilt_client->page_size,

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8687

ilog2(ilt_client->page_size >> 12));

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8694

ilt_client->page_size = SRC_ILT_PAGE_SZ;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8704

ilt_client->page_size,

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8706

ilog2(ilt_client->page_size >> 12));

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8711

ilt_client->page_size = TM_ILT_PAGE_SZ;

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8721

ilt_client->page_size,

drivers/net/ethernet/broadcom/bnx2x/bnx2x_main.c

8723

ilog2(ilt_client->page_size >> 12));

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16324

WARN_ON(dst_rmem->page_size != src_rmem->page_size);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

16349

WARN_ON(dst_rmem->page_size != src_rmem->page_size);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3665

head_page = head / rmem->page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3666

source_offset = head % rmem->page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3671

max_bytes = (rmem->nr_pages - start_idx) * rmem->page_size -

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3677

len = min((size_t)(rmem->page_size - source_offset), rem_len);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3699

dma_free_coherent(&pdev->dev, rmem->page_size,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3709

pg_tbl_size = rmem->page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3732

pg_tbl_size = rmem->page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3744

rmem->page_size,

drivers/net/ethernet/broadcom/bnxt/bnxt.c

3752

rmem->page_size);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

4272

rmem->page_size = HW_CMPD_RING_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

4368

rmem->page_size = HW_RXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

4377

rmem->page_size = HW_RXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

4438

rmem->page_size = HW_CMPD_RING_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

4453

rmem->page_size = HW_RXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

4462

rmem->page_size = HW_RXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

4473

rmem->page_size = HW_TXBD_RING_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

7238

req->page_size = BNXT_PAGE_SHIFT;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

7698

int i, size = ring->ring_mem.page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9120

rmem->page_size = BNXT_PAGE_SIZE;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9196

int page_size = rmem->page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9200

tail %= nr_pages * page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9203

int i = head / (page_size * MAX_CTX_PAGES);

drivers/net/ethernet/broadcom/bnxt/bnxt.c

9213

if (head >= nr_pages * page_size)

drivers/net/ethernet/broadcom/bnxt/bnxt.h

925

int page_size;

drivers/net/ethernet/broadcom/bnxt/bnxt_coredump.c

537

data_len = rmem->page_size;

drivers/net/ethernet/brocade/bna/bna_tx_rx.c

1298

(bfi_q)->page_sz = htons((u16)(bna_qpt)->page_size);\

drivers/net/ethernet/brocade/bna/bna_tx_rx.c

1856

u32 page_size,

drivers/net/ethernet/brocade/bna/bna_tx_rx.c

1870

rxq->qpt.page_size = page_size;

drivers/net/ethernet/brocade/bna/bna_tx_rx.c

1894

u32 page_size,

drivers/net/ethernet/brocade/bna/bna_tx_rx.c

1908

rxp->cq.qpt.page_size = page_size;

drivers/net/ethernet/brocade/bna/bna_tx_rx.c

3161

bna_txq_qpt_setup(struct bna_txq *txq, int page_count, int page_size,

drivers/net/ethernet/brocade/bna/bna_tx_rx.c

3175

txq->qpt.page_size = page_size;

drivers/net/ethernet/brocade/bna/bna_types.h

301

u32 page_size;

drivers/net/ethernet/chelsio/cxgb3/cxgb3_ctl_defs.h

178

unsigned int page_size; /* Page size, should be a power of 2 */

drivers/net/ethernet/chelsio/cxgb3/cxgb3_offload.c

451

rx_page_info->page_size = tp->rx_pg_size;

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

1966

int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,

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

4028

size_t page_size;

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

4058

page_size = HMA_PAGE_SIZE;

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

4068

sgt->orig_nents = (hma_size << 20) / (page_size << page_order);

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

4087

sg_set_page(iter, newpage, page_size << page_order, 0);

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

4144

((page_size << page_order) >> 12));

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

7264

int t4_fixup_host_params(struct adapter *adap, unsigned int page_size,

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

7267

unsigned int page_shift = fls(page_size) - 1;

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

7391

t4_write_reg(adap, SGE_FL_BUFFER_SIZE0_A, page_size);

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

9252

unsigned int page_shift, page_size, qpp_shift, qpp_mask;

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

9263

page_size = 1 << page_shift;

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

9298

bar2_qinferred = (bar2_qid_offset < page_size);

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

772

unsigned int page_shift, page_size, qpp_shift, qpp_mask;

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

784

page_size = 1 << page_shift;

drivers/net/ethernet/chelsio/cxgb4vf/t4vf_hw.c

819

bar2_qinferred = (bar2_qid_offset < page_size);

drivers/net/ethernet/emulex/benet/be_cmds.c

1193

req->page_size = 1; /* 1 for 4K */

drivers/net/ethernet/emulex/benet/be_cmds.h

493

u8 page_size;

drivers/net/ethernet/google/gve/gve_adminq.c

1180

.page_size = cpu_to_be64(PAGE_SIZE),

drivers/net/ethernet/google/gve/gve_adminq.h

305

__be64 page_size;

drivers/net/ethernet/hisilicon/hibmcge/hbg_common.h

62

u32 page_size;

drivers/net/ethernet/hisilicon/hibmcge/hbg_txrx.c

104

buffer->page_size = len;

drivers/net/ethernet/hisilicon/hibmcge/hbg_txrx.c

456

buffer->page_size, DMA_FROM_DEVICE);

drivers/net/ethernet/hisilicon/hibmcge/hbg_txrx.c

470

buffer->skb = napi_build_skb(buffer->page_addr, buffer->page_size);

drivers/net/ethernet/hisilicon/hibmcge/hbg_txrx.c

85

buffer->page_size = 0;

drivers/net/ethernet/huawei/hinic/hinic_hw_cmdq.c

76

#define CMDQ_PFN(addr, page_size) ((addr) >> (ilog2(page_size)))

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

62

#define PAGE_IN_4K(page_size) ((page_size) >> 12)

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

63

#define EQ_SET_HW_PAGE_SIZE_VAL(eq) (ilog2(PAGE_IN_4K((eq)->page_size)))

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

650

eq->page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

680

dma_free_coherent(&pdev->dev, eq->page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

702

dma_free_coherent(&pdev->dev, eq->page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

723

enum hinic_eq_type type, int q_id, u32 q_len, u32 page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

733

eq->page_size = page_size;

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

751

eq->num_pages = GET_EQ_NUM_PAGES(eq, page_size);

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

752

eq->num_elem_in_pg = GET_EQ_NUM_ELEMS_IN_PG(eq, page_size);

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

861

int num_aeqs, u32 q_len, u32 page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

876

page_size, msix_entries[q_id]);

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

919

int num_ceqs, u32 q_len, u32 page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c

931

page_size, msix_entries[q_id]);

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.h

179

u32 page_size;

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.h

247

int num_aeqs, u32 q_len, u32 page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.h

253

int num_ceqs, u32 q_len, u32 page_size,

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

492

u32 page_size)

drivers/net/ethernet/huawei/hinic/hinic_hw_io.c

503

page_size_info.page_size = HINIC_PAGE_SIZE_HW(page_size);

drivers/net/ethernet/huawei/hinic/hinic_hw_io.h

101

u8 page_size;

drivers/net/ethernet/huawei/hinic/hinic_hw_io.h

107

u32 page_size);

drivers/net/ethernet/huawei/hinic/hinic_hw_mbox.c

1340

if (((1U << page_size_info->page_size) * SZ_4K) !=

drivers/net/ethernet/huawei/hinic3/hinic3_eqs.c

406

page_size_val = ilog2(qpages->page_size / HINIC3_MIN_PAGE_SIZE);

drivers/net/ethernet/huawei/hinic3/hinic3_eqs.c

513

u32 max_pages, min_page_size, page_size, total_size;

drivers/net/ethernet/huawei/hinic3/hinic3_eqs.c

524

page_size = min_page_size;

drivers/net/ethernet/huawei/hinic3/hinic3_eqs.c

526

page_size = total_size / max_pages;

drivers/net/ethernet/huawei/hinic3/hinic3_eqs.c

528

hinic3_queue_pages_init(&eq->qpages, eq->eq_len, page_size, elem_size);

drivers/net/ethernet/huawei/hinic3/hinic3_hw_comm.c

244

u32 page_size)

drivers/net/ethernet/huawei/hinic3/hinic3_hw_comm.c

251

page_size_info.page_size = ilog2(page_size / HINIC3_MIN_PAGE_SIZE);

drivers/net/ethernet/huawei/hinic3/hinic3_hw_comm.h

42

u32 page_size);

drivers/net/ethernet/huawei/hinic3/hinic3_hw_intf.h

225

u8 page_size;

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.c

10

u32 page_size, u32 elem_size)

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.c

14

elem_per_page = min(page_size / elem_size, q_depth);

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.c

17

qpages->page_size = page_size;

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.c

52

align = qpages->page_size;

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.c

56

qpages->page_size,

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.h

17

u32 page_size;

drivers/net/ethernet/huawei/hinic3/hinic3_queue_common.h

25

u32 page_size, u32 elem_size);

drivers/net/ethernet/huawei/hinic3/hinic3_wq.c

110

memset(qpages->pages[pg_idx].align_vaddr, 0, qpages->page_size);

drivers/net/ethernet/ibm/ibmvnic.c

5689

crq->query_map_rsp.page_size,

drivers/net/ethernet/ibm/ibmvnic.h

612

u8 page_size;

drivers/net/ethernet/intel/e1000/e1000_hw.c

3481

eeprom->page_size = 32;

drivers/net/ethernet/intel/e1000/e1000_hw.c

3484

eeprom->page_size = 8;

drivers/net/ethernet/intel/e1000/e1000_hw.c

4124

if ((((offset + widx) * 2) % eeprom->page_size) == 0) {

drivers/net/ethernet/intel/e1000/e1000_hw.h

237

u16 page_size;

drivers/net/ethernet/intel/e1000e/80003es2lan.c

80

nvm->page_size = 32;

drivers/net/ethernet/intel/e1000e/80003es2lan.c

84

nvm->page_size = 8;

drivers/net/ethernet/intel/e1000e/80003es2lan.c

88

nvm->page_size = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;

drivers/net/ethernet/intel/e1000e/82571.c

130

nvm->page_size = 32;

drivers/net/ethernet/intel/e1000e/82571.c

134

nvm->page_size = 8;

drivers/net/ethernet/intel/e1000e/82571.c

138

nvm->page_size = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;

drivers/net/ethernet/intel/e1000e/hw.h

662

u16 page_size;

drivers/net/ethernet/intel/e1000e/nvm.c

390

if ((((offset + widx) * 2) % nvm->page_size) == 0) {

drivers/net/ethernet/intel/i40e/i40e_txrx.h

137

int page_size, pad_size;

drivers/net/ethernet/intel/i40e/i40e_txrx.h

139

page_size = ALIGN(rx_buf_len, PAGE_SIZE / 2);

drivers/net/ethernet/intel/i40e/i40e_txrx.h

140

pad_size = SKB_WITH_OVERHEAD(page_size) - rx_buf_len;

drivers/net/ethernet/intel/igb/e1000_82575.c

351

nvm->page_size = 32;

drivers/net/ethernet/intel/igb/e1000_82575.c

355

nvm->page_size = 8;

drivers/net/ethernet/intel/igb/e1000_82575.c

359

nvm->page_size = eecd & E1000_EECD_ADDR_BITS ? 32 : 8;

drivers/net/ethernet/intel/igb/e1000_82575.c

365

nvm->page_size = 128;

drivers/net/ethernet/intel/igb/e1000_hw.h

450

u16 page_size;

drivers/net/ethernet/intel/igb/e1000_nvm.c

465

if ((((offset + widx) * 2) % nvm->page_size) == 0) {

drivers/net/ethernet/intel/igb/igb.h

171

int page_size, pad_size;

drivers/net/ethernet/intel/igb/igb.h

173

page_size = ALIGN(rx_buf_len, PAGE_SIZE / 2);

drivers/net/ethernet/intel/igb/igb.h

174

pad_size = SKB_WITH_OVERHEAD(page_size) - rx_buf_len;

drivers/net/ethernet/intel/igc/igc_base.c

93

nvm->page_size = eecd & IGC_EECD_ADDR_BITS ? 32 : 8;

drivers/net/ethernet/intel/igc/igc_base.c

98

nvm->page_size = 128;

drivers/net/ethernet/intel/igc/igc_hw.h

127

u16 page_size;

drivers/net/ethernet/intel/ixgbe/ixgbe.h

100

pad_size = SKB_WITH_OVERHEAD(page_size) - rx_buf_len;

drivers/net/ethernet/intel/ixgbe/ixgbe.h

97

int page_size, pad_size;

drivers/net/ethernet/intel/ixgbe/ixgbe.h

99

page_size = ALIGN(rx_buf_len, PAGE_SIZE / 2);

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

1000

page_size = hw->eeprom.word_page_size;

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

1008

if (page_size == 0)

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

1012

if (((offset + i) & (page_size - 1)) ==

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

1013

(page_size - 1))

drivers/net/ethernet/intel/ixgbe/ixgbe_common.c

962

u16 page_size;

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

909

u32 page_size;

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

951

page_size = ~dev->caps.page_size_cap + 1;

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

952

mlx4_warn(dev, "HCA minimum page size:%d\n", page_size);

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

953

if (page_size > PAGE_SIZE) {

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

955

page_size, PAGE_SIZE);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

676

u32 page_size = BIT(PAGE_SHIFT + page_order);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

683

page_size, rq->buff.map_dir);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

694

u32 page_size = BIT(PAGE_SHIFT + page_order);

drivers/net/ethernet/mellanox/mlx5/core/en_main.c

696

dma_unmap_page(rq->pdev, rq->wqe_overflow.addr, page_size,

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1890

u32 page_size = BIT(rq->mpwqe.page_shift);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1896

u32 pg_consumed_bytes = min_t(u32, page_size - data_offset,

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1918

u32 page_size = BIT(rq->mpwqe.page_shift);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1987

if (unlikely(frag_offset >= page_size)) {

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

1989

frag_offset -= page_size;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2001

min_t(u32, page_size - frag_offset, byte_cnt);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2036

truesize -= (nr_frags_free - 1) * page_size +

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2220

u32 page_size)

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2224

if (page_size >= GRO_LEGACY_MAX_SIZE)

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2227

return page_size * nr_frags + data_bcnt <= GRO_LEGACY_MAX_SIZE;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2242

u32 page_size = BIT(rq->mpwqe.page_shift);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2264

data_offset = wqe_offset & (page_size - 1);

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c

2268

page_size))) {

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_resource.c

106

res->size = (u64)entry.region.page_size << 8;

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_resource.c

53

u32 page_size;

drivers/net/ethernet/qlogic/qed/qed_chain.c

101

dma_free_coherent(&cdev->pdev->dev, chain->page_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

119

dma_free_coherent(dev, chain->page_size, entry->virt_addr,

drivers/net/ethernet/qlogic/qed/qed_chain.c

164

chain_size = ELEMS_PER_PAGE(params->elem_size, params->page_size);

drivers/net/ethernet/qlogic/qed/qed_chain.c

207

virt = dma_alloc_coherent(dev, chain->page_size, &phys,

drivers/net/ethernet/qlogic/qed/qed_chain.c

22

params->page_size);

drivers/net/ethernet/qlogic/qed/qed_chain.c

238

virt = dma_alloc_coherent(&cdev->pdev->dev, chain->page_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

24

params->page_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

290

virt = dma_alloc_coherent(dev, chain->page_size, &phys,

drivers/net/ethernet/qlogic/qed/qed_chain.c

326

if (!params->page_size)

drivers/net/ethernet/qlogic/qed/qed_chain.c

327

params->page_size = QED_CHAIN_PAGE_SIZE;

drivers/net/ethernet/qlogic/qed/qed_chain.c

33

chain->page_size = params->page_size;

drivers/net/ethernet/qlogic/qed/qed_chain.c

334

params->page_size,

drivers/net/ethernet/qlogic/qed/qed_chain.c

345

params->page_size);

drivers/net/ethernet/qlogic/qed/qed_chain.c

88

dma_free_coherent(dev, chain->page_size, virt, phys);

drivers/net/ethernet/qlogic/qed/qed_cxt.c

291

u32 page_size;

drivers/net/ethernet/qlogic/qed/qed_cxt.c

293

page_size = qed_cxt_get_ilt_page_size(p_hwfn, ILT_CLI_TSDM);

drivers/net/ethernet/qlogic/qed/qed_cxt.c

294

return page_size / XRC_SRQ_CXT_SIZE;

drivers/net/ethernet/qlogic/qed/qed_cxt.c

792

struct qed_src_t2 *p_t2, u32 total_size, u32 page_size)

drivers/net/ethernet/qlogic/qed/qed_cxt.c

801

size = min_t(u32, total_size, page_size);

drivers/net/ethernet/qlogic/qed/qed_hsi.h

6290

__le16 page_size;

drivers/net/ethernet/qlogic/qed/qed_hsi.h

9693

__le16 page_size;

drivers/net/ethernet/qlogic/qed/qed_rdma.c

1811

p_ramrod->page_size = cpu_to_le16(in_params->page_size);

drivers/net/ethernet/sun/cassini.c

1284

if (cp->page_size == 0x1000)

drivers/net/ethernet/sun/cassini.c

1286

else if (cp->page_size == 0x2000)

drivers/net/ethernet/sun/cassini.c

1288

else if (cp->page_size == 0x4000)

drivers/net/ethernet/sun/cassini.c

1293

if (size > cp->page_size)

drivers/net/ethernet/sun/cassini.c

1294

size = cp->page_size;

drivers/net/ethernet/sun/cassini.c

1308

val |= CAS_BASE(RX_PAGE_SIZE_MTU_COUNT, cp->page_size >> (i + 10));

drivers/net/ethernet/sun/cassini.c

161

#define CAS_MAX_MTU min(((cp->page_size << 1) - 0x50), 9000)

drivers/net/ethernet/sun/cassini.c

1966

hlen = min(cp->page_size - off, dlen);

drivers/net/ethernet/sun/cassini.c

2040

hlen = min(cp->page_size - off, dlen);

drivers/net/ethernet/sun/cassini.c

3367

cp->page_size = (PAGE_SIZE << cp->page_order);

drivers/net/ethernet/sun/cassini.c

444

dma_unmap_page(&cp->pdev->dev, page->dma_addr, cp->page_size,

drivers/net/ethernet/sun/cassini.c

476

cp->page_size, DMA_FROM_DEVICE);

drivers/net/ethernet/sun/cassini.h

2811

int page_size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

300

u32 page_size = fwrt->fw_paging_db[idx].fw_paging_size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

303

range->range_data_size = cpu_to_le32(page_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

304

dma_sync_single_for_cpu(fwrt->trans->dev, addr, page_size,

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

306

memcpy(range->data, page_address(page), page_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

307

dma_sync_single_for_device(fwrt->trans->dev, addr, page_size,

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

318

u32 page_size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

327

page_size = fwrt->trans->init_dram.paging[idx].size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

330

range->range_data_size = cpu_to_le32(page_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

332

page_size);

drivers/net/wireless/mediatek/mt76/mt7603/init.c

43

int page_size = 128;

drivers/net/wireless/mediatek/mt76/mt7603/init.c

46

int max_amsdu_pages = 4096 / page_size;

drivers/net/wireless/mediatek/mt76/mt7603/init.c

49

int max_mcast_pages = 4 * max_len / page_size;

drivers/net/wireless/mediatek/mt76/mt7603/init.c

57

beacon_pages = 4 * (max_beacon_len / page_size);

drivers/net/wireless/mediatek/mt76/mt7603/init.c

58

mcu_pages = max_mcu_len / page_size;

drivers/net/wireless/realtek/rtw88/debug.c

311

u16 page_size = rtwdev->chip->page_size;

drivers/net/wireless/realtek/rtw88/debug.c

312

u32 buf_size = debugfs_priv->rsvd_page.page_num * page_size;

drivers/net/wireless/realtek/rtw88/debug.c

313

u32 offset = debugfs_priv->rsvd_page.page_offset * page_size;

drivers/net/wireless/realtek/rtw88/debug.c

331

if (i % page_size == 0)

drivers/net/wireless/realtek/rtw88/debug.c

332

seq_printf(m, "PAGE %d\n", (i + offset) / page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1313

static inline u8 rtw_len_to_page(unsigned int len, u16 page_size)

drivers/net/wireless/realtek/rtw88/fw.c

1315

return DIV_ROUND_UP(len, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1318

static void rtw_rsvd_page_list_to_buf(struct rtw_dev *rtwdev, u16 page_size,

drivers/net/wireless/realtek/rtw88/fw.c

1325

memcpy(buf + page_margin + page_size * (page - 1),

drivers/net/wireless/realtek/rtw88/fw.c

1546

pg_size = rtwdev->chip->page_size;

drivers/net/wireless/realtek/rtw88/fw.c

1631

u16 page_size, page_margin, tx_desc_sz;

drivers/net/wireless/realtek/rtw88/fw.c

1637

page_size = chip->page_size;

drivers/net/wireless/realtek/rtw88/fw.c

1639

page_margin = page_size - tx_desc_sz;

drivers/net/wireless/realtek/rtw88/fw.c

1679

page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1681

total_page += rtw_len_to_page(iter->len, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1690

*size = (total_page - 1) * page_size + page_margin;

drivers/net/wireless/realtek/rtw88/fw.c

1703

rtw_rsvd_page_list_to_buf(rtwdev, page_size, page_margin,

drivers/net/wireless/realtek/rtw88/fw.c

1707

tx_desc_sz, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1709

page += rtw_len_to_page(rsvd_pkt->skb->len, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

2041

u16 page_size = chip->page_size;

drivers/net/wireless/realtek/rtw88/fw.c

2043

u16 buf_offset = page_size * page_offset;

drivers/net/wireless/realtek/rtw88/fw.c

2055

buf = kzalloc(page_size * pages, GFP_KERNEL);

drivers/net/wireless/realtek/rtw88/fw.c

2063

if (skb->len > page_size * page_cnt) {

drivers/net/wireless/realtek/rtw88/fw.c

2073

buf_offset += page_cnt * page_size;

drivers/net/wireless/realtek/rtw88/mac.c

1147

fifo->txff_pg_num = chip->txff_size / chip->page_size;

drivers/net/wireless/realtek/rtw88/main.h

1225

u16 page_size;

drivers/net/wireless/realtek/rtw88/rtw8703b.c

1903

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8723d.c

2141

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8812a.c

1058

.page_size = 512,

drivers/net/wireless/realtek/rtw88/rtw8814a.c

2196

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8821a.c

1163

.page_size = 256,

drivers/net/wireless/realtek/rtw88/rtw8821c.c

1998

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8822b.c

2541

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8822c.c

5357

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/sdio.c

623

pages_needed = DIV_ROUND_UP(count, rtwdev->chip->page_size);

drivers/net/wireless/realtek/rtw89/pci.c

3424

u32 page_size = wd_ring->page_size;

drivers/net/wireless/realtek/rtw89/pci.c

3426

u32 ring_sz = page_size * page_num;

drivers/net/wireless/realtek/rtw89/pci.c

3546

u32 page_size = RTW89_PCI_TXWD_PAGE_SIZE;

drivers/net/wireless/realtek/rtw89/pci.c

3548

u32 ring_sz = page_size * page_num;

drivers/net/wireless/realtek/rtw89/pci.c

3563

wd_ring->page_size = page_size;

drivers/net/wireless/realtek/rtw89/pci.c

3576

txwd->len = page_size;

drivers/net/wireless/realtek/rtw89/pci.c

3580

page_offset += page_size;

drivers/net/wireless/realtek/rtw89/pci.h

1579

u32 page_size;

drivers/net/wireless/realtek/rtw89/pci.h

1725

memset(txwd->vaddr, 0, wd_ring->page_size);

drivers/nfc/s3fwrn5/firmware.h

44

__u16 page_size;

drivers/nvdimm/pfn.h

45

__le32 page_size;

drivers/nvdimm/pfn_devs.c

483

pfn_sb->page_size = cpu_to_le32(PAGE_SIZE);

drivers/nvdimm/pfn_devs.c

502

if ((le32_to_cpu(pfn_sb->page_size) > PAGE_SIZE) &&

drivers/nvdimm/pfn_devs.c

506

le32_to_cpu(pfn_sb->page_size));

drivers/nvdimm/pfn_devs.c

830

pfn_sb->page_size = cpu_to_le32(PAGE_SIZE);

drivers/pci/controller/dwc/pci-imx6.c

1634

ep->page_size = imx_pcie->drvdata->epc_features->align;

drivers/pci/controller/dwc/pci-keystone.c

884

ep->page_size = AM654_WIN_SIZE;

drivers/pci/controller/dwc/pcie-designware-ep.c

1175

epc->mem->window.page_size);

drivers/pci/controller/dwc/pcie-designware-ep.c

1528

ep->page_size);

drivers/pci/controller/dwc/pcie-designware-ep.c

1535

epc->mem->window.page_size);

drivers/pci/controller/dwc/pcie-designware-ep.c

630

*pci_size = ALIGN(ofst + *pci_size, epc->mem->window.page_size);

drivers/pci/controller/dwc/pcie-designware.h

512

size_t page_size;

drivers/pci/controller/dwc/pcie-dw-rockchip.c

726

rockchip->pci.ep.page_size = SZ_64K;

drivers/pci/controller/dwc/pcie-stm32-ep.c

208

ep->page_size = stm32_pcie_epc_features.align;

drivers/pci/controller/dwc/pcie-tegra194.c

2087

ep->page_size = SZ_64K;

drivers/pci/controller/pcie-rcar-ep.c

121

ep->ob_window[i].page_size = resource_size(res);

drivers/pci/controller/pcie-rockchip-ep.c

778

windows[i].page_size = SZ_1M;

drivers/pci/endpoint/pci-epc-mem.c

129

size_t size, size_t page_size)

drivers/pci/endpoint/pci-epc-mem.c

135

mem_window.page_size = page_size;

drivers/pci/endpoint/pci-epc-mem.c

194

align_size = ALIGN(size, mem->window.page_size);

drivers/pci/endpoint/pci-epc-mem.c

201

page_shift = ilog2(mem->window.page_size);

drivers/pci/endpoint/pci-epc-mem.c

252

size_t page_size;

drivers/pci/endpoint/pci-epc-mem.c

26

unsigned int page_shift = ilog2(mem->window.page_size);

drivers/pci/endpoint/pci-epc-mem.c

262

page_size = mem->window.page_size;

drivers/pci/endpoint/pci-epc-mem.c

263

page_shift = ilog2(page_size);

drivers/pci/endpoint/pci-epc-mem.c

266

size = ALIGN(size, page_size);

drivers/pci/endpoint/pci-epc-mem.c

54

size_t page_size;

drivers/pci/endpoint/pci-epc-mem.c

70

page_size = windows[i].page_size;

drivers/pci/endpoint/pci-epc-mem.c

71

if (page_size < PAGE_SIZE)

drivers/pci/endpoint/pci-epc-mem.c

72

page_size = PAGE_SIZE;

drivers/pci/endpoint/pci-epc-mem.c

73

page_shift = ilog2(page_size);

drivers/pci/endpoint/pci-epc-mem.c

94

mem->window.page_size = page_size;

drivers/ps3/ps3stor_lib.c

140

enum ps3_dma_page_size page_size;

drivers/ps3/ps3stor_lib.c

176

page_size = PS3_DMA_4K;

drivers/ps3/ps3stor_lib.c

178

page_size = PS3_DMA_64K;

drivers/ps3/ps3stor_lib.c

180

ps3_dma_region_init(&dev->sbd, &dev->dma_region, page_size,

drivers/scsi/be2iscsi/be_cmds.c

811

req->page_size = 1;

drivers/scsi/be2iscsi/be_cmds.h

615

u8 page_size;

drivers/scsi/elx/libefc_sli/sli4.c

100

u32 page_size = 0;

drivers/scsi/elx/libefc_sli/sli4.c

113

page_size = SZ_4K;

drivers/scsi/elx/libefc_sli/sli4.c

116

page_size = SZ_8K;

drivers/scsi/elx/libefc_sli/sli4.c

121

num_pages = sli_page_count(qmem->size, page_size);

drivers/scsi/elx/libefc_sli/sli4.c

133

cqv2->page_size = page_size / SLI_PAGE_SIZE;

drivers/scsi/elx/libefc_sli/sli4.c

169

for (p = 0, addr = qmem->phys; p < num_pages; p++, addr += page_size) {

drivers/scsi/elx/libefc_sli/sli4.c

306

u32 page_size = 0;

drivers/scsi/elx/libefc_sli/sli4.c

324

page_size = SZ_4K;

drivers/scsi/elx/libefc_sli/sli4.c

327

page_size = SZ_8K;

drivers/scsi/elx/libefc_sli/sli4.c

330

page_size = SZ_16K;

drivers/scsi/elx/libefc_sli/sli4.c

333

page_size = SZ_32K;

drivers/scsi/elx/libefc_sli/sli4.c

336

page_size = SZ_64K;

drivers/scsi/elx/libefc_sli/sli4.c

343

num_pages = sli_page_count(qmem->size, page_size);

drivers/scsi/elx/libefc_sli/sli4.c

350

wq->page_size = page_size / SLI_PAGE_SIZE;

drivers/scsi/elx/libefc_sli/sli4.c

359

for (p = 0, addr = qmem->phys; p < num_pages; p++, addr += page_size) {

drivers/scsi/elx/libefc_sli/sli4.c

403

rq->page_size = SLI4_RQ_PAGE_SIZE_4096;

drivers/scsi/elx/libefc_sli/sli4.c

467

req->page_size = SLI4_RQ_PAGE_SIZE_4096;

drivers/scsi/elx/libefc_sli/sli4.c

824

u32 p = 0, page_size = 0, n_cqe = 0, num_pages_cq;

drivers/scsi/elx/libefc_sli/sli4.c

835

page_size = 1;

drivers/scsi/elx/libefc_sli/sli4.c

838

page_size = 2;

drivers/scsi/elx/libefc_sli/sli4.c

844

page_bytes = page_size * SLI_PAGE_SIZE;

drivers/scsi/elx/libefc_sli/sli4.c

866

req->page_size = page_size;

drivers/scsi/elx/libefc_sli/sli4.h

2002

sli_page_count(size_t bytes, u32 page_size)

drivers/scsi/elx/libefc_sli/sli4.h

2004

if (!page_size)

drivers/scsi/elx/libefc_sli/sli4.h

2007

return (bytes + (page_size - 1)) >> __ffs(page_size);

drivers/scsi/elx/libefc_sli/sli4.h

604

u8 page_size;

drivers/scsi/elx/libefc_sli/sli4.h

631

u8 page_size;

drivers/scsi/elx/libefc_sli/sli4.h

861

u8 page_size;

drivers/scsi/elx/libefc_sli/sli4.h

882

u8 page_size;

drivers/scsi/elx/libefc_sli/sli4.h

920

u8 page_size;

drivers/scsi/esas2r/atioctl.h

1055

u32 page_size;

drivers/scsi/lpfc/lpfc_sli.c

15832

dma_free_coherent(&queue->phba->pcidev->dev, queue->page_size,

drivers/scsi/lpfc/lpfc_sli.c

15861

lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t page_size,

drivers/scsi/lpfc/lpfc_sli.c

15870

hw_page_size = page_size;

drivers/scsi/lpfc/lpfc_sli.c

15898

queue->page_size = hw_page_size;

drivers/scsi/lpfc/lpfc_sli.c

16352

(cq->page_size / SLI4_PAGE_SIZE));

drivers/scsi/lpfc/lpfc_sli.c

16399

memset(dmabuf->virt, 0, cq->page_size);

drivers/scsi/lpfc/lpfc_sli.c

16517

hw_page_size = cq->page_size;

drivers/scsi/lpfc/lpfc_sli.c

16953

hw_page_size = wq->page_size;

drivers/scsi/lpfc/lpfc_sli.c

16975

(wq->page_size > SLI4_PAGE_SIZE))

drivers/scsi/lpfc/lpfc_sli.c

17004

(wq->page_size / SLI4_PAGE_SIZE));

drivers/scsi/lpfc/lpfc_sli4.h

1085

uint32_t page_size,

drivers/scsi/lpfc/lpfc_sli4.h

224

uint16_t page_size; /* size of page allocated for this queue */

drivers/scsi/megaraid/megaraid_sas_base.c

3484

static DEVICE_ATTR_RO(page_size);

drivers/scsi/mpi3mr/mpi/mpi30_cnfg.h

2428

u8 page_size;

drivers/scsi/mpi3mr/mpi3mr_os.c

1189

pcieinf->page_size);

drivers/scsi/mpi3mr/mpi3mr_os.c

1362

tgtdev->dev_spec.pcie_inf.pgsz = pcieinf->page_size;

drivers/scsi/mpt3sas/mpt3sas_base.c

2319

page_mask = ioc->page_size - 1;

drivers/scsi/mpt3sas/mpt3sas_base.c

2369

entry_len = ioc->page_size - offset;

drivers/scsi/mpt3sas/mpt3sas_base.c

2389

if (length > ioc->page_size) {

drivers/scsi/mpt3sas/mpt3sas_base.c

2466

nvme_pg_size = max_t(u32, ioc->page_size, NVME_PRP_PAGE_SIZE);

drivers/scsi/mpt3sas/mpt3sas_base.c

5974

ioc->page_size, 0);

drivers/scsi/mpt3sas/mpt3sas_base.c

6609

nvme_blocks_needed /= (ioc->page_size - NVME_PRP_SIZE);

drivers/scsi/mpt3sas/mpt3sas_base.c

6618

sz = nvme_blocks_needed * ioc->page_size;

drivers/scsi/mpt3sas/mpt3sas_base.c

7507

ioc->page_size = 1 << facts->CurrentHostPageSize;

drivers/scsi/mpt3sas/mpt3sas_base.c

7508

if (ioc->page_size == 1) {

drivers/scsi/mpt3sas/mpt3sas_base.c

7510

ioc->page_size = 1 << MPT3SAS_HOST_PAGE_SIZE_4K;

drivers/scsi/mpt3sas/mpt3sas_base.h

1523

u32 page_size;

drivers/scsi/mpt3sas/mpt3sas_scsih.c

2760

lim->virt_boundary_mask = ioc->page_size - 1;

drivers/spi/spi-amlogic-spifc-a4.c

694

u32 page_size, cmd = 0;

drivers/spi/spi-amlogic-spifc-a4.c

699

page_size = ecc_cfg->stepsize * ecc_cfg->nsteps;

drivers/spi/spi-amlogic-spifc-a4.c

700

data_len = page_size + ecc_cfg->oobsize;

drivers/spi/spi-amlogic-spifc-a4.c

729

memcpy(op->data.buf.in, sfc->data_buf, page_size);

drivers/spi/spi-amlogic-spifc-a4.c

733

memcpy(op->data.buf.in, sfc->data_buf, page_size);

drivers/spi/spi-amlogic-spifc-a4.c

734

aml_sfc_get_user_byte(sfc, sfc->info_buf, op->data.buf.in + page_size);

drivers/spi/spi-amlogic-spifc-a4.c

747

u32 page_size, cmd = 0;

drivers/spi/spi-amlogic-spifc-a4.c

752

page_size = ecc_cfg->stepsize * ecc_cfg->nsteps;

drivers/spi/spi-amlogic-spifc-a4.c

753

data_len = page_size + ecc_cfg->oobsize;

drivers/spi/spi-amlogic-spifc-a4.c

757

memcpy(sfc->data_buf, op->data.buf.out, page_size);

drivers/spi/spi-amlogic-spifc-a4.c

762

(u8 *)op->data.buf.out + page_size, 1);

drivers/spi/spi-amlogic-spifc-a4.c

765

(u8 *)op->data.buf.out + page_size, 0);

drivers/spi/spi-mtk-snfi.c

1014

u32 cap_len = snf->buf_len - snf->nfi_cfg.page_size;

drivers/spi/spi-mtk-snfi.c

1015

u32 req_left = op->data.nbytes - snf->nfi_cfg.page_size;

drivers/spi/spi-mtk-snfi.c

1018

memcpy(op->data.buf.in + snf->nfi_cfg.page_size,

drivers/spi/spi-mtk-snfi.c

1073

dma_len = snf->nfi_cfg.page_size;

drivers/spi/spi-mtk-snfi.c

1078

last_bit = fls(snf->nfi_cfg.page_size + snf->nfi_cfg.oob_size);

drivers/spi/spi-mtk-snfi.c

1098

mtk_snand_write_fdm(snf, snf->buf + snf->nfi_cfg.page_size);

drivers/spi/spi-mtk-snfi.c

295

size_t page_size;

drivers/spi/spi-mtk-snfi.c

534

static int mtk_snand_setup_pagefmt(struct mtk_snand *snf, u32 page_size,

drivers/spi/spi-mtk-snfi.c

544

if (snf->nfi_cfg.page_size == page_size &&

drivers/spi/spi-mtk-snfi.c

548

nsectors = page_size / snf->caps->sector_size;

drivers/spi/spi-mtk-snfi.c

562

switch (page_size) {

drivers/spi/spi-mtk-snfi.c

620

snf->nfi_cfg.page_size = page_size;

drivers/spi/spi-mtk-snfi.c

627

return snand_prepare_bouncebuf(snf, page_size + oob_size);

drivers/spi/spi-mtk-snfi.c

629

dev_err(snf->dev, "page size %u + %u is not supported\n", page_size,

drivers/spi/spi-mtk-snfi.c

839

buf_bbm_pos = snf->nfi_cfg.page_size -

drivers/spi/spi-mtk-snfi.c

841

fdm_bbm_pos = snf->nfi_cfg.page_size +

drivers/spi/spi-mtk-snfi.c

855

fdm_bbm_pos1 = snf->nfi_cfg.page_size;

drivers/spi/spi-mtk-snfi.c

856

fdm_bbm_pos2 = snf->nfi_cfg.page_size +

drivers/spi/spi-mtk-snfi.c

865

u8 *buf_fdm = buf + snf->nfi_cfg.page_size;

drivers/spi/spi-mtk-snfi.c

881

dma_len = snf->nfi_cfg.page_size;

drivers/spi/spi-mtk-snfi.c

890

last_bit = fls(snf->nfi_cfg.page_size + snf->nfi_cfg.oob_size);

drivers/spi/spi-mtk-snfi.c

896

if (rd_offset == 0 && op->data.nbytes >= snf->nfi_cfg.page_size)

drivers/staging/rtl8723bs/hal/hal_sdio.c

61

u32 page_size;

drivers/staging/rtl8723bs/hal/hal_sdio.c

64

rtw_hal_get_def_var(padapter, HAL_DEF_TX_PAGE_SIZE, &page_size);

drivers/staging/rtl8723bs/hal/hal_sdio.c

66

lenHQ = ((numHQ + numPubQ) >> 1) * page_size;

drivers/staging/rtl8723bs/hal/hal_sdio.c

67

lenNQ = ((numNQ + numPubQ) >> 1) * page_size;

drivers/staging/rtl8723bs/hal/hal_sdio.c

68

lenLQ = ((numLQ + numPubQ) >> 1) * page_size;

drivers/target/tcm_fc/tfc_io.c

138

fp_skb(fp)->truesize += page_size(page);

drivers/usb/cdns3/cdnsp-gadget.h

118

__le32 page_size;

drivers/usb/cdns3/cdnsp-mem.c

1242

u32 page_size;

drivers/usb/cdns3/cdnsp-mem.c

1249

page_size = 1 << 12;

drivers/usb/cdns3/cdnsp-mem.c

1278

page_size);

drivers/usb/cdns3/cdnsp-mem.c

1283

CDNSP_CTX_SIZE, 64, page_size);

drivers/usb/gadget/udc/bdc/bdc_core.c

367

u32 page_size;

drivers/usb/gadget/udc/bdc/bdc_core.c

373

page_size = BDC_PGS(bdc_readl(bdc->regs, BDC_BDCCFG0));

drivers/usb/gadget/udc/bdc/bdc_core.c

375

page_size = 1 << page_size;

drivers/usb/gadget/udc/bdc/bdc_core.c

377

page_size <<= 10;

drivers/usb/gadget/udc/bdc/bdc_core.c

378

dev_dbg(bdc->dev, "page_size=%d\n", page_size);

drivers/usb/gadget/udc/bdc/bdc_core.c

383

16, page_size);

drivers/usb/host/xhci-mem.c

1677

void *buf = dma_alloc_coherent(dev, xhci->page_size, &dma,

drivers/usb/host/xhci-mem.c

1690

dma_free_coherent(dev, xhci->page_size,

drivers/usb/host/xhci-mem.c

1721

dma_free_coherent(dev, xhci->page_size,

drivers/usb/host/xhci-mem.c

2444

TRB_SEGMENT_SIZE * 2, TRB_SEGMENT_SIZE * 2, xhci->page_size * 2);

drivers/usb/host/xhci-mem.c

2447

TRB_SEGMENT_SIZE, TRB_SEGMENT_SIZE, xhci->page_size);

drivers/usb/host/xhci-mem.c

2453

xhci->page_size);

drivers/usb/host/xhci.c

459

u32 page_size;

drivers/usb/host/xhci.c

461

page_size = readl(&xhci->op_regs->page_size) & XHCI_PAGE_SIZE_MASK;

drivers/usb/host/xhci.c

462

if (!is_power_of_2(page_size)) {

drivers/usb/host/xhci.c

463

xhci_warn(xhci, "Invalid page size register = 0x%x\n", page_size);

drivers/usb/host/xhci.c

465

page_size = 1;

drivers/usb/host/xhci.c

468

xhci->page_size = page_size << 12;

drivers/usb/host/xhci.c

470

xhci->page_size >> 10);

drivers/usb/host/xhci.h

111

__le32 page_size;

drivers/usb/host/xhci.h

1528

u32 page_size;

drivers/vdpa/mlx5/core/mr.c

22

u64 page_size = 1ULL << page_shift;

drivers/vdpa/mlx5/core/mr.c

25

npages = ALIGN(len, page_size) >> page_shift;

drivers/vfio/pci/hisilicon/hisi_acc_vfio_pci.c

147

ret = qm_read_regs(qm, QM_PAGE_SIZE, &vf_data->page_size, 1);

drivers/vfio/pci/hisilicon/hisi_acc_vfio_pci.c

221

ret = qm_write_regs(qm, QM_PAGE_SIZE, &vf_data->page_size, 1);

drivers/vfio/pci/hisilicon/hisi_acc_vfio_pci.h

101

u32 page_size;

drivers/vfio/pci/mlx5/cmd.c

1513

u64 *page_size)

drivers/vfio/pci/mlx5/cmd.c

1518

u8 log_tracked_page = ilog2(*page_size);

drivers/vfio/pci/mlx5/cmd.c

1607

*page_size = host_qp->tracked_page_size;

drivers/vfio/pci/mlx5/cmd.h

250

struct rb_root_cached *ranges, u32 nnodes, u64 *page_size);

drivers/vfio/pci/pds/dirty.c

221

region->page_size = region_page_size;

drivers/vfio/pci/pds/dirty.c

244

u64 *page_size)

drivers/vfio/pci/pds/dirty.c

250

u64 region_page_size = *page_size;

drivers/vfio/pci/pds/dirty.c

475

u64 page_size = region->page_size;

drivers/vfio/pci/pds/dirty.c

496

u64 addr = abs_bit_i * page_size + region_start;

drivers/vfio/pci/pds/dirty.c

498

iova_bitmap_set(dirty_bitmap, addr, page_size);

drivers/vfio/pci/pds/dirty.c

547

pages = DIV_ROUND_UP(length, region->page_size);

drivers/vfio/pci/pds/dirty.c

553

pds_vfio->vf_id, iova, length, region->page_size,

drivers/vfio/pci/pds/dirty.c

563

bmp_bytes = ALIGN(DIV_ROUND_UP(length / region->page_size,

drivers/vfio/pci/pds/dirty.c

580

region->page_size, sizeof(u64));

drivers/vfio/pci/pds/dirty.c

619

u64 *page_size)

drivers/vfio/pci/pds/dirty.c

628

err = pds_vfio_dirty_enable(pds_vfio, ranges, nnodes, page_size);

drivers/vfio/pci/pds/dirty.h

13

u64 page_size;

drivers/vfio/pci/pds/dirty.h

39

u64 *page_size);

drivers/vfio/vfio_main.c

1129

if (!IS_ALIGNED(range.iova, control.page_size) ||

drivers/vfio/vfio_main.c

1130

!IS_ALIGNED(range.length, control.page_size)) {

drivers/vfio/vfio_main.c

1153

&control.page_size);

drivers/vfio/vfio_main.c

1219

if (report.page_size < SZ_4K || !is_power_of_2(report.page_size))

drivers/vfio/vfio_main.c

1227

report.page_size,

drivers/virt/nitro_enclaves/ne_misc_dev.c

819

if (page_size(mem_region_page) & (NE_MIN_MEM_REGION_SIZE - 1)) {

drivers/virt/nitro_enclaves/ne_misc_dev.c

882

u64 page_paddr, u64 page_size)

drivers/virt/nitro_enclaves/ne_misc_dev.c

887

rc = ne_sanity_check_phys_mem_region(page_paddr, page_size);

drivers/virt/nitro_enclaves/ne_misc_dev.c

893

phys_contig_regions->regions[num - 1].end += page_size;

drivers/virt/nitro_enclaves/ne_misc_dev.c

896

phys_contig_regions->regions[num].end = page_paddr + page_size - 1;

drivers/virt/nitro_enclaves/ne_misc_dev.c

981

page_size(ne_mem_region->pages[i]));

drivers/virt/nitro_enclaves/ne_misc_dev.c

985

memory_size += page_size(ne_mem_region->pages[i]);

fs/ntfs/compress.c

1417

int page_size;

fs/ntfs/compress.c

1420

page_size = PAGE_SIZE;

fs/ntfs/compress.c

1423

page_size = bio_size;

fs/ntfs/compress.c

1436

if (!bio_add_page(bio, pages[i], page_size, 0)) {

fs/ntfs3/fslog.c

1035

u32 page_size;

fs/ntfs3/fslog.c

1102

off = (off & ~log->sys_page_mask) + log->page_size;

fs/ntfs3/fslog.c

1141

log->page_size) +

fs/ntfs3/fslog.c

1161

u32 bytes = log->page_size - page_off;

fs/ntfs3/fslog.c

1172

to_free = kmalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

1181

log->page_size, NULL, &log->read_ahead);

fs/ntfs3/fslog.c

1186

ntfs_fix_post_read(&page_buf->rhdr, log->page_size, false);

fs/ntfs3/fslog.c

1328

log->sys_page_size = log->page_size;

fs/ntfs3/fslog.c

1331

log->clst_per_page = log->page_size >> log->ni->mi.sbi->cluster_bits;

fs/ntfs3/fslog.c

1335

log->first_page = major_ver >= 2 ? 0x22 * log->page_size :

fs/ntfs3/fslog.c

1336

4 * log->page_size;

fs/ntfs3/fslog.c

1369

sizeof(short) * ((log->page_size >> SECTOR_SHIFT) + 1),

fs/ntfs3/fslog.c

1371

log->data_size = log->page_size - log->data_off;

fs/ntfs3/fslog.c

1441

u32 tail = log->page_size - page_off;

fs/ntfs3/fslog.c

1557

log->next_page + log->page_size :

fs/ntfs3/fslog.c

1643

final_off = 0x02 * log->page_size;

fs/ntfs3/fslog.c

1644

second_off = 0x12 * log->page_size;

fs/ntfs3/fslog.c

1647

page_bufs = kmalloc(log->page_size * 0x10, GFP_NOFS);

fs/ntfs3/fslog.c

1651

second_off = log->first_page - log->page_size;

fs/ntfs3/fslog.c

1652

final_off = second_off - log->page_size;

fs/ntfs3/fslog.c

1738

memmove(page_bufs, best_page, log->page_size);

fs/ntfs3/fslog.c

1747

saved_off + log->page_size == this_off &&

fs/ntfs3/fslog.c

1754

saved_off += log->page_size;

fs/ntfs3/fslog.c

1757

memmove(Add2Ptr(page_bufs, tails * log->page_size), best_page,

fs/ntfs3/fslog.c

1758

log->page_size);

fs/ntfs3/fslog.c

1787

final_off += log->page_size;

fs/ntfs3/fslog.c

1788

second_off += log->page_size;

fs/ntfs3/fslog.c

1878

log->page_size -

fs/ntfs3/fslog.c

2016

log->page_size -

fs/ntfs3/fslog.c

2058

if (log->page_size -

fs/ntfs3/fslog.c

2190

tails -= (page_off1 - page_off) / log->page_size;

fs/ntfs3/fslog.c

2202

page = kmalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

2213

memcpy(page, tmp_page, log->page_size);

fs/ntfs3/fslog.c

2223

ntfs_fix_pre_write(&page->rhdr, log->page_size);

fs/ntfs3/fslog.c

2227

log->page_size, 0);

fs/ntfs3/fslog.c

2233

second_off += log->page_size;

fs/ntfs3/fslog.c

2237

tmp_page = Add2Ptr(tmp_page, log->page_size);

fs/ntfs3/fslog.c

2279

u32 tail = log->page_size - off;

fs/ntfs3/fslog.c

2452

if (page_off + len + log->record_header_len > log->page_size)

fs/ntfs3/fslog.c

30

__le32 page_size; // 0x14: Log page size used for this log file.

fs/ntfs3/fslog.c

3870

log->page_size = norm_file_page(PAGE_SIZE, &log->l_size, true);

fs/ntfs3/fslog.c

3871

if (!log->page_size) {

fs/ntfs3/fslog.c

3876

log->one_page_buf = kmalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

3882

log->page_mask = log->page_size - 1;

fs/ntfs3/fslog.c

3883

log->page_bits = blksize_bits(log->page_size);

fs/ntfs3/fslog.c

3933

log->page_size != log->rst_info.vbo) {

fs/ntfs3/fslog.c

3937

if (!read_log_page(log, log->page_size, &sp, &usa_error) &&

fs/ntfs3/fslog.c

4007

if (log->page_size != t32) {

fs/ntfs3/fslog.c

4008

u32 old_page_size = log->page_size;

fs/ntfs3/fslog.c

4011

log->page_size = norm_file_page(t32, &log->l_size,

fs/ntfs3/fslog.c

4019

if (log->page_size > old_page_size) {

fs/ntfs3/fslog.c

4022

buf = krealloc(log->one_page_buf, log->page_size,

fs/ntfs3/fslog.c

4032

if (log->page_size != t32 ||

fs/ntfs3/fslog.c

4033

log->page_size != le32_to_cpu(log->rst_info.r_page->page_size)) {

fs/ntfs3/fslog.c

4038

log->page_mask = log->page_size - 1;

fs/ntfs3/fslog.c

4039

log->page_bits = blksize_bits(log->page_size);

fs/ntfs3/fslog.c

4061

log->data_size = log->page_size - log->data_off;

fs/ntfs3/fslog.c

4085

tail = log->page_size - (off & log->page_mask) - 1;

fs/ntfs3/fslog.c

431

u32 page_size = le32_to_cpu(rhdr->page_size);

fs/ntfs3/fslog.c

4338

if (sbi->cluster_size <= log->page_size)

fs/ntfs3/fslog.c

435

if (sys_page < SECTOR_SIZE || page_size < SECTOR_SIZE ||

fs/ntfs3/fslog.c

436

sys_page & (sys_page - 1) || page_size & (page_size - 1)) {

fs/ntfs3/fslog.c

5276

rh = kzalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

5284

t16 = (log->page_size >> SECTOR_SHIFT) + 1;

fs/ntfs3/fslog.c

5286

rh->sys_page_size = cpu_to_le32(log->page_size);

fs/ntfs3/fslog.c

5287

rh->page_size = cpu_to_le32(log->page_size);

fs/ntfs3/fslog.c

5304

ntfs_fix_pre_write(&rh->rhdr, log->page_size);

fs/ntfs3/fslog.c

5306

err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rh, log->page_size, 0);

fs/ntfs3/fslog.c

5308

err = ntfs_sb_write_run(sbi, &log->ni->file.run, log->page_size,

fs/ntfs3/fslog.c

5309

rh, log->page_size, 0);

fs/ntfs3/fslog.c

670

static inline u32 norm_file_page(u32 page_size, u32 *l_size, bool use_default)

fs/ntfs3/fslog.c

673

page_size = DefaultLogPageSize;

fs/ntfs3/fslog.c

676

*l_size &= ~(page_size - 1);

fs/ntfs3/fslog.c

679

if (*l_size < (MinLogRecordPages + 2) * page_size)

fs/ntfs3/fslog.c

682

return page_size;

include/acpi/actbl2.h

909

u64 page_size;

include/asm-generic/tlb.h

294

extern bool __tlb_remove_page_size(struct mmu_gather *tlb, struct page *page, int page_size);

include/asm-generic/tlb.h

393

unsigned int page_size;

include/asm-generic/tlb.h

514

struct page *page, int page_size)

include/asm-generic/tlb.h

516

if (__tlb_remove_page_size(tlb, page, page_size))

include/asm-generic/tlb.h

531

unsigned int page_size)

include/asm-generic/tlb.h

534

if (tlb->page_size && tlb->page_size != page_size) {

include/asm-generic/tlb.h

539

tlb->page_size = page_size;

include/hyperv/hvgdk_mini.h

554

u64 page_size : 1;

include/linux/bnge/hsi.h

8251

u8 page_size;

include/linux/bnxt/hsi.h

7513

u8 page_size;

include/linux/buffer_head.h

175

return (unsigned long)(bh)->b_data & (page_size(bh->b_page) - 1);

include/linux/highmem.h

374

BUG_ON(end1 > page_size(page) || end2 > page_size(page));

include/linux/iova_bitmap.h

20

unsigned long page_size,

include/linux/iova_bitmap.h

30

unsigned long page_size,

include/linux/mlx4/qp.h

397

__be32 page_size;

include/linux/mlx5/qp.h

202

__be32 page_size;

include/linux/mtd/sh_flctl.h

152

unsigned page_size:1; /* NAND page size (0 = 512, 1 = 2048) */

include/linux/pci-epc.h

179

size_t page_size;

include/linux/pci-epc.h

408

size_t size, size_t page_size);

include/linux/psp-sev.h

683

u32 page_size:1; /* In */

include/linux/qed/qed_chain.h

124

u32 page_size;

include/linux/qed/qed_chain.h

153

u32 page_size;

include/linux/qed/qed_chain.h

163

#define ELEMS_PER_PAGE(elem_size, page_size) \

include/linux/qed/qed_chain.h

164

((page_size) / (elem_size))

include/linux/qed/qed_chain.h

171

#define USABLE_ELEMS_PER_PAGE(elem_size, page_size, mode) \

include/linux/qed/qed_chain.h

172

((u32)(ELEMS_PER_PAGE((elem_size), (page_size)) - \

include/linux/qed/qed_chain.h

175

#define QED_CHAIN_PAGE_CNT(elem_cnt, elem_size, page_size, mode) \

include/linux/qed/qed_chain.h

177

USABLE_ELEMS_PER_PAGE((elem_size), (page_size), (mode)))

include/linux/qed/qed_chain.h

635

p_chain->page_size);

include/linux/qed/qed_rdma_if.h

272

u16 page_size;

include/linux/spi/eeprom.h

17

u32 page_size; /* for writes */

include/linux/vfio.h

251

struct rb_root_cached *ranges, u32 nnodes, u64 *page_size);

include/rdma/ib_verbs.h

1990

unsigned int page_size;

include/rdma/ib_verbs.h

4738

unsigned int *sg_offset, unsigned int page_size);

include/rdma/ib_verbs.h

4742

unsigned int *meta_sg_offset, unsigned int page_size);

include/rdma/ib_verbs.h

4746

unsigned int *sg_offset, unsigned int page_size)

include/rdma/ib_verbs.h

4750

n = ib_map_mr_sg(mr, sg, sg_nents, sg_offset, page_size);

include/trace/events/habanalabs.h

17

TP_PROTO(struct device *dev, u64 virt_addr, u64 phys_addr, u32 page_size, bool flush_pte),

include/trace/events/habanalabs.h

19

TP_ARGS(dev, virt_addr, phys_addr, page_size, flush_pte),

include/trace/events/habanalabs.h

25

__field(u32, page_size)

include/trace/events/habanalabs.h

33

__entry->page_size = page_size;

include/trace/events/habanalabs.h

41

__entry->page_size,

include/trace/events/habanalabs.h

46

TP_PROTO(struct device *dev, u64 virt_addr, u64 phys_addr, u32 page_size, bool flush_pte),

include/trace/events/habanalabs.h

47

TP_ARGS(dev, virt_addr, phys_addr, page_size, flush_pte));

include/trace/events/habanalabs.h

50

TP_PROTO(struct device *dev, u64 virt_addr, u64 phys_addr, u32 page_size, bool flush_pte),

include/trace/events/habanalabs.h

51

TP_ARGS(dev, virt_addr, phys_addr, page_size, flush_pte));

include/uapi/drm/habanalabs_accel.h

1937

__u64 page_size;

include/uapi/linux/iommufd.h

843

__aligned_u64 page_size;

include/uapi/linux/vfio.h

1412

__aligned_u64 page_size;

include/uapi/linux/vfio.h

1460

__aligned_u64 page_size;

include/uapi/rdma/ocrdma-abi.h

87

__u32 page_size;

io_uring/rsrc.c

203

acct += page_size(hpage) >> PAGE_SHIFT;

io_uring/rsrc.c

753

acct_pages += page_size(hpage) >> PAGE_SHIFT;

kernel/trace/ring_buffer_benchmark.c

111

int page_size;

kernel/trace/ring_buffer_benchmark.c

121

page_size = ring_buffer_subbuf_size_get(buffer);

kernel/trace/ring_buffer_benchmark.c

122

ret = ring_buffer_read_page(buffer, bpage, page_size, cpu, 1);

kernel/trace/ring_buffer_benchmark.c

129

if (i >= (page_size - offsetof(struct rb_page, data))) {

kernel/trace/trace.c

7084

int page_size;

kernel/trace/trace.c

7094

page_size = ring_buffer_subbuf_size_get(iter->array_buffer->buffer);

kernel/trace/trace.c

7098

if (page_size != info->spare_size) {

kernel/trace/trace.c

7113

info->spare_size = page_size;

kernel/trace/trace.c

7120

if (info->read < page_size)

kernel/trace/trace.c

7150

size = page_size - info->read;

kernel/trace/trace.c

7271

int page_size;

kernel/trace/trace.c

7278

page_size = ring_buffer_subbuf_size_get(iter->array_buffer->buffer);

kernel/trace/trace.c

7279

if (*ppos & (page_size - 1))

kernel/trace/trace.c

7282

if (len & (page_size - 1)) {

kernel/trace/trace.c

7283

if (len < page_size)

kernel/trace/trace.c

7285

len &= (~(page_size - 1));

kernel/trace/trace.c

7295

for (i = 0; i < spd.nr_pages_max && len && entries; i++, len -= page_size) {

kernel/trace/trace.c

7328

spd.partial[i].len = page_size;

kernel/trace/trace.c

7332

*ppos += page_size;

lib/iov_iter.c

356

if (WARN_ON(n > v || v > page_size(head)))

mm/highmem.c

409

BUG_ON(end1 > page_size(page) || end2 > page_size(page));

mm/kasan/common.c

162

kasan_poison(page_address(page), page_size(page),

mm/kasan/common.c

438

redzone_end = (unsigned long)ptr + page_size(virt_to_page(ptr));

mm/kasan/common.c

527

kasan_poison(ptr, page_size(page), KASAN_PAGE_FREE, false);

mm/kmsan/hooks.c

118

kmsan_internal_poison_memory((void *)ptr, page_size(page),

mm/madvise.c

1471

size = page_size(compound_head(page));

mm/mmu_gather.c

168

int page_size)

mm/mmu_gather.c

176

VM_WARN_ON(tlb->page_size != page_size);

mm/mmu_gather.c

177

VM_WARN_ON_ONCE(nr_pages != 1 && page_size != PAGE_SIZE);

mm/mmu_gather.c

214

bool __tlb_remove_page_size(struct mmu_gather *tlb, struct page *page, int page_size)

mm/mmu_gather.c

216

return __tlb_remove_folio_pages_size(tlb, page, 1, false, page_size);

mm/mmu_gather.c

445

tlb->page_size = 0;

mm/slub.c

6553

return page_size(page);

mm/slub.c

6787

ks = page_size(page);

mm/usercopy.c

201

if (n > page_size(page) - offset)

mm/vmalloc.c

3367

unsigned long page_size;

mm/vmalloc.c

3369

page_size = PAGE_SIZE << page_order;

mm/vmalloc.c

3371

end = max(addr + page_size, end);

samples/vfio-mdev/mtty.c

1286

u32 nnodes, u64 *page_size)

tools/lib/bpf/libbpf.c

14244

munmap(cpu_buf->base, pb->mmap_size + pb->page_size))

tools/lib/bpf/libbpf.c

14302

cpu_buf->base = mmap(NULL, pb->mmap_size + pb->page_size,

tools/lib/bpf/libbpf.c

14435

pb->page_size = getpagesize();

tools/lib/bpf/libbpf.c

14436

pb->mmap_size = pb->page_size * page_cnt;

tools/lib/bpf/libbpf.c

14585

pb->page_size, &cpu_buf->buf,

tools/lib/bpf/ringbuf.c

123

tmp = mmap(NULL, rb->page_size, PROT_READ | PROT_WRITE, MAP_SHARED, map_fd, 0);

tools/lib/bpf/ringbuf.c

136

mmap_sz = rb->page_size + 2 * (__u64)info.max_entries;

tools/lib/bpf/ringbuf.c

142

tmp = mmap(NULL, (size_t)mmap_sz, PROT_READ, MAP_SHARED, map_fd, rb->page_size);

tools/lib/bpf/ringbuf.c

150

r->data = tmp + rb->page_size;

tools/lib/bpf/ringbuf.c

203

rb->page_size = getpagesize();

tools/lib/bpf/ringbuf.c

38

size_t page_size;

tools/lib/bpf/ringbuf.c

425

munmap(rb->consumer_pos, rb->page_size);

tools/lib/bpf/ringbuf.c

429

munmap(rb->producer_pos, rb->page_size + 2 * (rb->mask + 1));

tools/lib/bpf/ringbuf.c

475

tmp = mmap(NULL, rb->page_size, PROT_READ, MAP_SHARED, map_fd, 0);

tools/lib/bpf/ringbuf.c

489

mmap_sz = rb->page_size + 2 * (__u64)info.max_entries;

tools/lib/bpf/ringbuf.c

49

size_t page_size;

tools/lib/bpf/ringbuf.c

495

map_fd, rb->page_size);

tools/lib/bpf/ringbuf.c

504

rb->data = tmp + rb->page_size;

tools/lib/bpf/ringbuf.c

530

rb->page_size = getpagesize();

tools/lib/bpf/ringbuf.c

63

munmap(r->consumer_pos, rb->page_size);

tools/lib/bpf/ringbuf.c

67

munmap(r->producer_pos, rb->page_size + 2 * (r->mask + 1));

tools/lib/perf/core.c

36

page_size = sysconf(_SC_PAGE_SIZE);

tools/lib/perf/evlist.c

733

mp->mask = evlist->mmap_len - page_size - 1;

tools/lib/perf/evlist.c

761

evlist->mmap_len = (pages + 1) * page_size;

tools/lib/perf/evsel.c

264

.mask = (pages * page_size) - 1,

tools/lib/perf/include/internal/lib.h

7

extern unsigned int page_size;

tools/lib/perf/lib.c

8

unsigned int page_size;

tools/lib/perf/mmap.c

151

unsigned char *data = md->base + page_size;

tools/lib/perf/mmap.c

213

unsigned char *data = map->base + page_size;

tools/lib/perf/mmap.c

33

return map->mask + 1 + page_size;

tools/mm/page-types.c

1012

(void)*(volatile int *)(ptr + i * page_size);

tools/mm/page-types.c

1020

if (pagemap_read(buf, (unsigned long)ptr / page_size,

tools/mm/page-types.c

1040

add_page(off / page_size + i, pfn,

tools/mm/page-types.c

1054

add_addr_range(0, st->st_size / page_size);

tools/mm/page-types.c

1057

walk_file_range(name, fd, opt_offset[i] * page_size,

tools/mm/page-types.c

1058

(opt_offset[i] + opt_size[i]) * page_size);

tools/mm/page-types.c

1273

page_size = getpagesize();

tools/mm/page-types.c

182

static int page_size;

tools/mm/page-types.c

225

return (pages * page_size) >> 20;

tools/mm/page-types.c

927

pg_start[nr_vmas] = vm_start / page_size;

tools/mm/page-types.c

928

pg_end[nr_vmas] = vm_end / page_size;

tools/mm/page-types.c

945

size, (size + page_size - 1) / page_size);

tools/mm/page-types.c

985

nr_pages = (end - off + page_size - 1) / page_size;

tools/mm/page-types.c

988

len = nr_pages * page_size;

tools/mm/slabinfo.c

1426

page_size = getpagesize();

tools/mm/slabinfo.c

371

return s->slabs * (page_size << s->order);

tools/mm/slabinfo.c

576

s->slabs * (page_size << s->order));

tools/mm/slabinfo.c

581

page_size << s->order, s->partial, onoff(s->poison),

tools/mm/slabinfo.c

582

s->slabs * (page_size << s->order) - s->objects * s->object_size);

tools/mm/slabinfo.c

588

((page_size << s->order) - s->objs_per_slab * s->slab_size) *

tools/mm/slabinfo.c

671

(s->slabs * (page_size << s->order)) : 100,

tools/mm/slabinfo.c

97

int page_size;

tools/perf/arch/arm/util/cs-etm.c

376

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm/util/cs-etm.c

379

KiB(128) / page_size;

tools/perf/arch/arm/util/cs-etm.c

381

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm/util/cs-etm.c

385

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm/util/cs-etm.c

394

opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/arm/util/cs-etm.c

405

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/arm/util/cs-etm.c

411

opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/arm/util/cs-etm.c

414

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/arm/util/cs-etm.c

429

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm/util/cs-etm.c

431

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/arm/util/cs-etm.c

433

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

210

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

212

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

214

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

217

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

225

opts->auxtrace_snapshot_size = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/arm64/util/arm-spe.c

234

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

316

if (opts->auxtrace_snapshot_size > opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/arm64/util/arm-spe.c

319

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/arm64/util/arm-spe.c

338

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

340

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

342

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

348

size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/arm64/util/hisi-ptt.c

74

opts->auxtrace_mmap_pages = MiB(16) / page_size;

tools/perf/arch/arm64/util/hisi-ptt.c

76

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/arm64/util/hisi-ptt.c

78

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/hisi-ptt.c

84

size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/powerpc/util/auxtrace.c

32

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/powerpc/util/auxtrace.c

34

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/tests/amd-ibs-period.c

153

base = (void *)rb + page_size;

tools/perf/arch/x86/tests/amd-ibs-period.c

20

static int page_size;

tools/perf/arch/x86/tests/amd-ibs-period.c

23

#define PERF_MMAP_DATA_SIZE (PERF_MMAP_DATA_PAGES * page_size)

tools/perf/arch/x86/tests/amd-ibs-period.c

26

#define PERF_MMAP_TOTAL_SIZE (PERF_MMAP_TOTAL_PAGES * page_size)

tools/perf/arch/x86/tests/amd-ibs-period.c

62

p = calloc(2, page_size);

tools/perf/arch/x86/tests/amd-ibs-period.c

68

func = (void *)((unsigned long)(p + page_size - 1) & ~(page_size - 1));

tools/perf/arch/x86/tests/amd-ibs-period.c

70

ret = mprotect(func, page_size, PROT_READ | PROT_WRITE | PROT_EXEC);

tools/perf/arch/x86/tests/amd-ibs-period.c

944

page_size = sysconf(_SC_PAGESIZE);

tools/perf/arch/x86/util/intel-bts.c

159

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-bts.c

161

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-bts.c

163

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-bts.c

167

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-bts.c

171

opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-bts.c

175

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/x86/util/intel-bts.c

179

opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/x86/util/intel-bts.c

182

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/x86/util/intel-bts.c

196

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-bts.c

198

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-bts.c

200

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-bts.c

206

size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-pt.c

682

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-pt.c

684

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-pt.c

686

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

690

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

694

opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-pt.c

698

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/x86/util/intel-pt.c

702

opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/x86/util/intel-pt.c

705

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/x86/util/intel-pt.c

729

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

731

size_t sz = round_up(max_sz, page_size) / page_size;

tools/perf/arch/x86/util/intel-pt.c

735

if (max_sz > opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/x86/util/intel-pt.c

738

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/x86/util/intel-pt.c

752

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-pt.c

754

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-pt.c

756

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

762

size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-pt.c

778

size_t aw = opts->auxtrace_mmap_pages * (size_t)page_size / 4;

tools/perf/arch/x86/util/machine.c

62

u64 end = start + page_size;

tools/perf/bench/mem-functions.c

259

unsigned int page_size;

tools/perf/bench/mem-functions.c

288

page_size = (unsigned int)perf_atoll((char *)page_size_str);

tools/perf/bench/mem-functions.c

289

if (page_size != (1 << PAGE_SHIFT_4KB) &&

tools/perf/bench/mem-functions.c

290

page_size != (1 << PAGE_SHIFT_2MB) &&

tools/perf/bench/mem-functions.c

291

page_size != (1 << PAGE_SHIFT_1GB)) {

tools/perf/bench/mem-functions.c

295

p.page_shift = ilog2(page_size);

tools/perf/tests/mmap-thread-lookup.c

123

munmap(td0->map, page_size);

tools/perf/tests/mmap-thread-lookup.c

39

map = mmap(NULL, page_size,

tools/perf/tests/mmap-thread-lookup.c

76

munmap(td->map, page_size);

tools/perf/tests/vmlinux-kallsyms.c

317

if (llabs(skew) >= page_size)

tools/perf/util/aslr.c

136

return (addr + page_size - 1) & ~((u64)page_size - 1);

tools/perf/util/aslr.c

356

remap_addr += page_size;

tools/perf/util/auxtrace.c

1245

size_t adj = buffer->data_offset & (page_size - 1);

tools/perf/util/auxtrace.c

181

mp->len = auxtrace_pages * (size_t)page_size;

tools/perf/util/auxtrace.c

2585

size = round_up(start, page_size) + page_size - args->start;

tools/perf/util/bpf-event.c

736

.len = page_size,

tools/perf/util/copyfile.c

50

pgoff = off_in & ~(page_size - 1);

tools/perf/util/evlist.c

918

max -= (page_size / 1024);

tools/perf/util/evlist.c

921

pages = (max * 1024) / page_size;

tools/perf/util/evlist.c

935

return (pages + 1) * page_size;

tools/perf/util/evlist.c

956

pages = PERF_ALIGN(val, page_size) / page_size;

tools/perf/util/evlist.c

975

unit_number__scnprintf(buf, sizeof(buf), pages * page_size);

tools/perf/util/evlist.c

991

if (max > SIZE_MAX / page_size)

tools/perf/util/evlist.c

992

max = SIZE_MAX / page_size;

tools/perf/util/machine.c

1177

.end = va + page_size,

tools/perf/util/mmap.c

334

unsigned char *data = md->core.base + page_size;

tools/perf/util/python.c

2269

page_size = sysconf(_SC_PAGE_SIZE);

tools/perf/util/session.c

3258

if (event_size <= mmap_size - head % page_size) {

tools/perf/util/session.c

3423

page_offset = page_size * (rd->head / page_size);

tools/perf/util/srccode.c

128

sz = (h->maplen + page_size - 1) & ~(page_size - 1);

tools/perf/util/symbol-elf.c

1953

char *buf = malloc(page_size);

tools/perf/util/symbol-elf.c

1965

n = page_size;

tools/perf/util/symbol-elf.c

2109

.p_align = page_size,

tools/perf/util/symbol-elf.c

2323

u64 s = round_down(sdat->addr, page_size);

tools/perf/util/symbol-elf.c

2408

kci->stext = round_down(kci->stext, page_size);

tools/perf/util/symbol-elf.c

2410

kci->stext = round_down(kci->first_symbol, page_size);

tools/perf/util/symbol-elf.c

2413

kci->etext = round_up(kci->etext, page_size);

tools/perf/util/symbol-elf.c

2415

kci->etext = round_up(kci->last_symbol, page_size);

tools/perf/util/symbol-elf.c

2416

kci->etext += page_size;

tools/perf/util/symbol-elf.c

2423

kci->first_module = round_down(kci->first_module, page_size);

tools/perf/util/symbol-elf.c

2427

page_size);

tools/perf/util/symbol-elf.c

2428

kci->last_module_symbol += page_size;

tools/perf/util/symbol-elf.c

2474

buf_from = malloc(page_size);

tools/perf/util/symbol-elf.c

2475

buf_to = malloc(page_size);

tools/perf/util/symbol-elf.c

2481

ret = read(from, buf_from, page_size);

tools/perf/util/symbol-elf.c

2598

offset = round_up(offset, page_size);

tools/perf/util/symbol-elf.c

2650

off_t offset = page_size, sz;

tools/perf/util/synthetic-events.c

2442

sz = PERF_ALIGN(sz, page_size);

tools/perf/util/trace-event-info.c

586

if (write(output_fd, &page_size, 4) != 4)

tools/power/acpi/os_specific/service_layers/osunixmap.c

112

acpi_size page_size;

tools/power/acpi/os_specific/service_layers/osunixmap.c

114

page_size = acpi_os_get_page_size();

tools/power/acpi/os_specific/service_layers/osunixmap.c

115

offset = ACPI_TO_INTEGER(where) % page_size;

tools/power/acpi/os_specific/service_layers/osunixmap.c

67

acpi_size page_size;

tools/power/acpi/os_specific/service_layers/osunixmap.c

78

page_size = acpi_os_get_page_size();

tools/power/acpi/os_specific/service_layers/osunixmap.c

79

offset = where % page_size;

tools/testing/selftests/arm64/gcs/basic-gcs.c

188

buf = (void *)syscall(__NR_map_shadow_stack, 0, page_size,

tools/testing/selftests/arm64/gcs/basic-gcs.c

192

page_size, errno);

tools/testing/selftests/arm64/gcs/basic-gcs.c

196

(void *)((uint64_t)buf + page_size));

tools/testing/selftests/arm64/gcs/basic-gcs.c

199

elem = (page_size / sizeof(uint64_t)) - 1;

tools/testing/selftests/arm64/gcs/basic-gcs.c

20

static size_t page_size = 65536;

tools/testing/selftests/arm64/gcs/basic-gcs.c

207

expected_cap = ((uint64_t)buf + page_size - 16);

tools/testing/selftests/arm64/gcs/basic-gcs.c

218

for (elem = 0; elem < page_size / sizeof(uint64_t) - 2; elem++) {

tools/testing/selftests/arm64/gcs/basic-gcs.c

226

ret = munmap(buf, page_size);

tools/testing/selftests/arm64/gcs/basic-gcs.c

229

page_size, errno);

tools/testing/selftests/arm64/mte/check_buffer_fill.c

406

size_t page_size = getpagesize();

tools/testing/selftests/arm64/mte/check_buffer_fill.c

409

sizes[item - 3] = page_size - 1;

tools/testing/selftests/arm64/mte/check_buffer_fill.c

410

sizes[item - 2] = page_size;

tools/testing/selftests/arm64/mte/check_buffer_fill.c

411

sizes[item - 1] = page_size + 1;

tools/testing/selftests/arm64/mte/check_buffer_fill.c

442

evaluate_test(check_buffer_underflow_by_byte(USE_MMAP, MTE_SYNC_ERR, page_size),

tools/testing/selftests/arm64/mte/check_buffer_fill.c

444

evaluate_test(check_buffer_underflow_by_byte(USE_MMAP, MTE_ASYNC_ERR, page_size),

tools/testing/selftests/arm64/mte/check_buffer_fill.c

446

evaluate_test(check_buffer_underflow_by_byte(USE_MMAP, MTE_NONE_ERR, page_size),

tools/testing/selftests/arm64/mte/check_child_memory.c

149

page_size = getpagesize();

tools/testing/selftests/arm64/mte/check_child_memory.c

150

if (!page_size) {

tools/testing/selftests/arm64/mte/check_child_memory.c

154

sizes[item - 3] = page_size - 1;

tools/testing/selftests/arm64/mte/check_child_memory.c

155

sizes[item - 2] = page_size;

tools/testing/selftests/arm64/mte/check_child_memory.c

156

sizes[item - 1] = page_size + 1;

tools/testing/selftests/arm64/mte/check_child_memory.c

23

static size_t page_size;

tools/testing/selftests/arm64/mte/check_mmap_options.c

57

static size_t page_size;

tools/testing/selftests/arm64/mte/check_mmap_options.c

951

page_size = getpagesize();

tools/testing/selftests/arm64/mte/check_mmap_options.c

952

if (!page_size) {

tools/testing/selftests/arm64/mte/check_mmap_options.c

956

sizes[item - 3] = page_size - 1;

tools/testing/selftests/arm64/mte/check_mmap_options.c

957

sizes[item - 2] = page_size;

tools/testing/selftests/arm64/mte/check_mmap_options.c

958

sizes[item - 1] = page_size + 1;

tools/testing/selftests/arm64/signal/testcases/gcs_prot_none_fault.c

25

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/arm64/signal/testcases/gcs_prot_none_fault.c

28

page_size, 0);

tools/testing/selftests/arm64/signal/testcases/gcs_prot_none_fault.c

31

page_size, errno);

tools/testing/selftests/arm64/signal/testcases/gcs_write_fault.c

24

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/arm64/signal/testcases/gcs_write_fault.c

27

page_size, 0);

tools/testing/selftests/arm64/signal/testcases/gcs_write_fault.c

30

page_size, errno);

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

282

const size_t page_size = getpagesize();

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

301

tmp = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED,

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

310

tmp = mmap(NULL, page_size + 2 * args.ringbuf_sz, PROT_READ, MAP_SHARED,

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

311

r->map_fd, page_size);

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

317

r->data = tmp + page_size;

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

519

size_t page_size;

tools/testing/selftests/bpf/benchs/bench_ringbufs.c

553

base = ((void *)header) + pb->page_size;

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

17

long page_size;

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

20

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

21

if (!ASSERT_GE(page_size, 0, "get_page_size"))

tools/testing/selftests/bpf/prog_tests/btf_sysfs.c

28

end = (btf_size + page_size - 1) / page_size * page_size;

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

107

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

143

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

188

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

237

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

28

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

283

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

336

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

378

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

417

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/cgroup_getset_retval.c

64

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/core_reloc.c

982

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/bpf/prog_tests/core_reloc.c

983

return (sz + page_size - 1) / page_size * page_size;

tools/testing/selftests/bpf/prog_tests/map_ptr.c

14

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/map_ptr.c

27

skel->maps.m_ringbuf.max_entries = page_size;

tools/testing/selftests/bpf/prog_tests/map_ptr.c

33

skel->bss->page_size = page_size;

tools/testing/selftests/bpf/prog_tests/mmap.c

12

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/bpf/prog_tests/mmap.c

13

return (sz + page_size - 1) / page_size * page_size;

tools/testing/selftests/bpf/prog_tests/mmap.c

200

tmp0 = mmap(NULL, 4 * page_size, PROT_READ, MAP_SHARED | MAP_ANONYMOUS,

tools/testing/selftests/bpf/prog_tests/mmap.c

206

tmp1 = mmap(tmp0, 3 * page_size, PROT_READ, MAP_SHARED | MAP_FIXED,

tools/testing/selftests/bpf/prog_tests/mmap.c

209

munmap(tmp0, 4 * page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

21

const long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/bpf/prog_tests/mmap.c

214

err = munmap(tmp1 + page_size, page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

216

munmap(tmp1, 4 * page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

221

tmp2 = mmap(tmp1 + page_size, page_size, PROT_READ,

tools/testing/selftests/bpf/prog_tests/mmap.c

224

munmap(tmp1, page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

225

munmap(tmp1 + 2*page_size, 2 * page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

228

CHECK(tmp1 + page_size != tmp2, "adv_mmap4",

tools/testing/selftests/bpf/prog_tests/mmap.c

232

tmp2 = mmap(tmp1, 4 * page_size, PROT_READ, MAP_SHARED | MAP_FIXED,

tools/testing/selftests/bpf/prog_tests/mmap.c

235

munmap(tmp1, 4 * page_size); /* unmap page 1 */

tools/testing/selftests/bpf/prog_tests/mmap.c

250

munmap(tmp2, 4 * page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

253

tmp1 = mmap(NULL, 4 * page_size, PROT_READ, MAP_SHARED | MAP_FIXED,

tools/testing/selftests/bpf/prog_tests/mmap.c

254

data_map_fd, page_size /* initial page shift */);

tools/testing/selftests/bpf/prog_tests/mmap.c

256

munmap(tmp1, 4 * page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

36

err = bpf_map__set_max_entries(skel->maps.rdonly_map, page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

42

4 * (page_size / sizeof(u64)));

tools/testing/selftests/bpf/prog_tests/mmap.c

55

tmp1 = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, rdmap_fd, 0);

tools/testing/selftests/bpf/prog_tests/mmap.c

57

munmap(tmp1, page_size);

tools/testing/selftests/bpf/prog_tests/mmap.c

61

tmp1 = mmap(NULL, page_size, PROT_READ, MAP_SHARED, rdmap_fd, 0);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

109

mmap_ptr = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, rb_fd, 0);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

113

ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_rw");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

148

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/ringbuf.c

158

skel->maps.ringbuf.max_entries = page_size;

tools/testing/selftests/bpf/prog_tests/ringbuf.c

166

mmap_ptr = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, rb_fd, 0);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

168

tmp_ptr = mremap(mmap_ptr, page_size, 2 * page_size, MREMAP_MAYMOVE);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

171

ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_EXEC), "exec_cons_pos_protect");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

172

ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_rw");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

175

mmap_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd, page_size);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

181

mmap_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd, 2 * page_size);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

185

mmap_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd, 3 * page_size);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

187

mmap_ptr = mmap(NULL, 2 * page_size, PROT_WRITE, MAP_SHARED, rb_fd, 2 * page_size);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

191

mmap_ptr = mmap(NULL, 4 * page_size, PROT_READ, MAP_SHARED, rb_fd, 0);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

195

ASSERT_ERR(mprotect(mmap_ptr, 4 * page_size, PROT_WRITE), "write_protect");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

196

ASSERT_ERR(mprotect(mmap_ptr, 4 * page_size, PROT_EXEC), "exec_protect");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

197

ASSERT_ERR_PTR(mremap(mmap_ptr, 0, 4 * page_size, MREMAP_MAYMOVE), "ro_remap");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

198

ASSERT_OK(munmap(mmap_ptr, 4 * page_size), "unmap_ro");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

201

mmap_ptr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, rb_fd, page_size);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

205

ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_WRITE), "write_protect");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

206

ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_EXEC), "exec_protect");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

207

ASSERT_ERR_PTR(mremap(mmap_ptr, 0, 3 * page_size, MREMAP_MAYMOVE), "ro_remap");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

208

ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_ro");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

235

CHECK(skel->bss->ring_size != page_size,

tools/testing/selftests/bpf/prog_tests/ringbuf.c

237

(long)page_size, skel->bss->ring_size);

tools/testing/selftests/bpf/prog_tests/ringbuf.c

251

ASSERT_EQ(ring_size, page_size, "ring_ring_size");

tools/testing/selftests/bpf/prog_tests/ringbuf.c

506

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/ringbuf.c

513

size = page_size;

tools/testing/selftests/bpf/prog_tests/ringbuf.c

514

len1 = page_size / 2;

tools/testing/selftests/bpf/prog_tests/ringbuf.c

515

len2 = page_size / 4;

tools/testing/selftests/bpf/prog_tests/ringbuf.c

93

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

48

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

56

ASSERT_EQ(bpf_map__max_entries(skel->maps.ringbuf1), page_size, "rb1_size_before");

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

57

ASSERT_OK(bpf_map__set_max_entries(skel->maps.ringbuf1, page_size + 1), "rb1_resize");

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

58

ASSERT_EQ(bpf_map__max_entries(skel->maps.ringbuf1), 2 * page_size, "rb1_size_after");

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

59

ASSERT_OK(bpf_map__set_max_entries(skel->maps.ringbuf1, page_size), "rb1_reset");

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

60

ASSERT_EQ(bpf_map__max_entries(skel->maps.ringbuf1), page_size, "rb1_size_final");

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

62

proto_fd = bpf_map_create(BPF_MAP_TYPE_RINGBUF, NULL, 0, 0, page_size, NULL);

tools/testing/selftests/bpf/prog_tests/ringbuf_multi.c

78

if (!ASSERT_ERR(bpf_map__set_max_entries(skel->maps.ringbuf1, 3 * page_size), "rb1_resize_after_load"))

tools/testing/selftests/bpf/prog_tests/sockopt_inherit.c

112

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/sockopt_multi.c

271

obj->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/sockopt_qos_to_cc.c

45

skel->bss->page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/sockopt_sk.c

246

skel->bss->page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

384

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

394

mem = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

406

value.udata = mem + page_size - offsetof(struct user_data, b);

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

412

value.udata = mem + page_size - sizeof(struct user_data);

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

419

munmap(mem, page_size * 2);

tools/testing/selftests/bpf/prog_tests/test_mmap_inner_array.c

21

tmp = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, inner_array_fd, 0);

tools/testing/selftests/bpf/prog_tests/test_mmap_inner_array.c

54

munmap(tmp, page_size);

tools/testing/selftests/bpf/prog_tests/test_mmap_inner_array.c

9

const long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

2426

u64 page_size, umem_sz;

tools/testing/selftests/bpf/prog_tests/test_xsk.c

2434

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

2436

assert(umem_sz % page_size > MIN_PKT_SIZE);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

2437

assert(umem_sz % page_size < page_size - MIN_PKT_SIZE);

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

101

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

111

mmap_ptr = mmap(NULL, page_size, PROT_READ, MAP_SHARED, rb_fd, 0);

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

113

ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_WRITE), "write_cons_pos_protect");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

114

ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_EXEC), "exec_cons_pos_protect");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

115

ASSERT_ERR_PTR(mremap(mmap_ptr, 0, 4 * page_size, MREMAP_MAYMOVE), "wr_prod_pos");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

118

ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_ro_cons");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

121

mmap_ptr = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED,

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

122

rb_fd, page_size);

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

124

ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_EXEC), "exec_prod_pos_protect");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

127

ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_rw_prod");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

130

mmap_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd,

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

131

2 * page_size);

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

133

ASSERT_ERR(mprotect(mmap_ptr, page_size, PROT_EXEC), "exec_data_protect");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

136

ASSERT_OK(munmap(mmap_ptr, page_size), "unmap_rw_data");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

206

int rb_fd, page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

213

producer_pos_ptr = mmap(NULL, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

214

MAP_SHARED, rb_fd, page_size);

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

218

data_ptr = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, rb_fd, 2 * page_size);

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

231

ASSERT_OK(munmap(producer_pos_ptr, page_size), "unmap_producer_pos");

tools/testing/selftests/bpf/prog_tests/user_ringbuf.c

232

ASSERT_OK(munmap(data_ptr, page_size), "unmap_data_ptr");

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

360

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

365

test_xdp_adjust_tail_grow(page_size == 65536);

tools/testing/selftests/bpf/prog_tests/xdp_adjust_tail.c

371

if (page_size == 65536)

tools/testing/selftests/bpf/progs/cgroup_getset_retval_getsockopt.c

15

__u32 page_size = 0;

tools/testing/selftests/bpf/progs/cgroup_getset_retval_getsockopt.c

25

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/cgroup_getset_retval_getsockopt.c

40

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/cgroup_getset_retval_getsockopt.c

54

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/cgroup_getset_retval_setsockopt.c

14

__s32 page_size = 0;

tools/testing/selftests/bpf/progs/cgroup_getset_retval_setsockopt.c

23

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/cgroup_getset_retval_setsockopt.c

38

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/cgroup_getset_retval_setsockopt.c

53

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/cgroup_getset_retval_setsockopt.c

65

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/map_ptr_kern.c

15

int page_size = 0; /* userspace should set it */

tools/testing/selftests/bpf/progs/map_ptr_kern.c

671

VERIFY(check(&ringbuf->map, map, 0, 0, page_size));

tools/testing/selftests/bpf/progs/sockopt_inherit.c

107

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/sockopt_inherit.c

12

__s32 page_size = 0;

tools/testing/selftests/bpf/progs/sockopt_inherit.c

78

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/sockopt_multi.c

34

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/sockopt_multi.c

63

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/sockopt_multi.c

8

__s32 page_size = 0;

tools/testing/selftests/bpf/progs/sockopt_multi.c

87

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/sockopt_qos_to_cc.c

40

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/sockopt_qos_to_cc.c

7

__s32 page_size = 0;

tools/testing/selftests/bpf/progs/sockopt_sk.c

10

int page_size = 0; /* userspace should set it */

tools/testing/selftests/bpf/progs/sockopt_sk.c

104

if (optval_end - optval != page_size)

tools/testing/selftests/bpf/progs/sockopt_sk.c

134

if (ctx->optlen > page_size)

tools/testing/selftests/bpf/progs/sockopt_sk.c

209

if (ctx->optlen != page_size * 2)

tools/testing/selftests/bpf/progs/sockopt_sk.c

223

if (optval_end - optval != page_size)

tools/testing/selftests/bpf/progs/sockopt_sk.c

251

if (ctx->optlen > page_size)

tools/testing/selftests/cgroup/test_memcontrol.c

1796

page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/cgroup/test_memcontrol.c

1797

if (page_size <= 0)

tools/testing/selftests/cgroup/test_memcontrol.c

1798

page_size = BUF_SIZE;

tools/testing/selftests/cgroup/test_memcontrol.c

29

static int page_size;

tools/testing/selftests/cgroup/test_memcontrol.c

69

for (ptr = buf; ptr < buf + size; ptr += page_size)

tools/testing/selftests/cgroup/test_zswap.c

19

static int page_size;

tools/testing/selftests/cgroup/test_zswap.c

194

size_t allocation_size = page_size * 512;

tools/testing/selftests/cgroup/test_zswap.c

272

if (zswpin < MB(24) / page_size) {

tools/testing/selftests/cgroup/test_zswap.c

299

size_t memsize = page_size * 1024;

tools/testing/selftests/cgroup/test_zswap.c

300

char buf[page_size];

tools/testing/selftests/cgroup/test_zswap.c

315

for (int i = 0; i < page_size; i++)

tools/testing/selftests/cgroup/test_zswap.c

316

buf[i] = i < page_size/2 ? (char) i : 0;

tools/testing/selftests/cgroup/test_zswap.c

318

for (int i = 0; i < memsize; i += page_size)

tools/testing/selftests/cgroup/test_zswap.c

319

memcpy(&mem[i], buf, page_size);

tools/testing/selftests/cgroup/test_zswap.c

330

for (int i = 0; i < memsize; i += page_size) {

tools/testing/selftests/cgroup/test_zswap.c

331

if (memcmp(&mem[i], buf, page_size)) {

tools/testing/selftests/cgroup/test_zswap.c

455

size_t allocation_size = page_size * 1024;

tools/testing/selftests/cgroup/test_zswap.c

456

unsigned int nr_pages = allocation_size / page_size;

tools/testing/selftests/cgroup/test_zswap.c

461

snprintf(zswap_max_buf, sizeof(zswap_max_buf), "%d", page_size);

tools/testing/selftests/cgroup/test_zswap.c

483

off = (unsigned long)i * page_size;

tools/testing/selftests/cgroup/test_zswap.c

484

memset(&zw_allocation[off], 0, page_size);

tools/testing/selftests/cgroup/test_zswap.c

485

memset(&zw_allocation[off], 'a', page_size/4);

tools/testing/selftests/cgroup/test_zswap.c

497

off = (unsigned long)i * page_size;

tools/testing/selftests/cgroup/test_zswap.c

498

memset(&wb_allocation[off], 0, page_size);

tools/testing/selftests/cgroup/test_zswap.c

499

getrandom(&wb_allocation[off], page_size/4, 0);

tools/testing/selftests/cgroup/test_zswap.c

537

for (long i = 0; i < values->target_alloc_bytes; i += page_size)

tools/testing/selftests/cgroup/test_zswap.c

585

stored_pages_threshold = sys_info.totalram / 5 / page_size;

tools/testing/selftests/cgroup/test_zswap.c

612

for (int i = 0; i < trigger_allocation_size; i += page_size)

tools/testing/selftests/cgroup/test_zswap.c

623

int delta = stored_pages * page_size - zswapped;

tools/testing/selftests/cgroup/test_zswap.c

624

int result_ok = delta < stored_pages * page_size / 4;

tools/testing/selftests/cgroup/test_zswap.c

678

for (size_t i = 0; i < size; i += page_size)

tools/testing/selftests/cgroup/test_zswap.c

79

for (int i = 0; i < size; i += page_size)

tools/testing/selftests/cgroup/test_zswap.c

808

page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/cgroup/test_zswap.c

809

if (page_size <= 0)

tools/testing/selftests/cgroup/test_zswap.c

810

page_size = BUF_SIZE;

tools/testing/selftests/cgroup/test_zswap.c

83

for (int i = 0; i < size; i += page_size) {

tools/testing/selftests/cgroup/test_zswap.c

99

for (int i = 0; i < size; i += page_size)

tools/testing/selftests/drivers/dma-buf/udmabuf.c

203

page_size = getpagesize();

tools/testing/selftests/drivers/dma-buf/udmabuf.c

220

size = MEMFD_SIZE * page_size;

tools/testing/selftests/drivers/dma-buf/udmabuf.c

237

page_size = getpagesize() * 512; /* 2 MB */

tools/testing/selftests/drivers/dma-buf/udmabuf.c

238

size = MEMFD_SIZE * page_size;

tools/testing/selftests/drivers/dma-buf/udmabuf.c

255

page_size = getpagesize() * 512; /* 2 MB */

tools/testing/selftests/drivers/dma-buf/udmabuf.c

256

size = MEMFD_SIZE * page_size;

tools/testing/selftests/drivers/dma-buf/udmabuf.c

26

static unsigned int page_size;

tools/testing/selftests/drivers/dma-buf/udmabuf.c

91

for (i = 0; i < size / page_size; i++) {

tools/testing/selftests/drivers/dma-buf/udmabuf.c

92

*((char *)addr + (i * page_size)) = chr;

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

137

ring_size += page_size;

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

138

return ALIGN_UP(ring_size, page_size);

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

151

if (cfg_rx_buf_len && cfg_rx_buf_len != page_size) {

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

262

add_recvzc_oneshot(ring, connfd, page_size);

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

288

add_recvzc_oneshot(ring, connfd, page_size);

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

464

cfg_rx_buf_len = page_size * strtoul(optarg, NULL, 0);

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

494

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

495

if (page_size < 0)

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

498

if (posix_memalign((void **)&payload, page_size, SEND_SIZE))

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

58

static long page_size;

tools/testing/selftests/drivers/net/hw/iou-zcrx.c

59

#define AREA_SIZE (8192 * page_size)

tools/testing/selftests/futex/functional/futex_wait_uninitialized_heap.c

58

long page_size;

tools/testing/selftests/futex/functional/futex_wait_uninitialized_heap.c

62

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/futex/functional/futex_wait_uninitialized_heap.c

64

buf = mmap(NULL, page_size, PROT_READ|PROT_WRITE,

tools/testing/selftests/iommu/iommufd.c

2100

unsigned long page_size;

tools/testing/selftests/iommu/iommufd.c

2165

self->page_size = MOCK_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2166

self->bitmap_size = variant->buffer_size / self->page_size;

tools/testing/selftests/iommu/iommufd.c

2338

uint32_t page_size = MOCK_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2343

page_size = MOCK_HUGE_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2360

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2365

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2371

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2380

uint32_t page_size = MOCK_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2385

page_size = MOCK_HUGE_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2403

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2410

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2418

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd_utils.h

405

__u64 iova, size_t page_size,

tools/testing/selftests/iommu/iommufd_utils.h

414

.page_size = page_size,

tools/testing/selftests/iommu/iommufd_utils.h

425

#define test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, \

tools/testing/selftests/iommu/iommufd_utils.h

428

page_size, bitmap, flags))

tools/testing/selftests/iommu/iommufd_utils.h

431

__u64 iova, size_t page_size,

tools/testing/selftests/iommu/iommufd_utils.h

441

.page_size = page_size,

tools/testing/selftests/iommu/iommufd_utils.h

455

#define test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, page_size, \

tools/testing/selftests/iommu/iommufd_utils.h

459

page_size, bitmap, nr))

tools/testing/selftests/iommu/iommufd_utils.h

462

__u64 iova, size_t page_size,

tools/testing/selftests/iommu/iommufd_utils.h

467

unsigned long npte = pte_page_size / page_size, pteset = 2 * npte;

tools/testing/selftests/iommu/iommufd_utils.h

477

test_cmd_mock_domain_set_dirty(fd, hwpt_id, length, iova, page_size,

tools/testing/selftests/iommu/iommufd_utils.h

483

test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,

tools/testing/selftests/iommu/iommufd_utils.h

495

test_cmd_get_dirty_bitmap(fd, hwpt_id, length, iova, page_size, bitmap,

tools/testing/selftests/iommu/iommufd_utils.h

511

#define test_mock_dirty_bitmaps(hwpt_id, length, iova, page_size, pte_size,\

tools/testing/selftests/iommu/iommufd_utils.h

514

page_size, pte_size, bitmap, \

tools/testing/selftests/kvm/arm64/external_aborts.c

285

bad_pa = BIT(vm->pa_bits) - vm->page_size;

tools/testing/selftests/kvm/arm64/mmio_sign_ext.c

185

for (addr = gva & ~((uint64_t)vm->page_size - 1); addr < gva + len;

tools/testing/selftests/kvm/arm64/mmio_sign_ext.c

186

addr += vm->page_size)

tools/testing/selftests/kvm/arm64/mmio_sign_ext.c

216

make_el0_accessible(vm, MMIO_ADDR, vm->page_size);

tools/testing/selftests/kvm/arm64/page_fault_test.c

578

u64 guest_page_size = vm->page_size;

tools/testing/selftests/kvm/arm64/sea_to_user.c

259

guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;

tools/testing/selftests/kvm/arm64/vgic_lpi_stress.c

165

pages = sz / vm->page_size;

tools/testing/selftests/kvm/arm64/vgic_lpi_stress.c

166

gpa_base = ((vm_compute_max_gfn(vm) + 1) * vm->page_size) - sz;

tools/testing/selftests/kvm/dirty_log_test.c

310

if (vm->page_size < getpagesize())

tools/testing/selftests/kvm/dirty_log_test.c

624

guest_page_size = vm->page_size;

tools/testing/selftests/kvm/guest_memfd_test.c

101

kvm_mbind(mem + page_size * 2, page_size * 2, MPOL_BIND, &nodemask_0, maxnode, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

102

kvm_get_mempolicy(&policy, &nodemask, maxnode, mem + page_size * 2, MPOL_F_ADDR);

tools/testing/selftests/kvm/guest_memfd_test.c

115

ret = mbind(mem, page_size, 999, &nodemask_0, maxnode, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

138

pages[i] = (char *)mem + page_size * i;

tools/testing/selftests/kvm/guest_memfd_test.c

141

memset(mem, 0xaa, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

142

kvm_mbind(pages[0], page_size, MPOL_BIND, &node0_mask, maxnode, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

143

kvm_fallocate(fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 0, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

146

kvm_mbind(pages[0], page_size * 2, MPOL_BIND, &node1_mask, maxnode, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

147

kvm_mbind(pages[2], page_size * 2, MPOL_BIND, &node0_mask, maxnode, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

161

kvm_mbind(pages[0], page_size * 2, MPOL_BIND, &node0_mask, maxnode, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

162

kvm_mbind(pages[2], page_size * 2, MPOL_BIND, &node1_mask, maxnode, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

26

static size_t page_size;

tools/testing/selftests/kvm/guest_memfd_test.c

263

mem = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

278

TEST_ASSERT_EQ(sb.st_blksize, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

289

page_size - 1, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

292

ret = fallocate(fd, FALLOC_FL_KEEP_SIZE, total_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

295

ret = fallocate(fd, FALLOC_FL_KEEP_SIZE, total_size + page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

299

total_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

303

total_size + page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

307

page_size, page_size - 1);

tools/testing/selftests/kvm/guest_memfd_test.c

311

page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

314

ret = fallocate(fd, FALLOC_FL_KEEP_SIZE, page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

325

{0, page_size - 1},

tools/testing/selftests/kvm/guest_memfd_test.c

326

{0, page_size + 1},

tools/testing/selftests/kvm/guest_memfd_test.c

329

{1, page_size - 1},

tools/testing/selftests/kvm/guest_memfd_test.c

330

{1, page_size},

tools/testing/selftests/kvm/guest_memfd_test.c

331

{1, page_size + 1},

tools/testing/selftests/kvm/guest_memfd_test.c

333

{page_size, 1},

tools/testing/selftests/kvm/guest_memfd_test.c

334

{page_size, page_size - 1},

tools/testing/selftests/kvm/guest_memfd_test.c

335

{page_size, page_size + 1},

tools/testing/selftests/kvm/guest_memfd_test.c

353

fd, ALIGN_DOWN(INT64_MAX, page_size));

tools/testing/selftests/kvm/guest_memfd_test.c

364

for (size = 1; size < page_size; size++) {

tools/testing/selftests/kvm/guest_memfd_test.c

377

fd1 = __vm_create_guest_memfd(vm, page_size, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

382

TEST_ASSERT(st1.st_size == page_size, "memfd st_size should match requested size");

tools/testing/selftests/kvm/guest_memfd_test.c

384

fd2 = __vm_create_guest_memfd(vm, page_size * 2, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

389

TEST_ASSERT(st2.st_size == page_size * 2, "second memfd st_size should match requested size");

tools/testing/selftests/kvm/guest_memfd_test.c

393

TEST_ASSERT(st1.st_size == page_size, "first memfd st_size should still match requested size");

tools/testing/selftests/kvm/guest_memfd_test.c

407

fd = __vm_create_guest_memfd(vm, page_size, flag);

tools/testing/selftests/kvm/guest_memfd_test.c

433

__gmem_test(__test, __vm, __flags, page_size * 4)

tools/testing/selftests/kvm/guest_memfd_test.c

439

__gmem_test_vm(__test, __vm, __flags, page_size * 4)

tools/testing/selftests/kvm/guest_memfd_test.c

538

size = max_t(size_t, vm->page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

547

virt_map(vm, gpa, gpa, size / vm->page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

567

page_size = getpagesize();

tools/testing/selftests/kvm/guest_memfd_test.c

64

page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

67

for (i = 0; i < page_size; i++)

tools/testing/selftests/kvm/guest_memfd_test.c

72

memset(mem, val, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

94

kvm_mbind(mem, page_size * 2, MPOL_INTERLEAVE, &nodemask_0, maxnode, 0);

tools/testing/selftests/kvm/include/kvm_util.h

104

unsigned int page_size;

tools/testing/selftests/kvm/include/kvm_util.h

1268

return (v + vm->page_size - 1) & ~(vm->page_size - 1);

tools/testing/selftests/kvm/include/kvm_util.h

242

#define ptes_per_page(page_size) ((page_size) / 8)

tools/testing/selftests/kvm/include/kvm_util.h

248

#define ptes_per_page(page_size) ((page_size) / 8)

tools/testing/selftests/kvm/include/kvm_util.h

254

#define ptes_per_page(page_size) ((page_size) / 16)

tools/testing/selftests/kvm/include/kvm_util.h

264

#define ptes_per_page(page_size) ((page_size) / 8)

tools/testing/selftests/kvm/include/kvm_util.h

269

#define ptes_per_page(page_size) ((page_size) / 8)

tools/testing/selftests/kvm/include/kvm_util.h

281

unsigned int page_size;

tools/testing/selftests/kvm/include/ucall_common.h

43

int ucall_nr_pages_required(u64 page_size);

tools/testing/selftests/kvm/kvm_page_table_test.c

242

u64 guest_page_size = vm_guest_mode_params[mode].page_size;

tools/testing/selftests/kvm/lib/arm64/processor.c

113

size_t nr_pages = vm_page_align(vm, ptrs_per_pgd(vm) * 8) / vm->page_size;

tools/testing/selftests/kvm/lib/arm64/processor.c

131

TEST_ASSERT((gva % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/arm64/processor.c

133

" gva: 0x%lx vm->page_size: 0x%x", gva, vm->page_size);

tools/testing/selftests/kvm/lib/arm64/processor.c

136

TEST_ASSERT((gpa % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/arm64/processor.c

138

" gpa: 0x%lx vm->page_size: 0x%x", gpa, vm->page_size);

tools/testing/selftests/kvm/lib/arm64/processor.c

142

gpa, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/arm64/processor.c

236

return pte_addr(vm, *ptep) + (gva & (vm->page_size - 1));

tools/testing/selftests/kvm/lib/arm64/processor.c

422

stack_size = vm->page_size == 4096 ? DEFAULT_STACK_PGS * vm->page_size :

tools/testing/selftests/kvm/lib/arm64/processor.c

423

vm->page_size;

tools/testing/selftests/kvm/lib/arm64/processor.c

538

vm->handlers = __vm_alloc(vm, sizeof(struct handlers), vm->page_size,

tools/testing/selftests/kvm/lib/arm64/processor.c

62

return (vm->page_size == SZ_4K || vm->page_size == SZ_16K) &&

tools/testing/selftests/kvm/lib/arm64/ucall.c

13

gva_t mmio_gva = vm_unused_gva_gap(vm, vm->page_size, KVM_UTIL_MIN_VADDR);

tools/testing/selftests/kvm/lib/elf.c

160

gva_t seg_vstart = align_down(phdr.p_vaddr, vm->page_size);

tools/testing/selftests/kvm/lib/elf.c

162

seg_vend |= vm->page_size - 1;

tools/testing/selftests/kvm/lib/kvm_util.c

1004

gpa, npages, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

1011

vm, gpa, (gpa + npages * vm->page_size) - 1);

tools/testing/selftests/kvm/lib/kvm_util.c

1017

gpa, npages, vm->page_size,

tools/testing/selftests/kvm/lib/kvm_util.c

1114

region->region.memory_size = npages * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1375

u64 pages = (sz + vm->page_size - 1) >> vm->page_shift;

tools/testing/selftests/kvm/lib/kvm_util.c

1378

u64 pgidx_start = (min_gva + vm->page_size - 1) >> vm->page_shift;

tools/testing/selftests/kvm/lib/kvm_util.c

1379

if ((pgidx_start * vm->page_size) < min_gva)

tools/testing/selftests/kvm/lib/kvm_util.c

1435

return pgidx_start * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1441

u64 pages = (sz >> vm->page_shift) + ((sz % vm->page_size) != 0);

tools/testing/selftests/kvm/lib/kvm_util.c

1445

KVM_UTIL_MIN_PFN * vm->page_size,

tools/testing/selftests/kvm/lib/kvm_util.c

1456

pages--, gva += vm->page_size, gpa += vm->page_size) {

tools/testing/selftests/kvm/lib/kvm_util.c

1512

size_t page_size = vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1513

size_t size = npages * page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1521

gva += page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1522

gpa += page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1713

u32 page_size = getpagesize();

tools/testing/selftests/kvm/lib/kvm_util.c

1722

page_size * KVM_DIRTY_LOG_PAGE_OFFSET);

tools/testing/selftests/kvm/lib/kvm_util.c

1726

page_size * KVM_DIRTY_LOG_PAGE_OFFSET);

tools/testing/selftests/kvm/lib/kvm_util.c

1730

page_size * KVM_DIRTY_LOG_PAGE_OFFSET);

tools/testing/selftests/kvm/lib/kvm_util.c

1896

fprintf(stream, "%*spage_size: 0x%x\n", indent, "", vm->page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

2032

TEST_ASSERT((min_gpa % vm->page_size) == 0, "Min physical address "

tools/testing/selftests/kvm/lib/kvm_util.c

2035

min_gpa, vm->page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

2054

min_gpa, vm->page_size, memslot);

tools/testing/selftests/kvm/lib/kvm_util.c

2066

return base * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

2138

n = DIV_ROUND_UP(size, vm_guest_mode_params[mode].page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

296

vm->page_size = vm_guest_mode_params[vm->mode].page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

403

u64 page_size = vm_guest_mode_params[mode].page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

433

nr_pages += ucall_nr_pages_required(page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

986

size_t mem_size = npages * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

995

TEST_ASSERT((gpa % vm->page_size) == 0, "Guest physical "

tools/testing/selftests/kvm/lib/kvm_util.c

998

gpa, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

116

return pte_addr(vm, *ptep) + (gva & (vm->page_size - 1));

tools/testing/selftests/kvm/lib/loongarch/processor.c

124

TEST_ASSERT((gva % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/loongarch/processor.c

126

"gva: 0x%lx vm->page_size: 0x%x", gva, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

129

TEST_ASSERT((gpa % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/loongarch/processor.c

131

"gpa: 0x%lx vm->page_size: 0x%x", gpa, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

135

gpa, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

213

memset(addr, 0, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

357

val = __vm_alloc(vm, vm->page_size, LOONGARCH_GUEST_STACK_VADDR_MIN,

tools/testing/selftests/kvm/lib/loongarch/processor.c

360

val = val + vm->page_size;

tools/testing/selftests/kvm/lib/loongarch/processor.c

380

stack_size = vm->page_size;

tools/testing/selftests/kvm/lib/loongarch/ucall.c

16

gva_t mmio_gva = vm_unused_gva_gap(vm, vm->page_size, KVM_UTIL_MIN_VADDR);

tools/testing/selftests/kvm/lib/memstress.c

145

args->guest_page_size = vm_guest_mode_params[mode].page_size;

tools/testing/selftests/kvm/lib/riscv/processor.c

142

return pte_addr(vm, *ptep) + (gva & (vm->page_size - 1));

tools/testing/selftests/kvm/lib/riscv/processor.c

322

stack_size = vm->page_size == 4096 ? DEFAULT_STACK_PGS * vm->page_size :

tools/testing/selftests/kvm/lib/riscv/processor.c

323

vm->page_size;

tools/testing/selftests/kvm/lib/riscv/processor.c

451

vm->handlers = __vm_alloc(vm, sizeof(struct handlers), vm->page_size,

tools/testing/selftests/kvm/lib/riscv/processor.c

67

size_t nr_pages = vm_page_align(vm, ptrs_per_pte(vm) * 8) / vm->page_size;

tools/testing/selftests/kvm/lib/riscv/processor.c

83

TEST_ASSERT((gva % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/riscv/processor.c

85

" gva: 0x%lx vm->page_size: 0x%x", gva, vm->page_size);

tools/testing/selftests/kvm/lib/riscv/processor.c

88

TEST_ASSERT((gpa % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/riscv/processor.c

90

" gpa: 0x%lx vm->page_size: 0x%x", gpa, vm->page_size);

tools/testing/selftests/kvm/lib/riscv/processor.c

94

gpa, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

169

TEST_ASSERT(vm->page_size == PAGE_SIZE, "Unsupported page size: 0x%x",

tools/testing/selftests/kvm/lib/s390/processor.c

17

TEST_ASSERT(vm->page_size == PAGE_SIZE, "Unsupported page size: 0x%x",

tools/testing/selftests/kvm/lib/s390/processor.c

170

vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

18

vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

26

memset(addr_gpa2hva(vm, gpa), 0xff, PAGES_PER_REGION * vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

43

memset(addr_gpa2hva(vm, taddr), 0xff, PAGES_PER_REGION * vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

55

TEST_ASSERT((gva % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/s390/processor.c

58

gva, vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

61

TEST_ASSERT((gpa % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/s390/processor.c

64

gva, vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

68

gva, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

92

TEST_ASSERT(vm->page_size == PAGE_SIZE, "Unsupported page size: 0x%x",

tools/testing/selftests/kvm/lib/s390/processor.c

93

vm->page_size);

tools/testing/selftests/kvm/lib/ucall_common.c

17

int ucall_nr_pages_required(u64 page_size)

tools/testing/selftests/kvm/lib/ucall_common.c

19

return align_up(sizeof(struct ucall_header), page_size) / page_size;

tools/testing/selftests/kvm/lib/x86/processor.c

280

gpa, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/x86/processor.c

500

size_t page_size = PG_LEVEL_SIZE(level);

tools/testing/selftests/kvm/lib/x86/processor.c

501

size_t npages = size / page_size;

tools/testing/selftests/kvm/lib/x86/processor.c

508

l2_gpa += page_size;

tools/testing/selftests/kvm/lib/x86/processor.c

509

gpa += page_size;

tools/testing/selftests/kvm/lib/x86/sev.c

32

const u64 size = (j - i + 1) * vm->page_size;

tools/testing/selftests/kvm/lib/x86/sev.c

33

const u64 offset = (i - lowest_page_in_region) * vm->page_size;

tools/testing/selftests/kvm/memslot_modification_stress_test.c

60

u64 pages = max_t(int, vm->page_size, getpagesize()) / vm->page_size;

tools/testing/selftests/kvm/memslot_modification_stress_test.c

68

gpa = memstress_args.gpa - pages * vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

195

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

226

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

265

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

296

guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

300

TEST_ASSERT(data->vm->page_size == guest_page_size, "Invalid VM page size");

tools/testing/selftests/kvm/memslot_perf_test.c

355

sync->guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

452

u32 page_size = (typeof(page_size))READ_ONCE(sync->guest_page_size);

tools/testing/selftests/kvm/memslot_perf_test.c

463

ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

481

u32 page_size = (typeof(page_size))READ_ONCE(sync->guest_page_size);

tools/testing/selftests/kvm/memslot_perf_test.c

492

ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

500

ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

548

u32 page_size = (typeof(page_size))READ_ONCE(sync->guest_page_size);

tools/testing/selftests/kvm/memslot_perf_test.c

558

ptr < MEM_TEST_GPA + MEM_TEST_SIZE; ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

564

for (ptr = MEM_TEST_GPA + page_size / 2;

tools/testing/selftests/kvm/memslot_perf_test.c

565

ptr < MEM_TEST_GPA + MEM_TEST_SIZE; ptr += page_size) {

tools/testing/selftests/kvm/memslot_perf_test.c

583

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

643

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

669

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

684

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

724

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

751

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

761

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

770

u32 guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

931

u32 guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;

tools/testing/selftests/kvm/mmu_stress_test.c

124

vcpu_args_set(vcpu, 3, info->start_gpa, info->end_gpa, vm->page_size);

tools/testing/selftests/kvm/mmu_stress_test.c

220

~((u64)vm->page_size - 1);

tools/testing/selftests/kvm/mmu_stress_test.c

336

max_mem / vm_guest_mode_params[VM_MODE_DEFAULT].page_size,

tools/testing/selftests/kvm/mmu_stress_test.c

349

for (i = 0; i < slot_size; i += vm->page_size)

tools/testing/selftests/kvm/pre_fault_memory_test.c

176

alignment = guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

61

memset(addr_gva2hva(vm, hcall_in_page), 0x0, vm->page_size);

tools/testing/selftests/kvm/x86/hyperv_extended_hypercalls.c

65

memset(addr_gva2hva(vm, hcall_out_page), 0x0, vm->page_size);

tools/testing/selftests/kvm/x86/nested_tdp_fault_test.c

221

l2_test_page = vm_alloc(vm, vm->page_size, TEST1_VADDR);

tools/testing/selftests/kvm/x86/nested_tdp_fault_test.c

231

l2_test_page = vm_alloc(vm, vm->page_size, TEST2_VADDR);

tools/testing/selftests/kvm/x86/nested_tdp_fault_test.c

241

l2_test_page = vm_alloc(vm, vm->page_size, TEST3_VADDR);

tools/testing/selftests/kvm/x86/nested_tdp_fault_test.c

253

l2_test_page = vm_alloc(vm, vm->page_size, TEST4_VADDR);

tools/testing/selftests/kvm/x86/nx_huge_pages_test.c

133

nr_bytes = HPAGE_SLOT_NPAGES * vm->page_size;

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

348

for (i = 0; i < size; i += vm->page_size) {

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

349

size_t nr_bytes = min_t(size_t, vm->page_size, size - i);

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

401

BASE_DATA_SLOT + i, slot_size / vm->page_size,

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

413

virt_map(vm, gpa, gpa, PER_CPU_DATA_SIZE / vm->page_size);

tools/testing/selftests/landlock/base_test.c

27

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/landlock/base_test.c

28

char *const buf = malloc(page_size + 1);

tools/testing/selftests/landlock/base_test.c

50

ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size + 1, 0));

tools/testing/selftests/landlock/base_test.c

60

ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size, 0));

tools/testing/selftests/landlock/base_test.c

64

buf[page_size - 2] = '.';

tools/testing/selftests/landlock/base_test.c

65

ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size, 0));

tools/testing/selftests/landlock/base_test.c

68

ASSERT_EQ(-1, landlock_create_ruleset(ruleset_attr, page_size + 1, 0));

tools/testing/selftests/liveupdate/luo_test_utils.c

100

munmap(map, page_size);

tools/testing/selftests/liveupdate/luo_test_utils.c

120

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/liveupdate/luo_test_utils.c

129

map = mmap(NULL, page_size, PROT_READ, MAP_SHARED, mfd, 0);

tools/testing/selftests/liveupdate/luo_test_utils.c

142

munmap(map, page_size);

tools/testing/selftests/liveupdate/luo_test_utils.c

84

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/liveupdate/luo_test_utils.c

92

if (ftruncate(mfd, page_size) != 0)

tools/testing/selftests/liveupdate/luo_test_utils.c

95

map = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, mfd, 0);

tools/testing/selftests/liveupdate/luo_test_utils.c

99

snprintf(map, page_size, "%s", data);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

118

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

119

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

125

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

131

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

142

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

143

__u32 size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

144

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

146

__u64 *syscall_lsms = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

147

char *attr = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

188

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

192

ASSERT_EQ(0, read_proc_attr("current", attr, page_size));

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

200

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

205

if (read_proc_attr("exec", attr, page_size) == 0)

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

214

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

219

if (read_proc_attr("fscreate", attr, page_size) == 0)

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

228

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

233

if (read_proc_attr("keycreate", attr, page_size) == 0)

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

242

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

247

ASSERT_EQ(0, read_proc_attr("prev", attr, page_size));

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

256

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

261

if (read_proc_attr("sockcreate", attr, page_size) == 0)

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

29

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

30

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

42

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

43

__u32 size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

58

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

59

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

77

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

78

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

79

__u64 *syscall_lsms = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

86

size = page_size;

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

90

ASSERT_EQ(page_size, size);

tools/testing/selftests/lsm/lsm_get_self_attr_test.c

98

size = page_size;

tools/testing/selftests/lsm/lsm_list_modules_test.c

20

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_list_modules_test.c

21

__u64 *syscall_lsms = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_list_modules_test.c

33

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_list_modules_test.c

34

__u32 size = page_size;

tools/testing/selftests/lsm/lsm_list_modules_test.c

44

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_list_modules_test.c

45

__u64 *syscall_lsms = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_list_modules_test.c

59

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_list_modules_test.c

60

__u64 *syscall_lsms = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_list_modules_test.c

61

__u32 size = page_size;

tools/testing/selftests/lsm/lsm_list_modules_test.c

67

ASSERT_EQ(page_size, size);

tools/testing/selftests/lsm/lsm_list_modules_test.c

74

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_list_modules_test.c

75

__u32 size = page_size;

tools/testing/selftests/lsm/lsm_list_modules_test.c

76

__u64 *syscall_lsms = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_list_modules_test.c

77

char *sysfs_lsms = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_list_modules_test.c

85

ASSERT_EQ(0, read_sysfs_lsms(sysfs_lsms, page_size));

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

26

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

27

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

28

__u32 size = page_size;

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

42

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

43

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

44

__u32 size = page_size;

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

58

const long page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

59

struct lsm_ctx *ctx = calloc(page_size, 1);

tools/testing/selftests/lsm/lsm_set_self_attr_test.c

60

__u32 size = page_size;

tools/testing/selftests/mincore/mincore_selftest.c

107

mlock(addr, page_size);

tools/testing/selftests/mincore/mincore_selftest.c

108

retval = mincore(addr, page_size, vec);

tools/testing/selftests/mincore/mincore_selftest.c

118

munlock(addr, page_size);

tools/testing/selftests/mincore/mincore_selftest.c

119

madvise(addr, page_size, MADV_DONTNEED);

tools/testing/selftests/mincore/mincore_selftest.c

120

retval = mincore(addr, page_size, vec);

tools/testing/selftests/mincore/mincore_selftest.c

125

munmap(addr, page_size);

tools/testing/selftests/mincore/mincore_selftest.c

144

int page_size;

tools/testing/selftests/mincore/mincore_selftest.c

146

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mincore/mincore_selftest.c

149

addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mincore/mincore_selftest.c

158

retval = mincore(addr, page_size, vec);

tools/testing/selftests/mincore/mincore_selftest.c

165

mlock(addr, page_size);

tools/testing/selftests/mincore/mincore_selftest.c

166

retval = mincore(addr, page_size, vec);

tools/testing/selftests/mincore/mincore_selftest.c

172

munlock(addr, page_size);

tools/testing/selftests/mincore/mincore_selftest.c

173

munmap(addr, page_size);

tools/testing/selftests/mincore/mincore_selftest.c

193

int page_size;

tools/testing/selftests/mincore/mincore_selftest.c

198

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mincore/mincore_selftest.c

199

vec_size = FILE_SIZE / page_size;

tools/testing/selftests/mincore/mincore_selftest.c

200

if (FILE_SIZE % page_size)

tools/testing/selftests/mincore/mincore_selftest.c

251

ASSERT_EQ(1, vec[FILE_SIZE / 2 / page_size]) {

tools/testing/selftests/mincore/mincore_selftest.c

255

i = FILE_SIZE / 2 / page_size + 1;

tools/testing/selftests/mincore/mincore_selftest.c

294

int page_size;

tools/testing/selftests/mincore/mincore_selftest.c

298

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mincore/mincore_selftest.c

299

vec_size = FILE_SIZE / page_size;

tools/testing/selftests/mincore/mincore_selftest.c

300

if (FILE_SIZE % page_size)

tools/testing/selftests/mincore/mincore_selftest.c

33

int page_size;

tools/testing/selftests/mincore/mincore_selftest.c

344

ASSERT_EQ(1, vec[FILE_SIZE / 2 / page_size]) {

tools/testing/selftests/mincore/mincore_selftest.c

37

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mincore/mincore_selftest.c

45

retval = mincore(NULL, page_size, vec);

tools/testing/selftests/mincore/mincore_selftest.c

50

addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mincore/mincore_selftest.c

58

retval = mincore(addr + 1, page_size, vec);

tools/testing/selftests/mincore/mincore_selftest.c

70

retval = mincore(addr, page_size, NULL);

tools/testing/selftests/mincore/mincore_selftest.c

73

munmap(addr, page_size);

tools/testing/selftests/mincore/mincore_selftest.c

88

int page_size;

tools/testing/selftests/mincore/mincore_selftest.c

90

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mincore/mincore_selftest.c

94

addr = mmap(NULL, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mincore/mincore_selftest.c

99

retval = mincore(addr, page_size, vec);

tools/testing/selftests/mm/compaction_test.c

131

size_t page_size, i;

tools/testing/selftests/mm/compaction_test.c

153

page_size = getpagesize();

tools/testing/selftests/mm/compaction_test.c

178

for (i = 0; i < MAP_SIZE; i += page_size)

tools/testing/selftests/mm/folio_split_race_test.c

199

if (madvise(mmap_base + i * page_size,

tools/testing/selftests/mm/folio_split_race_test.c

200

PUNCH_SIZE_FACTOR * page_size, MADV_REMOVE) != 0) {

tools/testing/selftests/mm/folio_split_race_test.c

237

page_size = getpagesize();

tools/testing/selftests/mm/folio_split_race_test.c

30

uint64_t page_size;

tools/testing/selftests/mm/folio_split_race_test.c

34

#define TOTAL_PAGES (FILE_SIZE / page_size)

tools/testing/selftests/mm/folio_split_race_test.c

54

unsigned char *page_ptr = base + page_idx * page_size;

tools/testing/selftests/mm/folio_split_race_test.c

57

memset(page_ptr, FILL_BYTE, page_size);

tools/testing/selftests/mm/folio_split_race_test.c

64

unsigned char *page_ptr = base + page_idx * page_size;

tools/testing/selftests/mm/folio_split_race_test.c

74

for (off = 0; off < page_size; off++) {

tools/testing/selftests/mm/folio_split_race_test.c

85

(page_idx * page_size) / pmd_pagesize);

tools/testing/selftests/mm/folio_split_race_test.c

92

(page_idx * page_size) / pmd_pagesize,

tools/testing/selftests/mm/guard-regions.c

1001

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1007

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1018

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1022

ptr = mmap_(self, variant, NULL, 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

1027

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1028

ASSERT_EQ(madvise(&ptr[4 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1032

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1037

ptr_new = mmap_(self, variant, NULL, 5 * page_size, PROT_NONE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1040

ASSERT_EQ(mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

1045

ASSERT_FALSE(try_read_write_buf(&ptr_new[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1051

munmap(ptr_new, 5 * page_size);

tools/testing/selftests/mm/guard-regions.c

1064

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1068

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1072

ASSERT_EQ(munmap(&ptr[5 * page_size], 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1075

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1076

ASSERT_EQ(madvise(&ptr[4 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1080

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1083

ptr = mremap(ptr, 5 * page_size, 10 * page_size, 0);

tools/testing/selftests/mm/guard-regions.c

1090

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1093

ptr_new = mmap_(self, variant, NULL, 20 * page_size, PROT_NONE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1097

ptr = mremap(ptr, 10 * page_size, 20 * page_size,

tools/testing/selftests/mm/guard-regions.c

1105

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1114

munmap(ptr, 20 * page_size);

tools/testing/selftests/mm/guard-regions.c

1126

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1131

ptr = mmap_(self, variant, NULL, 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

1136

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1137

ASSERT_EQ(madvise(&ptr[4 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1141

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1144

ptr = mremap(ptr, 5 * page_size, 3 * page_size, MREMAP_MAYMOVE);

tools/testing/selftests/mm/guard-regions.c

1152

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1167

ptr = mremap(ptr, 3 * page_size, 5 * page_size, 0);

tools/testing/selftests/mm/guard-regions.c

1175

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1181

munmap(ptr, 5 * page_size);

tools/testing/selftests/mm/guard-regions.c

1190

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1196

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1201

ASSERT_EQ(madvise(ptr, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1210

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1217

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1229

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1236

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1245

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1254

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1259

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1271

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1279

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1281

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1287

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1302

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1310

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1319

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1328

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1333

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_WIPEONFORK), 0);

tools/testing/selftests/mm/guard-regions.c

1336

ASSERT_EQ(madvise(ptr, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1345

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1359

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1366

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1372

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1380

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1385

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1389

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1395

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_FREE), 0);

tools/testing/selftests/mm/guard-regions.c

1399

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1405

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1411

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1415

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1420

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1423

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_POPULATE_READ), -1);

tools/testing/selftests/mm/guard-regions.c

1427

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_POPULATE_WRITE), -1);

tools/testing/selftests/mm/guard-regions.c

1431

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1437

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1442

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1447

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1451

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1457

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_COLD), 0);

tools/testing/selftests/mm/guard-regions.c

1461

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1467

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_PAGEOUT), 0);

tools/testing/selftests/mm/guard-regions.c

1471

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1477

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1483

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1519

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1525

range.len = 10 * page_size;

tools/testing/selftests/mm/guard-regions.c

1531

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1535

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1543

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1558

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1563

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1568

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1569

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1572

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_SEQUENTIAL), 0);

tools/testing/selftests/mm/guard-regions.c

1576

char *ptr2 = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1578

ASSERT_EQ(madvise(ptr2, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1582

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_PAGEOUT), 0);

tools/testing/selftests/mm/guard-regions.c

1586

char *chrp = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1598

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1601

if (!check_pattern(ptr, 10, page_size))

tools/testing/selftests/mm/guard-regions.c

1604

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1613

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1620

ptr_shared = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1624

ptr_private = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, self->fd, 0);

tools/testing/selftests/mm/guard-regions.c

1628

set_pattern(ptr_shared, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1632

char *ptr = &ptr_shared[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1634

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1639

ASSERT_EQ(try_read_buf(&ptr_shared[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1641

ASSERT_TRUE(try_read_buf(&ptr_private[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1646

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1648

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1653

ASSERT_EQ(try_read_buf(&ptr_shared[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1655

ASSERT_EQ(try_read_buf(&ptr_private[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1659

ASSERT_EQ(madvise(ptr_shared, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1663

ASSERT_TRUE(try_read_buf(&ptr_shared[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1665

ASSERT_EQ(try_read_buf(&ptr_private[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1669

ASSERT_EQ(madvise(ptr_private, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1673

ASSERT_TRUE(try_read_buf(&ptr_shared[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1675

ASSERT_TRUE(try_read_buf(&ptr_private[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1679

ASSERT_TRUE(check_pattern(ptr_shared, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1680

ASSERT_TRUE(check_pattern(ptr_private, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1684

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1686

memset(ptr, 'a' + i, page_size);

tools/testing/selftests/mm/guard-regions.c

1699

ASSERT_EQ(madvise(ptr_private, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1709

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1714

ASSERT_TRUE(try_read_buf(&ptr_shared[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1718

ASSERT_EQ(madvise(ptr_private, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1732

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1739

char *ptr_s = &ptr_shared[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1741

ASSERT_EQ(memcmp(ptr, ptr_s, page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1746

ASSERT_TRUE(is_buf_eq(ptr, page_size, 'a' + i));

tools/testing/selftests/mm/guard-regions.c

1749

ASSERT_EQ(munmap(ptr_shared, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1750

ASSERT_EQ(munmap(ptr_private, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1756

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1764

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1767

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1768

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1776

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1781

char *ptr_pg = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1783

ASSERT_EQ(madvise(ptr_pg, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1788

char *ptr_pg = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1794

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1797

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1799

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1804

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1811

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1816

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1822

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_PAGEOUT), 0);

tools/testing/selftests/mm/guard-regions.c

1825

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1826

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1832

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1834

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1839

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1846

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1851

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1856

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1863

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1871

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1875

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1877

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1882

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1888

ASSERT_EQ(ftruncate(self->fd, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1892

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1898

ASSERT_EQ(ftruncate(self->fd, 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1899

ASSERT_EQ(ftruncate(self->fd, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1903

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1908

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1913

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1921

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1924

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1927

ASSERT_EQ(madvise(&ptr[3 * page_size], 4 * page_size,

tools/testing/selftests/mm/guard-regions.c

1941

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1947

ASSERT_EQ(madvise(&ptr[3 * page_size], 4 * page_size,

tools/testing/selftests/mm/guard-regions.c

1952

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1958

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1961

ASSERT_TRUE(check_pattern(ptr, 3, page_size));

tools/testing/selftests/mm/guard-regions.c

1963

ASSERT_TRUE(is_buf_eq(&ptr[3 * page_size], 4 * page_size, '\0'));

tools/testing/selftests/mm/guard-regions.c

1965

ASSERT_TRUE(check_pattern_offset(ptr, 3, page_size, 7));

tools/testing/selftests/mm/guard-regions.c

1967

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1977

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1991

ASSERT_EQ(ftruncate(self->fd, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1994

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1996

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1997

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2003

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ, 0, 0);

tools/testing/selftests/mm/guard-regions.c

2007

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

2011

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2013

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2018

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2024

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

2027

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

2031

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2036

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2048

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2056

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ, 0, 0);

tools/testing/selftests/mm/guard-regions.c

2061

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2063

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2068

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2074

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

2078

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2084

ASSERT_TRUE(is_buf_eq(ptr, 10 * page_size, '\0'));

tools/testing/selftests/mm/guard-regions.c

2086

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2094

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2102

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

2108

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2117

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2119

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2124

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2132

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

214

static void set_pattern(char *ptr, size_t num_pages, size_t page_size)

tools/testing/selftests/mm/guard-regions.c

2140

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2155

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

2160

pm_scan_args.end = (long)ptr + 10 * page_size;

tools/testing/selftests/mm/guard-regions.c

2162

ASSERT_EQ(pm_scan_args.walk_end, (long)ptr + 10 * page_size);

tools/testing/selftests/mm/guard-regions.c

2166

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2168

ASSERT_EQ(syscall(__NR_madvise, ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2176

ASSERT_EQ(pm_scan_args.walk_end, (long)ptr + 10 * page_size);

tools/testing/selftests/mm/guard-regions.c

2180

long ptr_p = (long)&ptr[2 * i * page_size];

tools/testing/selftests/mm/guard-regions.c

2183

ASSERT_EQ(pm_regs[i].end, ptr_p + page_size);

tools/testing/selftests/mm/guard-regions.c

2188

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

219

char *ptr2 = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2193

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2195

const unsigned long num_pages = size / page_size;

tools/testing/selftests/mm/guard-regions.c

221

memset(ptr2, 'a' + (i % 26), page_size);

tools/testing/selftests/mm/guard-regions.c

2216

char *ptr_page = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2218

ASSERT_EQ(madvise(ptr_page, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2242

char *ptr_page = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2251

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2257

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

2264

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2274

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

2279

ASSERT_EQ(madvise(&ptr[i * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2285

ASSERT_EQ(munmap(&ptr[4 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2289

ASSERT_TRUE(check_vmflag_guard(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

229

static bool check_pattern_offset(char *ptr, size_t num_pages, size_t page_size,

tools/testing/selftests/mm/guard-regions.c

2302

ptr2 = mmap_(self, variant, &ptr[4 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

2303

PROT_READ | PROT_WRITE, MAP_FIXED, 4 * page_size);

tools/testing/selftests/mm/guard-regions.c

2314

ASSERT_EQ(procmap.query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/guard-regions.c

234

for (i = 0; i < num_pages * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

235

size_t offset = pgoff * page_size + i;

tools/testing/selftests/mm/guard-regions.c

237

char expected = 'a' + ((offset / page_size) % 26);

tools/testing/selftests/mm/guard-regions.c

247

static bool check_pattern(char *ptr, size_t num_pages, size_t page_size)

tools/testing/selftests/mm/guard-regions.c

249

return check_pattern_offset(ptr, num_pages, page_size, 0);

tools/testing/selftests/mm/guard-regions.c

278

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

286

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

290

munmap(&ptr[5 * page_size], page_size);

tools/testing/selftests/mm/guard-regions.c

293

ptr2 = mmap_(self, variant, &ptr[5 * page_size], page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/guard-regions.c

294

MAP_FIXED, 5 * page_size);

tools/testing/selftests/mm/guard-regions.c

306

if (procmap.query.vma_end != (unsigned long)ptr + 10 * page_size)

tools/testing/selftests/mm/guard-regions.c

315

self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/guard-regions.c

330

ASSERT_EQ(ftruncate(self->fd, 100 * self->page_size), 0);

tools/testing/selftests/mm/guard-regions.c

350

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

354

ptr = mmap_(self, variant, NULL, NUM_PAGES * page_size,

tools/testing/selftests/mm/guard-regions.c

361

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

368

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

374

ASSERT_EQ(madvise(&ptr[(NUM_PAGES - 1) * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

379

ASSERT_FALSE(try_read_write_buf(&ptr[(NUM_PAGES - 1) * page_size]));

tools/testing/selftests/mm/guard-regions.c

382

ASSERT_FALSE(madvise(ptr, page_size, MADV_GUARD_REMOVE));

tools/testing/selftests/mm/guard-regions.c

388

ASSERT_FALSE(madvise(&ptr[(NUM_PAGES - 1) * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

392

ASSERT_TRUE(try_read_write_buf(&ptr[(NUM_PAGES - 1) * page_size]));

tools/testing/selftests/mm/guard-regions.c

399

ASSERT_EQ(madvise(ptr, 3 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

403

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

410

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

416

ASSERT_EQ(madvise(ptr, NUM_PAGES * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

420

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

429

ASSERT_EQ(madvise(ptr, NUM_PAGES * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

431

for (i = 0; i < NUM_PAGES * page_size; i += page_size) {

tools/testing/selftests/mm/guard-regions.c

437

ASSERT_EQ(munmap(ptr, NUM_PAGES * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

443

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

448

ptr_region = mmap_(self, variant, NULL, 100 * page_size,

tools/testing/selftests/mm/guard-regions.c

453

ptr1 = mmap_(self, variant, ptr_region, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

458

ptr2 = mmap_(self, variant, &ptr_region[50 * page_size], 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

463

ptr3 = mmap_(self, variant, &ptr_region[80 * page_size], 20 * page_size,

tools/testing/selftests/mm/guard-regions.c

468

ASSERT_EQ(munmap(&ptr_region[10 * page_size], 40 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

469

ASSERT_EQ(munmap(&ptr_region[55 * page_size], 25 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

489

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_INSTALL), -1);

tools/testing/selftests/mm/guard-regions.c

493

char *curr = &ptr1[i * page_size];

tools/testing/selftests/mm/guard-regions.c

499

char *curr = &ptr2[i * page_size];

tools/testing/selftests/mm/guard-regions.c

50

unsigned long page_size;

tools/testing/selftests/mm/guard-regions.c

505

char *curr = &ptr3[i * page_size];

tools/testing/selftests/mm/guard-regions.c

512

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_REMOVE), -1);

tools/testing/selftests/mm/guard-regions.c

516

char *curr = &ptr1[i * page_size];

tools/testing/selftests/mm/guard-regions.c

522

char *curr = &ptr2[i * page_size];

tools/testing/selftests/mm/guard-regions.c

528

char *curr = &ptr3[i * page_size];

tools/testing/selftests/mm/guard-regions.c

534

ptr = mmap_(self, variant, &ptr_region[10 * page_size], 40 * page_size,

tools/testing/selftests/mm/guard-regions.c

537

ptr = mmap_(self, variant, &ptr_region[55 * page_size], 25 * page_size,

tools/testing/selftests/mm/guard-regions.c

552

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

554

char *curr = &ptr_region[i * page_size];

tools/testing/selftests/mm/guard-regions.c

558

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

560

char *curr = &ptr_region[i * page_size];

tools/testing/selftests/mm/guard-regions.c

566

ASSERT_EQ(munmap(ptr_region, 100 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

575

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

581

ptr_region = mmap_(self, variant, NULL, 100 * page_size,

tools/testing/selftests/mm/guard-regions.c

590

ptr1 = mmap_(self, variant, &ptr_region[page_size], 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

595

vec[0].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

596

vec[1].iov_base = &ptr1[9 * page_size];

tools/testing/selftests/mm/guard-regions.c

597

vec[1].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

600

ptr2 = mmap_(self, variant, &ptr_region[50 * page_size], 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

604

vec[2].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

605

vec[3].iov_base = &ptr2[4 * page_size];

tools/testing/selftests/mm/guard-regions.c

606

vec[3].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

609

ptr3 = mmap_(self, variant, &ptr_region[79 * page_size], 20 * page_size,

tools/testing/selftests/mm/guard-regions.c

613

vec[4].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

614

vec[5].iov_base = &ptr3[19 * page_size];

tools/testing/selftests/mm/guard-regions.c

615

vec[5].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

618

ASSERT_EQ(munmap(ptr_region, page_size), 0);

tools/testing/selftests/mm/guard-regions.c

619

ASSERT_EQ(munmap(&ptr_region[11 * page_size], 39 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

620

ASSERT_EQ(munmap(&ptr_region[55 * page_size], 24 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

621

ASSERT_EQ(munmap(&ptr_region[99 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

631

ASSERT_EQ(count, 6 * page_size);

tools/testing/selftests/mm/guard-regions.c

636

ASSERT_FALSE(try_read_write_buf(&ptr1[9 * page_size]));

tools/testing/selftests/mm/guard-regions.c

639

ASSERT_FALSE(try_read_write_buf(&ptr2[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

642

ASSERT_FALSE(try_read_write_buf(&ptr3[19 * page_size]));

tools/testing/selftests/mm/guard-regions.c

650

ASSERT_TRUE(try_read_write_buf(&ptr1[9 * page_size]));

tools/testing/selftests/mm/guard-regions.c

653

ASSERT_TRUE(try_read_write_buf(&ptr2[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

656

ASSERT_TRUE(try_read_write_buf(&ptr3[19 * page_size]));

tools/testing/selftests/mm/guard-regions.c

659

ASSERT_EQ(munmap(ptr1, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

660

ASSERT_EQ(munmap(ptr2, 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

661

ASSERT_EQ(munmap(ptr3, 20 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

667

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

670

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

675

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

676

ASSERT_EQ(madvise(&ptr[9 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

680

ASSERT_FALSE(try_read_write_buf(&ptr[9 * page_size]));

tools/testing/selftests/mm/guard-regions.c

683

ASSERT_EQ(munmap(ptr, page_size), 0);

tools/testing/selftests/mm/guard-regions.c

684

ASSERT_EQ(munmap(&ptr[9 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

687

ptr_new1 = mmap_(self, variant, ptr, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/guard-regions.c

690

ptr_new2 = mmap_(self, variant, &ptr[9 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

699

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

705

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

709

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

714

ASSERT_EQ(madvise(&ptr[5 * page_size], 2 * page_size,

tools/testing/selftests/mm/guard-regions.c

718

ASSERT_FALSE(try_read_write_buf(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

719

ASSERT_FALSE(try_read_write_buf(&ptr[6 * page_size]));

tools/testing/selftests/mm/guard-regions.c

722

ASSERT_EQ(mprotect(&ptr[5 * page_size], 2 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

725

ASSERT_FALSE(try_read_buf(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

726

ASSERT_FALSE(try_read_buf(&ptr[6 * page_size]));

tools/testing/selftests/mm/guard-regions.c

729

ASSERT_EQ(madvise(&ptr[5 * page_size], 2 * page_size,

tools/testing/selftests/mm/guard-regions.c

733

ASSERT_FALSE(try_read_buf(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

734

ASSERT_FALSE(try_read_buf(&ptr[6 * page_size]));

tools/testing/selftests/mm/guard-regions.c

737

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

741

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

747

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

753

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

757

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

762

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

766

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

772

ASSERT_EQ(munmap(&ptr[2 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

773

ASSERT_EQ(munmap(&ptr[5 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

774

ASSERT_EQ(munmap(&ptr[8 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

778

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

783

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

788

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

793

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

799

ptr_new = mmap_(self, variant, &ptr[2 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

802

ptr_new = mmap_(self, variant, &ptr[5 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

805

ptr_new = mmap_(self, variant, &ptr[8 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

811

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

819

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

823

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

829

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

830

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

834

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

840

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ | PROT_WRITE), 0);

tools/testing/selftests/mm/guard-regions.c

841

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size,

tools/testing/selftests/mm/guard-regions.c

846

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

852

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

853

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

856

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

860

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

866

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ | PROT_WRITE), 0);

tools/testing/selftests/mm/guard-regions.c

867

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size,

tools/testing/selftests/mm/guard-regions.c

872

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

878

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

884

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

888

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

894

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

901

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

902

int res = madvise(curr, page_size, MADV_GUARD_INSTALL);

tools/testing/selftests/mm/guard-regions.c

908

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_DONTNEED), 0);

tools/testing/selftests/mm/guard-regions.c

912

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

932

result = try_write_buf(&ptr[i * page_size]);

tools/testing/selftests/mm/guard-regions.c

939

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

945

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

949

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

955

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

961

ASSERT_EQ(mlock(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

964

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), -1);

tools/testing/selftests/mm/guard-regions.c

968

ASSERT_EQ(munlock(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

971

ASSERT_EQ(madvise(ptr, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

975

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

991

ASSERT_EQ(mlock(&ptr[5 * page_size], 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

997

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/hmm-tests.c

1006

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

103

unsigned int page_size;

tools/testing/selftests/mm/hmm-tests.c

1057

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1113

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1163

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1225

ret = munmap(buffer->ptr + self->page_size, self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1233

ret = mprotect(buffer->ptr + 2 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1236

ptr = (int *)(buffer->ptr + 2 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1241

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1244

ptr = (int *)(buffer->ptr + 3 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1246

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1251

ret = mprotect(buffer->ptr + 4 * self->page_size, 2 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1254

ptr = (int *)(buffer->ptr + 4 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1256

ptr = (int *)(buffer->ptr + 5 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1260

buffer->ptr = p + 2 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

1266

buffer->ptr = p + 5 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

1293

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1352

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1412

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

145

self->page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/hmm-tests.c

146

self->page_shift = ffs(self->page_size) - 1;

tools/testing/selftests/mm/hmm-tests.c

1539

ret = munmap(buffer->ptr + self->page_size, self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1543

ret = mprotect(buffer->ptr + 2 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1546

ptr = (int *)(buffer->ptr + 2 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1551

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1554

ptr = (int *)(buffer->ptr + 3 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1556

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

156

self->page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/hmm-tests.c

1561

ret = mprotect(buffer->ptr + 4 * self->page_size, 3 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1564

ptr = (int *)(buffer->ptr + 4 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1568

buffer->ptr = p + 5 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

157

self->page_shift = ffs(self->page_size) - 1;

tools/testing/selftests/mm/hmm-tests.c

1574

buffer->ptr = p + 6 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

1782

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1836

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1891

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

2024

GUP_BASIC_TEST, 1, self->page_size, 0), 0);

tools/testing/selftests/mm/hmm-tests.c

2026

(unsigned long)buffer->ptr + 1 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

2027

GUP_FAST_BENCHMARK, 1, self->page_size, 0), 0);

tools/testing/selftests/mm/hmm-tests.c

2029

(unsigned long)buffer->ptr + 2 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

2030

PIN_FAST_BENCHMARK, 1, self->page_size, FOLL_LONGTERM), 0);

tools/testing/selftests/mm/hmm-tests.c

2032

(unsigned long)buffer->ptr + 3 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

2033

PIN_LONGTERM_BENCHMARK, 1, self->page_size, 0), 0);

tools/testing/selftests/mm/hmm-tests.c

2385

(char *)buffer->ptr + i * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

313

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

335

i = 2 * self->page_size / sizeof(*ptr);

tools/testing/selftests/mm/hmm-tests.c

344

val = *(int *)(buffer->ptr + self->page_size);

tools/testing/selftests/mm/hmm-tests.c

355

for (i = 0; i < 2 * self->page_size / sizeof(*ptr); ++i)

tools/testing/selftests/mm/hmm-tests.c

376

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

435

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

483

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

558

self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

660

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

80

unsigned int page_size;

tools/testing/selftests/mm/hmm-tests.c

848

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

903

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

959

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/khugepaged.c

1005

ops->fault(p, 0, (hpage_pmd_nr - max_ptes_shared - 1) * page_size);

tools/testing/selftests/mm/khugepaged.c

1018

page_size);

tools/testing/selftests/mm/khugepaged.c

1240

page_size = getpagesize();

tools/testing/selftests/mm/khugepaged.c

1244

hpage_pmd_nr = hpage_pmd_size / page_size;

tools/testing/selftests/mm/khugepaged.c

235

for (i = start / page_size; i < end / page_size; i++)

tools/testing/selftests/mm/khugepaged.c

236

p[i * page_size / sizeof(*p)] = i + 0xdead0000;

tools/testing/selftests/mm/khugepaged.c

29

static unsigned long page_size;

tools/testing/selftests/mm/khugepaged.c

291

for (i = start / page_size; i < end / page_size; i++) {

tools/testing/selftests/mm/khugepaged.c

292

if (p[i * page_size / sizeof(*p)] != i + 0xdead0000)

tools/testing/selftests/mm/khugepaged.c

294

i, p[i * page_size / sizeof(*p)]);

tools/testing/selftests/mm/khugepaged.c

644

madvise(p, page_size, MADV_DONTNEED);

tools/testing/selftests/mm/khugepaged.c

686

ops->fault(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

712

ops->fault(p, 0, (hpage_pmd_nr - max_ptes_none - fault_nr_pages) * page_size);

tools/testing/selftests/mm/khugepaged.c

715

validate_memory(p, 0, (hpage_pmd_nr - max_ptes_none - fault_nr_pages) * page_size);

tools/testing/selftests/mm/khugepaged.c

721

ops->fault(p, 0, (hpage_pmd_nr - max_ptes_none) * page_size);

tools/testing/selftests/mm/khugepaged.c

725

(hpage_pmd_nr - max_ptes_none) * page_size);

tools/testing/selftests/mm/khugepaged.c

741

if (madvise(p, page_size, MADV_PAGEOUT))

tools/testing/selftests/mm/khugepaged.c

743

if (check_swap(p, page_size)) {

tools/testing/selftests/mm/khugepaged.c

767

if (madvise(p, (max_ptes_swap + 1) * page_size, MADV_PAGEOUT))

tools/testing/selftests/mm/khugepaged.c

769

if (check_swap(p, (max_ptes_swap + 1) * page_size)) {

tools/testing/selftests/mm/khugepaged.c

784

if (madvise(p, max_ptes_swap * page_size, MADV_PAGEOUT))

tools/testing/selftests/mm/khugepaged.c

786

if (check_swap(p, max_ptes_swap * page_size)) {

tools/testing/selftests/mm/khugepaged.c

817

madvise(p + page_size, hpage_pmd_size - page_size, MADV_DONTNEED);

tools/testing/selftests/mm/khugepaged.c

825

validate_memory(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

837

madvise(p, page_size, MADV_NOHUGEPAGE);

tools/testing/selftests/mm/khugepaged.c

865

p = mremap(BASE_ADDR - i * page_size,

tools/testing/selftests/mm/khugepaged.c

866

i * page_size + hpage_pmd_size,

tools/testing/selftests/mm/khugepaged.c

867

(i + 1) * page_size,

tools/testing/selftests/mm/khugepaged.c

874

(i + 1) * page_size,

tools/testing/selftests/mm/khugepaged.c

875

(i + 1) * page_size + hpage_pmd_size,

tools/testing/selftests/mm/khugepaged.c

877

BASE_ADDR - (i + 1) * page_size);

tools/testing/selftests/mm/khugepaged.c

905

ops->fault(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

919

ops->fault(p, page_size, 2 * page_size);

tools/testing/selftests/mm/khugepaged.c

923

validate_memory(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

936

validate_memory(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

956

madvise(p, page_size, MADV_NOHUGEPAGE);

tools/testing/selftests/mm/khugepaged.c

962

ops->fault(p, 0, page_size);

tools/testing/selftests/mm/ksm_tests.c

321

long page_count, int timeout, size_t page_size)

tools/testing/selftests/mm/ksm_tests.c

332

map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

336

if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

341

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

348

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

352

static int check_ksm_unmerge(int merge_type, int mapping, int prot, int timeout, size_t page_size)

tools/testing/selftests/mm/ksm_tests.c

364

map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

368

if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

373

memset(map_ptr + page_size, '+', 1);

tools/testing/selftests/mm/ksm_tests.c

381

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

386

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

391

int timeout, bool use_zero_pages, size_t page_size)

tools/testing/selftests/mm/ksm_tests.c

405

map_ptr = allocate_memory(NULL, prot, mapping, 0, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

409

if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

424

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

428

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

454

bool merge_across_nodes, size_t page_size)

tools/testing/selftests/mm/ksm_tests.c

479

numa1_map_ptr = numa_alloc_onnode(page_size, first_node);

tools/testing/selftests/mm/ksm_tests.c

480

numa2_map_ptr = numa_alloc_onnode(page_size, get_next_mem_node(first_node));

tools/testing/selftests/mm/ksm_tests.c

486

memset(numa1_map_ptr, '*', page_size);

tools/testing/selftests/mm/ksm_tests.c

487

memset(numa2_map_ptr, '*', page_size);

tools/testing/selftests/mm/ksm_tests.c

490

if (ksm_merge_pages(merge_type, numa1_map_ptr, page_size, start_time, timeout) ||

tools/testing/selftests/mm/ksm_tests.c

491

ksm_merge_pages(merge_type, numa2_map_ptr, page_size, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

505

numa_free(numa1_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

506

numa_free(numa2_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

510

numa_free(numa1_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

511

numa_free(numa2_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

673

static int ksm_cow_time(int merge_type, int mapping, int prot, int timeout, size_t page_size)

tools/testing/selftests/mm/ksm_tests.c

682

map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

691

memset(map_ptr + page_size * i, '-', 1);

tools/testing/selftests/mm/ksm_tests.c

700

ksft_print_msg("Total size: %lu MiB\n\n", (page_size * page_count) / MB);

tools/testing/selftests/mm/ksm_tests.c

704

ksft_print_msg("Average speed: %.3f MiB/s\n\n", ((page_size * (page_count / 2)) / MB) /

tools/testing/selftests/mm/ksm_tests.c

709

memset(map_ptr + page_size * i, '+', i / 2 + 1);

tools/testing/selftests/mm/ksm_tests.c

710

memset(map_ptr + page_size * (i + 1), '+', i / 2 + 1);

tools/testing/selftests/mm/ksm_tests.c

712

if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

720

memset(map_ptr + page_size * i, '-', 1);

tools/testing/selftests/mm/ksm_tests.c

732

ksft_print_msg("Average speed: %.3f MiB/s\n", ((page_size * (page_count / 2)) / MB) /

tools/testing/selftests/mm/ksm_tests.c

735

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

739

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

750

size_t page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/ksm_tests.c

856

ksm_scan_limit_sec, page_size);

tools/testing/selftests/mm/ksm_tests.c

861

ksm_scan_limit_sec, page_size);

tools/testing/selftests/mm/ksm_tests.c

867

page_size);

tools/testing/selftests/mm/ksm_tests.c

872

ksm_scan_limit_sec, merge_across_nodes, page_size);

tools/testing/selftests/mm/ksm_tests.c

898

ksm_scan_limit_sec, page_size);

tools/testing/selftests/mm/map_fixed_noreplace.c

110

addr = base_addr + (2 * page_size);

tools/testing/selftests/mm/map_fixed_noreplace.c

111

size = page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

128

addr = base_addr + (3 * page_size);

tools/testing/selftests/mm/map_fixed_noreplace.c

129

size = 2 * page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

147

size = 2 * page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

165

size = page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

182

addr = base_addr + (4 * page_size);

tools/testing/selftests/mm/map_fixed_noreplace.c

183

size = page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

193

size = 5 * page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

44

unsigned long flags, addr, size, page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

50

page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/map_fixed_noreplace.c

53

size = 5 * page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

60

size = 5 * page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

66

if (munmap((void *)addr, 5 * page_size) != 0) {

tools/testing/selftests/mm/map_fixed_noreplace.c

73

addr = base_addr + page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

74

size = 3 * page_size;

tools/testing/selftests/mm/map_fixed_noreplace.c

92

size = 5 * page_size;

tools/testing/selftests/mm/memfd_secret.c

109

memset(mem, PATTERN, page_size);

tools/testing/selftests/mm/memfd_secret.c

112

iov.iov_len = page_size;

tools/testing/selftests/mm/memfd_secret.c

120

munmap(mem, page_size);

tools/testing/selftests/mm/memfd_secret.c

224

mem = mmap(NULL, page_size, prot, mode, fd, 0);

tools/testing/selftests/mm/memfd_secret.c

230

memset(mem, PATTERN, page_size);

tools/testing/selftests/mm/memfd_secret.c

275

page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/memfd_secret.c

276

if (!page_size)

tools/testing/selftests/mm/memfd_secret.c

288

page_size, mlock_limit_cur, mlock_limit_max);

tools/testing/selftests/mm/memfd_secret.c

290

if (page_size > mlock_limit_cur)

tools/testing/selftests/mm/memfd_secret.c

291

mlock_limit_cur = page_size;

tools/testing/selftests/mm/memfd_secret.c

292

if (page_size > mlock_limit_max)

tools/testing/selftests/mm/memfd_secret.c

293

mlock_limit_max = page_size;

tools/testing/selftests/mm/memfd_secret.c

319

if (ftruncate(fd, page_size))

tools/testing/selftests/mm/memfd_secret.c

38

static unsigned long page_size;

tools/testing/selftests/mm/memfd_secret.c

66

if (len % page_size != 0)

tools/testing/selftests/mm/memfd_secret.c

67

len = (len/page_size) * page_size;

tools/testing/selftests/mm/memfd_secret.c

99

mem = mmap(NULL, page_size, prot, mode, fd, 0);

tools/testing/selftests/mm/memory-failure.c

100

self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/memory-failure.c

171

ASSERT_TRUE(check_memory(vaddr, self->page_size));

tools/testing/selftests/mm/memory-failure.c

184

ASSERT_EQ(1UL << siginfo.si_addr_lsb, self->page_size);

tools/testing/selftests/mm/memory-failure.c

196

ASSERT_EQ(size, self->corrupted_size + self->page_size / 1024);

tools/testing/selftests/mm/memory-failure.c

225

addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/memory-failure.c

229

memset(addr, 0xce, self->page_size);

tools/testing/selftests/mm/memory-failure.c

247

ASSERT_EQ(munmap(addr, self->page_size), 0);

tools/testing/selftests/mm/memory-failure.c

282

fd = prepare_file("./clean-page-cache-test-file", self->page_size);

tools/testing/selftests/mm/memory-failure.c

289

addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/memory-failure.c

293

memset(addr, 0xce, self->page_size);

tools/testing/selftests/mm/memory-failure.c

312

ASSERT_EQ(munmap(addr, self->page_size), 0);

tools/testing/selftests/mm/memory-failure.c

324

fd = prepare_file("./dirty-page-cache-test-file", self->page_size);

tools/testing/selftests/mm/memory-failure.c

331

addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/memory-failure.c

335

memset(addr, 0xce, self->page_size);

tools/testing/selftests/mm/memory-failure.c

353

ASSERT_EQ(munmap(addr, self->page_size), 0);

tools/testing/selftests/mm/memory-failure.c

44

unsigned long page_size;

tools/testing/selftests/mm/memory-failure.c

60

return madvise(vaddr, self->page_size, MADV_HWPOISON);

tools/testing/selftests/mm/memory-failure.c

71

return madvise(vaddr, self->page_size, MADV_SOFT_OFFLINE);

tools/testing/selftests/mm/merge.c

1003

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1015

ptr = mmap(&carveout[page_size], 15 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

1036

ptr3 = &ptr[10 * page_size];

tools/testing/selftests/mm/merge.c

1037

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1038

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 2000);

tools/testing/selftests/mm/merge.c

1040

ptr2 = &ptr[5 * page_size];

tools/testing/selftests/mm/merge.c

1041

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1042

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

1061

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1062

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

1067

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

1077

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1078

MREMAP_MAYMOVE | MREMAP_FIXED, ptr + page_size * 1000);

tools/testing/selftests/mm/merge.c

1096

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1097

MREMAP_MAYMOVE | MREMAP_FIXED, &carveout[page_size]);

tools/testing/selftests/mm/merge.c

110

self->page_size = psize();

tools/testing/selftests/mm/merge.c

1102

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

111

self->carveout = map_carveout(self->page_size);

tools/testing/selftests/mm/merge.c

1112

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1113

MREMAP_MAYMOVE | MREMAP_FIXED, ptr + page_size * 1000);

tools/testing/selftests/mm/merge.c

1131

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1132

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr2[5 * page_size]);

tools/testing/selftests/mm/merge.c

1137

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 10 * page_size);

tools/testing/selftests/mm/merge.c

1154

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1155

MREMAP_MAYMOVE | MREMAP_FIXED, &carveout[page_size]);

tools/testing/selftests/mm/merge.c

1160

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

1170

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1171

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

118

ASSERT_EQ(munmap(self->carveout, 30 * self->page_size), 0);

tools/testing/selftests/mm/merge.c

1189

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1190

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

1195

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

1205

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1206

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 1000);

tools/testing/selftests/mm/merge.c

1224

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1225

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[10 * page_size]);

tools/testing/selftests/mm/merge.c

1230

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

1235

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1247

carveout = mmap(NULL, 5 * page_size, PROT_NONE,

tools/testing/selftests/mm/merge.c

1259

ptr = mmap(&carveout[page_size], page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

126

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1262

ptr2 = mmap(&carveout[2 * page_size], page_size,

tools/testing/selftests/mm/merge.c

1266

ptr3 = mmap(&carveout[3 * page_size], page_size, PROT_READ,

tools/testing/selftests/mm/merge.c

1278

ASSERT_EQ(sys_mseal(ptr2, page_size, 0), 0);

tools/testing/selftests/mm/merge.c

1281

ASSERT_EQ(mprotect(ptr, page_size,

tools/testing/selftests/mm/merge.c

1293

ASSERT_EQ(sys_mseal(ptr, 3 * page_size, 0), 0);

tools/testing/selftests/mm/merge.c

1305

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 2 * page_size);

tools/testing/selftests/mm/merge.c

1311

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1327

ptr_a = mmap(&self->carveout[page_size + 3 * page_size],

tools/testing/selftests/mm/merge.c

1328

3 * page_size,

tools/testing/selftests/mm/merge.c

1347

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1348

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1352

ptr_b = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1361

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1363

&self->carveout[page_size + 3 * page_size]);

tools/testing/selftests/mm/merge.c

1370

offset = variant->forked ? 3 * page_size : 6 * page_size;

tools/testing/selftests/mm/merge.c

1377

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

139

ptr = mmap(&carveout[page_size], 10 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

1395

ptr_a = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1414

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1415

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1419

ptr_b = mmap(&self->carveout[page_size + 3 * page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1428

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1430

&self->carveout[page_size]);

tools/testing/selftests/mm/merge.c

1436

offset = variant->forked ? 3 * page_size : 6 * page_size;

tools/testing/selftests/mm/merge.c

1443

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1459

ptr_b = mmap(&self->carveout[page_size + 3 * page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1478

ptr_b = mremap(ptr_b, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1479

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1484

ptr_a = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1490

ptr_c = mmap(&self->carveout[page_size + 3 * page_size + 3 * page_size],

tools/testing/selftests/mm/merge.c

1491

3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

1499

ptr_b = mremap(ptr_b, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

150

ASSERT_EQ(mprotect(ptr, 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

1501

&self->carveout[page_size + 3 * page_size]);

tools/testing/selftests/mm/merge.c

1507

offset = variant->forked ? 3 * page_size : 9 * page_size;

tools/testing/selftests/mm/merge.c

1514

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + 3 * page_size);

tools/testing/selftests/mm/merge.c

1521

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1539

ptr_bc = mmap(&self->carveout[page_size + 3 * page_size],

tools/testing/selftests/mm/merge.c

1540

3 * page_size + 3 * page_size,

tools/testing/selftests/mm/merge.c

1561

ptr_b = mremap(ptr_bc, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1562

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1566

ptr_a = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1575

ptr_b = mremap(ptr_b, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1577

&self->carveout[page_size + 3 * page_size]);

tools/testing/selftests/mm/merge.c

1584

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + 6 * page_size);

tools/testing/selftests/mm/merge.c

1588

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + 9 * page_size);

tools/testing/selftests/mm/merge.c

160

ptr[5 * page_size] = 'x';

tools/testing/selftests/mm/merge.c

170

ASSERT_EQ(mprotect(&ptr[5 * page_size], 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

175

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

180

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

190

ptr = mmap(&carveout[page_size], 10 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

20

unsigned int page_size;

tools/testing/selftests/mm/merge.c

201

ASSERT_EQ(mprotect(&ptr[5 * page_size], 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

220

ASSERT_EQ(mprotect(ptr, 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

225

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

230

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

240

ptr = mmap(&carveout[2 * page_size], 9 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

25

static char *map_carveout(unsigned int page_size)

tools/testing/selftests/mm/merge.c

251

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

252

ASSERT_EQ(mprotect(&ptr[6 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

262

ptr[3 * page_size] = 'x';

tools/testing/selftests/mm/merge.c

27

return mmap(NULL, 30 * page_size, PROT_NONE,

tools/testing/selftests/mm/merge.c

271

ASSERT_EQ(mprotect(&ptr[3 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

276

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 9 * page_size);

tools/testing/selftests/mm/merge.c

281

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

291

ptr = mmap(&carveout[2 * page_size], 9 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

302

ASSERT_EQ(mprotect(&ptr[6 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

321

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

330

ASSERT_EQ(mprotect(&ptr[3 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

335

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 9 * page_size);

tools/testing/selftests/mm/merge.c

340

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

350

ptr = mmap(&carveout[2 * page_size], 9 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

361

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

371

ptr[3 * page_size] = 'x';

tools/testing/selftests/mm/merge.c

380

ASSERT_EQ(mprotect(&ptr[6 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

389

ASSERT_EQ(mprotect(&ptr[3 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

394

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 9 * page_size);

tools/testing/selftests/mm/merge.c

399

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

411

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

430

for (i = 0; i < 5 * page_size; i += page_size)

tools/testing/selftests/mm/merge.c

442

ptr2 = mmap(&ptr[5 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

449

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 5 * page_size);

tools/testing/selftests/mm/merge.c

454

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

466

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

485

for (i = 0; i < 5 * page_size; i += page_size)

tools/testing/selftests/mm/merge.c

497

ptr2 = mmap(&carveout[6 * page_size], 5 * page_size, PROT_READ | PROT_WRITE | PROT_EXEC,

tools/testing/selftests/mm/merge.c

504

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 5 * page_size);

tools/testing/selftests/mm/merge.c

518

ASSERT_EQ(mprotect(ptr, 5 * page_size, PROT_READ | PROT_WRITE | PROT_EXEC), 0);

tools/testing/selftests/mm/merge.c

522

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 5 * page_size);

tools/testing/selftests/mm/merge.c

528

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

539

ASSERT_EQ(ftruncate(fd, page_size), 0);

tools/testing/selftests/mm/merge.c

552

ptr1 = mmap(&carveout[page_size], 10 * page_size, PROT_EXEC,

tools/testing/selftests/mm/merge.c

556

ptr2 = mremap(ptr1, page_size, 2 * page_size,

tools/testing/selftests/mm/merge.c

557

MREMAP_MAYMOVE | MREMAP_FIXED, ptr1 + 5 * page_size);

tools/testing/selftests/mm/merge.c

560

ASSERT_NE(mremap(ptr2, page_size, page_size,

tools/testing/selftests/mm/merge.c

570

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

586

ptr = mmap(&carveout[page_size], page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

589

ptr2 = mmap(&carveout[2 * page_size], page_size,

tools/testing/selftests/mm/merge.c

595

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 2 * page_size);

tools/testing/selftests/mm/merge.c

598

ASSERT_EQ(munmap(ptr2, page_size), 0);

tools/testing/selftests/mm/merge.c

615

ptr2 = mmap(&carveout[2 * page_size], page_size,

tools/testing/selftests/mm/merge.c

621

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 2 * page_size);

tools/testing/selftests/mm/merge.c

624

ASSERT_EQ(munmap(ptr, 2 * page_size), 0);

tools/testing/selftests/mm/merge.c

627

ptr = mmap(&carveout[page_size], page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

630

ptr2 = mmap(&carveout[2 * page_size], page_size,

tools/testing/selftests/mm/merge.c

636

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 2 * page_size);

tools/testing/selftests/mm/merge.c

641

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

654

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

657

ptr2 = mmap(&carveout[7 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

66

self->page_size = psize();

tools/testing/selftests/mm/merge.c

662

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

663

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

68

self->carveout = map_carveout(self->page_size);

tools/testing/selftests/mm/merge.c

691

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

692

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

697

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

702

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

715

ptr = mmap(&carveout[6 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

718

ptr2 = mmap(&carveout[14 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

723

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

724

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

752

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

753

MREMAP_MAYMOVE | MREMAP_FIXED, &carveout[page_size]);

tools/testing/selftests/mm/merge.c

758

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 10 * page_size);

tools/testing/selftests/mm/merge.c

76

ASSERT_EQ(munmap(self->carveout, 30 * self->page_size), 0);

tools/testing/selftests/mm/merge.c

763

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

776

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

779

ptr2 = mmap(&carveout[7 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

782

ptr3 = mmap(&carveout[14 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

787

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

788

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 2000);

tools/testing/selftests/mm/merge.c

792

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

793

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

815

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

816

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[10 * page_size]);

tools/testing/selftests/mm/merge.c

833

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

834

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

839

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

843

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr3 + 5 * page_size);

tools/testing/selftests/mm/merge.c

848

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

861

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

864

ptr2 = mmap(&carveout[7 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

867

ptr3 = mmap(&carveout[14 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

872

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

873

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 2000);

tools/testing/selftests/mm/merge.c

878

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

879

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

88

unsigned int page_size;

tools/testing/selftests/mm/merge.c

900

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

901

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[10 * page_size]);

tools/testing/selftests/mm/merge.c

918

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

919

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

924

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

929

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

941

ptr = mmap(&carveout[page_size], 15 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

964

ASSERT_EQ(munmap(&ptr[5 * page_size], 5 * page_size), 0);

tools/testing/selftests/mm/merge.c

974

ptr2 = mmap(&carveout[20 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

992

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

993

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

998

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/mlock-random-test.c

138

int page_size = 0;

tools/testing/selftests/mm/mlock-random-test.c

174

page_size = get_proc_page_size((unsigned long)p);

tools/testing/selftests/mm/mlock-random-test.c

176

if (locked_vm_size > PAGE_ALIGN(alloc_size, page_size) + page_size)

tools/testing/selftests/mm/mlock2-tests.c

183

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

185

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

190

if (mlock2_(map, 2 * page_size, 0)) {

tools/testing/selftests/mm/mlock2-tests.c

191

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

198

if (munlock(map, 2 * page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

199

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

204

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

220

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

223

is_vma_lock_on_fault((unsigned long)map + page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

234

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

236

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

241

if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {

tools/testing/selftests/mm/mlock2-tests.c

242

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

249

if (munlock(map, 2 * page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

250

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

255

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

261

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

263

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

270

if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {

tools/testing/selftests/mm/mlock2-tests.c

271

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

276

is_vma_lock_on_fault((unsigned long)map + page_size),

tools/testing/selftests/mm/mlock2-tests.c

278

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

284

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

286

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

292

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

299

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

304

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

310

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

312

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

318

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

325

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

332

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

339

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

344

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

351

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

359

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

369

if (mlock2_(map, 2 * page_size, 0))

tools/testing/selftests/mm/mlock2-tests.c

375

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

381

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

388

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

404

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

410

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

415

map = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

420

if (call_mlock && mlock2_(map, 3 * page_size, MLOCK_ONFAULT)) {

tools/testing/selftests/mm/mlock2-tests.c

421

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

426

get_vm_area((unsigned long)map + page_size, &page2) ||

tools/testing/selftests/mm/mlock2-tests.c

427

get_vm_area((unsigned long)map + page_size * 2, &page3)) {

tools/testing/selftests/mm/mlock2-tests.c

428

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

438

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

442

if (munlock(map + page_size, page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

443

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

448

get_vm_area((unsigned long)map + page_size, &page2) ||

tools/testing/selftests/mm/mlock2-tests.c

449

get_vm_area((unsigned long)map + page_size * 2, &page3)) {

tools/testing/selftests/mm/mlock2-tests.c

450

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

456

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

461

if (munlock(map, page_size * 3)) {

tools/testing/selftests/mm/mlock2-tests.c

462

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

467

get_vm_area((unsigned long)map + page_size, &page2) ||

tools/testing/selftests/mm/mlock2-tests.c

468

get_vm_area((unsigned long)map + page_size * 2, &page3)) {

tools/testing/selftests/mm/mlock2-tests.c

469

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

475

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

480

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

100

mmap(NULL, num_pages * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

104

memset(source_mapping, 'a', num_pages * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

108

mremap(source_mapping, num_pages * page_size, num_pages * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

115

(dest_mapping, num_pages * page_size, 'a') != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

118

(source_mapping, num_pages * page_size, 0) != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

121

BUG_ON(munmap(dest_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

123

BUG_ON(munmap(source_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

136

BUG_ON(ftruncate(mem_fd, num_pages * page_size) < 0,

tools/testing/selftests/mm/mremap_dontunmap.c

140

mmap(NULL, num_pages * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

146

memset(source_mapping, 'a', num_pages * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

150

mremap(source_mapping, num_pages * page_size, num_pages * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

154

BUG_ON(munmap(source_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

164

(dest_mapping, num_pages * page_size, 'a') != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

170

(source_mapping, num_pages * page_size, 'a') != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

173

BUG_ON(munmap(dest_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

175

BUG_ON(munmap(source_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

19

unsigned long page_size;

tools/testing/selftests/mm/mremap_dontunmap.c

190

mmap(NULL, num_pages * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

193

memset(dest_mapping, 'X', num_pages * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

196

mmap(NULL, num_pages * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

199

memset(source_mapping, 'a', num_pages * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

202

mremap(source_mapping, num_pages * page_size, num_pages * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

212

(dest_mapping, num_pages * page_size, 'a') != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

217

(source_mapping, num_pages * page_size, 0) != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

220

BUG_ON(munmap(dest_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

222

BUG_ON(munmap(source_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

247

mmap(NULL, num_pages * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

250

memset(source_mapping, 'a', num_pages * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

254

mremap(source_mapping + (5 * page_size), 5 * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

255

5 * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

261

BUG_ON(check_region_contains_byte(source_mapping, 5 * page_size, 'a') !=

tools/testing/selftests/mm/mremap_dontunmap.c

264

(source_mapping + (5 * page_size), 5 * page_size, 0) != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

268

BUG_ON(check_region_contains_byte(dest_mapping, 5 * page_size, 'a') !=

tools/testing/selftests/mm/mremap_dontunmap.c

271

BUG_ON(munmap(dest_mapping, 5 * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

273

BUG_ON(munmap(source_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

300

mmap(NULL, 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

303

memset(source_mapping, 'a', 5 * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

306

mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

309

memset(dest_mapping, 'X', 10 * page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

313

mremap(source_mapping, 5 * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

314

5 * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

319

BUG_ON(check_region_contains_byte(source_mapping, 5 * page_size, 0) !=

tools/testing/selftests/mm/mremap_dontunmap.c

323

BUG_ON(check_region_contains_byte(dest_mapping, 5 * page_size, 'a') != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

327

BUG_ON(check_region_contains_byte(dest_mapping + (5 * page_size),

tools/testing/selftests/mm/mremap_dontunmap.c

328

5 * page_size, 'X') != 0,

tools/testing/selftests/mm/mremap_dontunmap.c

331

BUG_ON(munmap(dest_mapping, 10 * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

333

BUG_ON(munmap(source_mapping, 5 * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

342

page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/mremap_dontunmap.c

355

mmap(NULL, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_dontunmap.c

365

BUG_ON(munmap(page_buffer, page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

46

void *source_mapping = mmap(NULL, num_pages * page_size, PROT_NONE,

tools/testing/selftests/mm/mremap_dontunmap.c

53

mremap(source_mapping, num_pages * page_size, num_pages * page_size,

tools/testing/selftests/mm/mremap_dontunmap.c

58

BUG_ON(munmap(dest_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

62

BUG_ON(munmap(source_mapping, num_pages * page_size) == -1,

tools/testing/selftests/mm/mremap_dontunmap.c

71

BUG_ON(size & (page_size - 1),

tools/testing/selftests/mm/mremap_dontunmap.c

73

BUG_ON((unsigned long)addr & (page_size - 1),

tools/testing/selftests/mm/mremap_dontunmap.c

76

memset(page_buffer, byte, page_size);

tools/testing/selftests/mm/mremap_dontunmap.c

78

unsigned long num_pages = size / page_size;

tools/testing/selftests/mm/mremap_dontunmap.c

84

memcmp(addr + (i * page_size), page_buffer, page_size);

tools/testing/selftests/mm/mremap_test.c

1249

int page_size;

tools/testing/selftests/mm/mremap_test.c

1286

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/mremap_test.c

1289

test_cases[0] = MAKE_TEST(page_size, page_size, page_size,

tools/testing/selftests/mm/mremap_test.c

1293

test_cases[1] = MAKE_TEST(page_size, page_size/4, page_size,

tools/testing/selftests/mm/mremap_test.c

1296

test_cases[2] = MAKE_TEST(page_size/4, page_size, page_size,

tools/testing/selftests/mm/mremap_test.c

1338

perf_test_cases[0] = MAKE_TEST(page_size, page_size, _1GB, NON_OVERLAPPING, EXPECT_SUCCESS,

tools/testing/selftests/mm/mremap_test.c

1366

mremap_expand_merge(maps_fp, page_size);

tools/testing/selftests/mm/mremap_test.c

1367

mremap_expand_merge_offset(maps_fp, page_size);

tools/testing/selftests/mm/mremap_test.c

1371

mremap_shrink_multiple_vmas(page_size, /* inplace= */true);

tools/testing/selftests/mm/mremap_test.c

1372

mremap_shrink_multiple_vmas(page_size, /* inplace= */false);

tools/testing/selftests/mm/mremap_test.c

1373

mremap_move_multiple_vmas(pattern_seed, page_size, /* dontunmap= */ false);

tools/testing/selftests/mm/mremap_test.c

1374

mremap_move_multiple_vmas(pattern_seed, page_size, /* dontunmap= */ true);

tools/testing/selftests/mm/mremap_test.c

1375

mremap_move_multiple_vmas_split(pattern_seed, page_size, /* dontunmap= */ false);

tools/testing/selftests/mm/mremap_test.c

1376

mremap_move_multiple_vmas_split(pattern_seed, page_size, /* dontunmap= */ true);

tools/testing/selftests/mm/mremap_test.c

1377

mremap_move_multi_invalid_vmas(maps_fp, page_size);

tools/testing/selftests/mm/mremap_test.c

232

static void mremap_expand_merge(FILE *maps_fp, unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

238

start = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_test.c

246

munmap(start + page_size, page_size);

tools/testing/selftests/mm/mremap_test.c

247

remap = mremap(start, page_size, 2 * page_size, 0);

tools/testing/selftests/mm/mremap_test.c

250

munmap(start, page_size);

tools/testing/selftests/mm/mremap_test.c

251

munmap(start + 2 * page_size, page_size);

tools/testing/selftests/mm/mremap_test.c

256

(unsigned long)(start + 3 * page_size));

tools/testing/selftests/mm/mremap_test.c

257

munmap(start, 3 * page_size);

tools/testing/selftests/mm/mremap_test.c

271

static void mremap_expand_merge_offset(FILE *maps_fp, unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

278

start = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_test.c

287

munmap(start + 2 * page_size, page_size);

tools/testing/selftests/mm/mremap_test.c

288

remap = mremap(start + page_size, page_size, 2 * page_size, 0);

tools/testing/selftests/mm/mremap_test.c

291

munmap(start, 2 * page_size);

tools/testing/selftests/mm/mremap_test.c

296

(unsigned long)(start + 3 * page_size));

tools/testing/selftests/mm/mremap_test.c

297

munmap(start, 3 * page_size);

tools/testing/selftests/mm/mremap_test.c

377

char *ptr, unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

384

char *buf = &ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

385

size_t size = i == 4 ? 2 * page_size : page_size;

tools/testing/selftests/mm/mremap_test.c

402

unsigned long page_size,

tools/testing/selftests/mm/mremap_test.c

407

const size_t size = 11 * page_size;

tools/testing/selftests/mm/mremap_test.c

448

if (munmap(&ptr[i * page_size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

460

size_t size = i == 4 ? 2 * page_size : page_size;

tools/testing/selftests/mm/mremap_test.c

461

char *buf = &ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

474

if (!is_multiple_vma_range_ok(pattern_seed, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

487

if (!is_multiple_vma_range_ok(pattern_seed, &tgt_ptr[size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

507

if (!is_multiple_vma_range_ok(pattern_seed, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

527

static void mremap_shrink_multiple_vmas(unsigned long page_size,

tools/testing/selftests/mm/mremap_test.c

531

const size_t size = 10 * page_size;

tools/testing/selftests/mm/mremap_test.c

566

if (munmap(&ptr[i * page_size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

581

res = mremap(ptr, size, page_size, 0);

tools/testing/selftests/mm/mremap_test.c

583

res = mremap(ptr, size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED,

tools/testing/selftests/mm/mremap_test.c

607

unsigned long page_size,

tools/testing/selftests/mm/mremap_test.c

612

const size_t size = 10 * page_size;

tools/testing/selftests/mm/mremap_test.c

64

#define PTE page_size

tools/testing/selftests/mm/mremap_test.c

649

if (munmap(&ptr[5 * page_size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

659

char *buf = &ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

664

for (j = 0; j < page_size; j++)

tools/testing/selftests/mm/mremap_test.c

684

if (mremap(&ptr[2 * page_size], size - 3 * page_size, size - 3 * page_size,

tools/testing/selftests/mm/mremap_test.c

693

for (i = 0; i < 2 * page_size; i++)

tools/testing/selftests/mm/mremap_test.c

699

char *buf = &tgt_ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

704

for (j = 0; j < page_size; j++) {

tools/testing/selftests/mm/mremap_test.c

731

unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

734

const size_t size = 10 * page_size;

tools/testing/selftests/mm/mremap_test.c

791

void *unmap_ptr = &ptr[(i + 1) * page_size];

tools/testing/selftests/mm/mremap_test.c

792

unsigned long start = (unsigned long)&ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

796

.len = page_size,

tools/testing/selftests/mm/mremap_test.c

806

if (munmap(unmap_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

832

if (is_ptr_mapped(maps_fp, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

843

res = mremap(ptr, page_size, page_size,

tools/testing/selftests/mm/mremap_test.c

855

if (munmap(tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

860

res = mmap(ptr, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_test.c

885

if (!is_ptr_mapped(maps_fp, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

896

if (munmap(tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

901

if (munmap(ptr, size - 2 * page_size)) {

tools/testing/selftests/mm/mremap_test.c

907

res = mmap(&ptr[i * page_size], page_size,

tools/testing/selftests/mm/mremap_test.c

937

&tgt_ptr[i * page_size], page_size);

tools/testing/selftests/mm/mremap_test.c

964

static void mremap_move_multi_invalid_vmas(FILE *maps_fp, unsigned long page_size)

tools/testing/selftests/mm/mseal_test.c

1001

ret = sys_munmap(ptr + page_size, page_size * 2);

tools/testing/selftests/mm/mseal_test.c

1010

ret = sys_munmap(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

1013

ret = sys_munmap(ptr + page_size * 2, page_size);

tools/testing/selftests/mm/mseal_test.c

1025

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1026

unsigned long size = 2 * page_size;

tools/testing/selftests/mm/mseal_test.c

1034

ret = sys_mseal(ptr + page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

1045

FAIL_TEST_IF_FALSE(get_vma_size(ptr + page_size, &prot) > 0);

tools/testing/selftests/mm/mseal_test.c

1055

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1056

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1064

ret = sys_munmap(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

1069

ret = sys_mseal(ptr + page_size, 3 * page_size);

tools/testing/selftests/mm/mseal_test.c

1078

size = get_vma_size(ptr + page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1079

FAIL_TEST_IF_FALSE(size == page_size * 3);

tools/testing/selftests/mm/mseal_test.c

1085

size = get_vma_size(ptr + page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1095

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1096

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1103

ret = sys_munmap(ptr + page_size * 3, page_size);

tools/testing/selftests/mm/mseal_test.c

1108

ret = sys_mseal(ptr, 3 * page_size);

tools/testing/selftests/mm/mseal_test.c

1125

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1126

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1134

ret = sys_munmap(ptr + page_size, page_size * 2);

tools/testing/selftests/mm/mseal_test.c

1139

ret = sys_mseal(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

1149

FAIL_TEST_IF_FALSE(size == page_size);

tools/testing/selftests/mm/mseal_test.c

1151

size = get_vma_size(ptr + page_size * 3, &prot);

tools/testing/selftests/mm/mseal_test.c

1152

FAIL_TEST_IF_FALSE(size == page_size);

tools/testing/selftests/mm/mseal_test.c

1159

size = get_vma_size(ptr + page_size * 3, &prot);

tools/testing/selftests/mm/mseal_test.c

1169

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1170

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1183

ret2 = sys_mremap(ptr, size, 2 * page_size, 0, 0);

tools/testing/selftests/mm/mseal_test.c

1198

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1199

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1206

ret = sys_munmap(ptr + 2 * page_size, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

1210

ret = sys_mseal(ptr, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

1215

ret2 = sys_mremap(ptr, 2 * page_size, 4 * page_size, 0, 0);

tools/testing/selftests/mm/mseal_test.c

1230

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1231

unsigned long size = page_size;

tools/testing/selftests/mm/mseal_test.c

1263

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1264

unsigned long size = page_size;

tools/testing/selftests/mm/mseal_test.c

1291

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1292

unsigned long size = 12 * page_size;

tools/testing/selftests/mm/mseal_test.c

1299

ret = sys_munmap(ptr + 8 * page_size, 4 * page_size);

tools/testing/selftests/mm/mseal_test.c

1303

ret = sys_mseal(ptr, 8 * page_size);

tools/testing/selftests/mm/mseal_test.c

1322

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1323

unsigned long size = 12 * page_size;

tools/testing/selftests/mm/mseal_test.c

1336

ret2 = mmap(ptr, 8 * page_size, PROT_READ,

tools/testing/selftests/mm/mseal_test.c

1351

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1352

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1367

ret2 = sys_mremap(ptr, size, 2 * page_size, MREMAP_MAYMOVE | MREMAP_FIXED,

tools/testing/selftests/mm/mseal_test.c

1382

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1383

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1387

setup_single_address(page_size, &ptr);

tools/testing/selftests/mm/mseal_test.c

1398

ret2 = sys_mremap(ptr, page_size, size, MREMAP_MAYMOVE | MREMAP_FIXED,

tools/testing/selftests/mm/mseal_test.c

1413

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1414

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1442

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1443

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1458

ret2 = sys_mremap(ptr, size, 2 * page_size, MREMAP_MAYMOVE | MREMAP_FIXED,

tools/testing/selftests/mm/mseal_test.c

1473

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1474

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1502

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1503

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1543

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1549

setup_single_address(24 * page_size, &ptr);

tools/testing/selftests/mm/mseal_test.c

1554

ret = sys_mprotect(ptr, page_size, PROT_NONE);

tools/testing/selftests/mm/mseal_test.c

1556

ret = sys_mprotect(ptr + 23 * page_size, page_size, PROT_NONE);

tools/testing/selftests/mm/mseal_test.c

1558

size = get_vma_size(ptr + page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1559

FAIL_TEST_IF_FALSE(size == 22 * page_size);

tools/testing/selftests/mm/mseal_test.c

1564

ret = sys_mseal(ptr + page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

1566

size = get_vma_size(ptr + page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1567

FAIL_TEST_IF_FALSE(size == page_size);

tools/testing/selftests/mm/mseal_test.c

1569

size = get_vma_size(ptr + 2 * page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1570

FAIL_TEST_IF_FALSE(size == 21 * page_size);

tools/testing/selftests/mm/mseal_test.c

1575

ret = sys_mseal(ptr + 22 * page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

1577

size = get_vma_size(ptr + 22 * page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1578

FAIL_TEST_IF_FALSE(size == page_size);

tools/testing/selftests/mm/mseal_test.c

1580

size = get_vma_size(ptr + 2 * page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1581

FAIL_TEST_IF_FALSE(size == 20 * page_size);

tools/testing/selftests/mm/mseal_test.c

1586

ret = sys_mseal(ptr + 2 * page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

1588

size = get_vma_size(ptr + page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1589

FAIL_TEST_IF_FALSE(size == 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

1594

ret = sys_mseal(ptr + 21 * page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

1596

size = get_vma_size(ptr + 21 * page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1597

FAIL_TEST_IF_FALSE(size == 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

1602

ret = sys_mseal(ptr + 2 * page_size, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

1604

size = get_vma_size(ptr + 1 * page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1605

FAIL_TEST_IF_FALSE(size == 3 * page_size);

tools/testing/selftests/mm/mseal_test.c

1607

ret = sys_munmap(ptr + page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

1609

ret = sys_mprotect(ptr + 2 * page_size, page_size, PROT_NONE);

tools/testing/selftests/mm/mseal_test.c

1614

ret = sys_mseal(ptr + 20 * page_size, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

1617

size = get_vma_size(ptr + 20 * page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1618

FAIL_TEST_IF_FALSE(size == 3 * page_size);

tools/testing/selftests/mm/mseal_test.c

1623

ret = sys_mseal(ptr + 2 * page_size, 20 * page_size);

tools/testing/selftests/mm/mseal_test.c

1625

size = get_vma_size(ptr + page_size, &prot);

tools/testing/selftests/mm/mseal_test.c

1626

FAIL_TEST_IF_FALSE(size == 22 * page_size);

tools/testing/selftests/mm/mseal_test.c

1635

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1636

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1664

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1665

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1711

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1712

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1748

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1749

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1777

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1778

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

1807

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1808

unsigned long size = 2 * page_size;

tools/testing/selftests/mm/mseal_test.c

1815

ret = seal_single_address(ptr + page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

1838

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

1839

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

205

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

207

ptr = mmap(NULL, page_size, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

tools/testing/selftests/mm/mseal_test.c

211

ret = sys_mseal(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

233

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

234

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

249

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

250

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

256

ret = sys_munmap(ptr, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

267

ret = sys_mseal(ptr + 2 * page_size, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

277

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

278

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

284

ret = sys_munmap(ptr + page_size, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

296

ret = sys_mseal(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

299

ret = sys_mseal(ptr + 3 * page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

309

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

310

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

316

ret = sys_munmap(ptr + 2 * page_size, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

328

ret = sys_mseal(ptr, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

338

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

339

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

345

ret = sys_mprotect(ptr + page_size, 2 * page_size,

tools/testing/selftests/mm/mseal_test.c

354

ret = sys_mprotect(ptr + page_size, 2 * page_size,

tools/testing/selftests/mm/mseal_test.c

369

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

370

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

376

ret = sys_mprotect(ptr, 2 * page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

380

ret = sys_mseal(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

384

ret = sys_mseal(ptr + page_size, 3 * page_size);

tools/testing/selftests/mm/mseal_test.c

394

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

395

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

401

ret = sys_mprotect(ptr, 2 * page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

405

ret = sys_mseal(ptr + 3 * page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

409

ret = sys_mseal(ptr, 3 * page_size);

tools/testing/selftests/mm/mseal_test.c

418

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

419

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

422

setup_single_address(8 * page_size, &ptr);

tools/testing/selftests/mm/mseal_test.c

424

ret = clean_single_address(ptr + 4 * page_size, 4 * page_size);

tools/testing/selftests/mm/mseal_test.c

432

ret = sys_mseal(ptr + 1, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

436

ret = sys_mseal(ptr, 5 * page_size);

tools/testing/selftests/mm/mseal_test.c

440

ret = sys_mseal(ptr, UINT64_MAX/page_size);

tools/testing/selftests/mm/mseal_test.c

444

ret = sys_mseal(ptr - page_size, 5 * page_size);

tools/testing/selftests/mm/mseal_test.c

453

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

454

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

477

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

478

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

488

FAIL_TEST_IF_FALSE(size == 4 * page_size);

tools/testing/selftests/mm/mseal_test.c

504

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

505

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

523

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

524

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

547

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

548

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

555

ret = seal_single_address(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

560

ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

567

ret = sys_mprotect(ptr + page_size, page_size * 3,

tools/testing/selftests/mm/mseal_test.c

577

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

578

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

585

ret = seal_single_address(ptr + page_size, 3 * page_size);

tools/testing/selftests/mm/mseal_test.c

590

ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

594

ret = sys_mprotect(ptr + page_size, page_size * 3,

tools/testing/selftests/mm/mseal_test.c

607

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

608

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

615

ret = seal_single_address(ptr, page_size * 2 - 1);

tools/testing/selftests/mm/mseal_test.c

620

ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

626

ret = sys_mprotect(ptr + page_size * 2, page_size,

tools/testing/selftests/mm/mseal_test.c

636

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

637

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

643

ret = seal_single_address(ptr, page_size * 2 + 1);

tools/testing/selftests/mm/mseal_test.c

648

ret = sys_mprotect(ptr, page_size * 3, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

654

ret = sys_mprotect(ptr + page_size * 3, page_size,

tools/testing/selftests/mm/mseal_test.c

664

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

665

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

672

ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

676

ret = seal_single_address(ptr, page_size * 4);

tools/testing/selftests/mm/mseal_test.c

680

ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

686

ret = sys_mprotect(ptr + page_size * 2, page_size * 2,

tools/testing/selftests/mm/mseal_test.c

699

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

700

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

707

ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

712

ret = seal_single_address(ptr + page_size, page_size * 2);

tools/testing/selftests/mm/mseal_test.c

717

ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

721

ret = sys_mprotect(ptr + page_size, page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

728

ret = sys_mprotect(ptr + 2 * page_size, page_size,

tools/testing/selftests/mm/mseal_test.c

736

ret = sys_mprotect(ptr + 3 * page_size, page_size,

tools/testing/selftests/mm/mseal_test.c

746

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

747

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

755

ret = seal_single_address(ptr, page_size);

tools/testing/selftests/mm/mseal_test.c

760

ret = sys_mprotect(ptr, 2 * page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

772

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

773

unsigned long size = 2 * page_size;

tools/testing/selftests/mm/mseal_test.c

786

ret = sys_mseal(ptr + page_size, page_size);

tools/testing/selftests/mm/mseal_test.c

797

FAIL_TEST_IF_FALSE(get_vma_size(ptr + page_size, &prot) > 0);

tools/testing/selftests/mm/mseal_test.c

808

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

809

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

816

ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

820

ret = sys_mprotect(ptr + 3 * page_size, page_size,

tools/testing/selftests/mm/mseal_test.c

825

ret = sys_munmap(ptr + page_size, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

830

ret = sys_mprotect(ptr, 4 * page_size, PROT_READ);

tools/testing/selftests/mm/mseal_test.c

834

ret = sys_mseal(ptr, 4 * page_size);

tools/testing/selftests/mm/mseal_test.c

838

ret = sys_mprotect(ptr, page_size, PROT_READ);

tools/testing/selftests/mm/mseal_test.c

842

ret = sys_mprotect(ptr + 3 * page_size, page_size, PROT_READ);

tools/testing/selftests/mm/mseal_test.c

851

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

852

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

859

ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

864

ret = sys_mseal(ptr, 4 * page_size);

tools/testing/selftests/mm/mseal_test.c

869

ret = sys_mprotect(ptr, 2 * page_size, PROT_READ);

tools/testing/selftests/mm/mseal_test.c

876

ret = sys_mprotect(ptr + 2 * page_size, 2 * page_size, PROT_READ);

tools/testing/selftests/mm/mseal_test.c

888

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

889

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

896

ret = sys_mprotect(ptr, page_size, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

901

ret = sys_mseal(ptr, 2 * page_size);

tools/testing/selftests/mm/mseal_test.c

906

ret = sys_mprotect(ptr, 2 * page_size, PROT_READ);

tools/testing/selftests/mm/mseal_test.c

913

ret = sys_mprotect(ptr + 2 * page_size, 2 * page_size, PROT_READ);

tools/testing/selftests/mm/mseal_test.c

922

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

923

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

953

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

954

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/mseal_test.c

961

ret = sys_mprotect(ptr, page_size * 2, PROT_READ | PROT_WRITE);

tools/testing/selftests/mm/mseal_test.c

969

ret = sys_munmap(ptr, page_size * 2);

tools/testing/selftests/mm/mseal_test.c

975

ret = sys_munmap(ptr + page_size, page_size * 2);

tools/testing/selftests/mm/mseal_test.c

994

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mseal_test.c

995

unsigned long size = 4 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1001

long vec_size = len / page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1022

map = aligned_alloc(page_size, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1026

wp_init(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1027

wp_addr_range(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1030

if (pagemap_ioctl(map, page_size, &vec, 1, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

1036

wp_addr_range(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1040

if (pagemap_ioctl(map, page_size, &vec, 1, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

1046

wp_addr_range(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1048

wp_free(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1064

long mem_size = npages * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1114

mem_size = 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1115

vec_size = mem_size / page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1222

nr_pages = (sbuf.st_size + page_size - 1) / page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1223

force_read_pages(fmem, nr_pages, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1237

buf_size = page_size * 10;

tools/testing/selftests/mm/pagemap_ioctl.c

1265

LEN(vec[0]) == (buf_size/page_size) &&

tools/testing/selftests/mm/pagemap_ioctl.c

1290

mem = mmap(0, 2 * page_size, PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);

tools/testing/selftests/mm/pagemap_ioctl.c

1293

wp_init(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1294

wp_addr_range(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1297

memset(mem, 1, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1299

ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,

tools/testing/selftests/mm/pagemap_ioctl.c

1307

wp_addr_range(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1309

ksft_test_result(pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

1314

mem2 = mmap(mem + page_size, page_size, PROT_READ|PROT_WRITE,

tools/testing/selftests/mm/pagemap_ioctl.c

1318

wp_init(mem2, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1319

wp_addr_range(mem2, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1322

mprotect(mem, page_size, PROT_NONE);

tools/testing/selftests/mm/pagemap_ioctl.c

1323

mprotect(mem, 2 * page_size, PROT_READ);

tools/testing/selftests/mm/pagemap_ioctl.c

1324

mprotect(mem, 2 * page_size, PROT_READ|PROT_WRITE);

tools/testing/selftests/mm/pagemap_ioctl.c

1327

memset(mem, 2, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1330

mprotect(mem, page_size, PROT_NONE);

tools/testing/selftests/mm/pagemap_ioctl.c

1331

mprotect(mem, page_size, PROT_READ);

tools/testing/selftests/mm/pagemap_ioctl.c

1332

mprotect(mem, page_size, PROT_READ|PROT_WRITE);

tools/testing/selftests/mm/pagemap_ioctl.c

1334

ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,

tools/testing/selftests/mm/pagemap_ioctl.c

1343

wp_addr_range(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1345

memset(mem, 'A', 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1347

ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,

tools/testing/selftests/mm/pagemap_ioctl.c

1355

wp_free(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1356

munmap(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1368

int reset, int page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

1379

arg.end = (uintptr_t)(mem + count * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1422

__atomic_add_fetch(m + i * (page_size / sizeof(*m)), 1, __ATOMIC_SEQ_CST);

tools/testing/selftests/mm/pagemap_ioctl.c

1443

static void transact_test(int page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

1457

mem = mmap(NULL, page_size * nthreads * pages_per_thread, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/pagemap_ioctl.c

1462

wp_init(mem, page_size * nthreads * pages_per_thread);

tools/testing/selftests/mm/pagemap_ioctl.c

1463

wp_addr_range(mem, page_size * nthreads * pages_per_thread);

tools/testing/selftests/mm/pagemap_ioctl.c

1465

memset(mem, 0, page_size * nthreads * pages_per_thread);

tools/testing/selftests/mm/pagemap_ioctl.c

1467

count = get_dirty_pages_reset(mem, nthreads * pages_per_thread, 1, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1469

count = get_dirty_pages_reset(mem, nthreads * pages_per_thread, 1, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1474

pthread_create(&th, NULL, thread_proc, mem + page_size * i * pages_per_thread);

tools/testing/selftests/mm/pagemap_ioctl.c

1485

page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1495

c = get_dirty_pages_reset(mem, nthreads * pages_per_thread, 1, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1544

mem_size = 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1550

for (i = 0; i < mem_size; i += page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

1554

(mem_size / page_size), PAGE_IS_PFNZERO, 0, 0, PAGE_IS_PFNZERO);

tools/testing/selftests/mm/pagemap_ioctl.c

1558

ksft_test_result(ret == 1 && LEN(vec) == (mem_size / page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

1587

ksft_test_result(ret == 1 && LEN(vec) == (hpage_size / page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

1615

page_size = getpagesize();

tools/testing/selftests/mm/pagemap_ioctl.c

1626

mem_size = 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1639

mem_size = 512 * 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1711

buf_size = page_size * 10;

tools/testing/selftests/mm/pagemap_ioctl.c

1740

buf_size = page_size * 10;

tools/testing/selftests/mm/pagemap_ioctl.c

1777

transact_test(page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

193

mem_size = num_pages * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

213

vec_size = mem_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

250

mem_size = num_pages * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

323

for (i = 0; i < mem_size; i += 2 * page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

331

ksft_test_result((unsigned long long)ret == mem_size/(page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

357

for (i = 0; i < mem_size; i += 2 * page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

359

mem[(mem_size/page_size - 1) * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

378

vec_size = mem_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

382

ret = pagemap_ioctl(mem + page_size, 2 * page_size, vec, 1,

tools/testing/selftests/mm/pagemap_ioctl.c

394

vec[0].start == (uintptr_t)(mem + page_size) &&

tools/testing/selftests/mm/pagemap_ioctl.c

397

vec2[1].start == (uintptr_t)(mem + 3 * page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

40

size_t page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

426

ksft_test_result(ret == 1 && LEN(vec[0]) == mem_size/page_size,

tools/testing/selftests/mm/pagemap_ioctl.c

438

mem_size = 1050 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

439

vec_size = mem_size/(page_size*2);

tools/testing/selftests/mm/pagemap_ioctl.c

44

#define LEN(region) ((region.end - region.start)/page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

458

for (i = 0; i < mem_size/page_size; i += 2)

tools/testing/selftests/mm/pagemap_ioctl.c

459

mem[i * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

463

mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);

tools/testing/selftests/mm/pagemap_ioctl.c

471

mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);

tools/testing/selftests/mm/pagemap_ioctl.c

479

mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);

tools/testing/selftests/mm/pagemap_ioctl.c

485

ksft_test_result(total_pages == mem_size/(page_size*2), "%s Smaller max_pages\n", __func__);

tools/testing/selftests/mm/pagemap_ioctl.c

493

mem_size = 10000 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

511

for (i = 0; i < mem_size; i += page_size) {

tools/testing/selftests/mm/pagemap_ioctl.c

544

mem_size = vec_size * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

612

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

623

for (i = 0; i < mem_size; i += 2 * page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

637

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

644

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

672

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

699

vec_size = mem_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

719

ksft_test_result(written == 1 && LEN(vec[0]) == mem_size/page_size,

tools/testing/selftests/mm/pagemap_ioctl.c

728

memset(mem + page_size, 0, mem_size - (2 * page_size));

tools/testing/selftests/mm/pagemap_ioctl.c

752

mem[vec_size/2 * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

768

mem[vec_size/2 * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

769

mem[(vec_size/2 + 1) * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

771

written = pagemap_ioctl(&mem[vec_size/2 * page_size], 2 * page_size, vec, 1, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

776

ksft_test_result(written == 1 && vec[0].start == (uintptr_t)(&mem[vec_size/2 * page_size])

tools/testing/selftests/mm/pagemap_ioctl.c

809

unsigned long long vec_size = map_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

858

map[vec_size/2 * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

969

hpage_size/(2*page_size), PAGE_IS_WRITTEN, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

974

ksft_test_result(ret == 1 && LEN(vec[0]) == hpage_size/(2*page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

982

ksft_test_result(ret2 == 1 && LEN(vec[0]) == (map_size - hpage_size/2)/page_size,

tools/testing/selftests/mm/process_madv.c

133

const unsigned long pagesize = self->page_size;

tools/testing/selftests/mm/process_madv.c

216

const unsigned long pagesize = self->page_size;

tools/testing/selftests/mm/process_madv.c

22

unsigned long page_size;

tools/testing/selftests/mm/process_madv.c

257

const unsigned long pagesize = self->page_size;

tools/testing/selftests/mm/process_madv.c

290

const unsigned long pagesize = self->page_size;

tools/testing/selftests/mm/process_madv.c

30

self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/process_madv.c

347

const unsigned long pagesize = self->page_size;

tools/testing/selftests/mm/process_madv.c

62

const unsigned long pagesize = self->page_size;

tools/testing/selftests/mm/uffd-common.c

133

if (madvise(rel_area, gopts->nr_pages * gopts->page_size, MADV_REMOVE))

tools/testing/selftests/mm/uffd-common.c

140

size_t bytes = gopts->nr_pages * gopts->page_size, hpage_size = read_pmd_pagesize();

tools/testing/selftests/mm/uffd-common.c

17

return (pthread_mutex_t *) (area + nr * gopts->page_size);

tools/testing/selftests/mm/uffd-common.c

28

((unsigned long)(area + nr * gopts->page_size +

tools/testing/selftests/mm/uffd-common.c

281

if (munmap(*area, gopts->nr_pages * gopts->page_size))

tools/testing/selftests/mm/uffd-common.c

470

wp_range(gopts->uffd, msg->arg.pagefault.address, gopts->page_size, false);

tools/testing/selftests/mm/uffd-common.c

491

for (b = 0; b < gopts->page_size; ++b)

tools/testing/selftests/mm/uffd-common.c

493

continue_range(gopts->uffd, msg->arg.pagefault.address, gopts->page_size,

tools/testing/selftests/mm/uffd-common.c

522

offset &= ~(gopts->page_size-1);

tools/testing/selftests/mm/uffd-common.c

55

if (madvise(rel_area, gopts->nr_pages * gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-common.c

61

*alloc_area = mmap(NULL, gopts->nr_pages * gopts->page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/uffd-common.c

631

if (offset >= gopts->nr_pages * gopts->page_size)

tools/testing/selftests/mm/uffd-common.c

635

uffdio_copy.len = gopts->page_size;

tools/testing/selftests/mm/uffd-common.c

646

wake_range(gopts->uffd, uffdio_copy.dst, gopts->page_size);

tools/testing/selftests/mm/uffd-common.c

647

} else if (uffdio_copy.copy != gopts->page_size) {

tools/testing/selftests/mm/uffd-common.c

668

if (offset + len > gopts->nr_pages * gopts->page_size)

tools/testing/selftests/mm/uffd-common.c

78

if (madvise(rel_area, gopts->nr_pages * gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-common.c

81

if (madvise(rel_area, gopts->nr_pages * gopts->page_size, MADV_REMOVE))

tools/testing/selftests/mm/uffd-common.c

88

off_t size = gopts->nr_pages * gopts->page_size;

tools/testing/selftests/mm/uffd-common.h

60

unsigned long nr_parallel, nr_pages, nr_pages_per_cpu, page_size;

tools/testing/selftests/mm/uffd-stress.c

172

copy_page_retry(gopts, page_nr * gopts->page_size);

tools/testing/selftests/mm/uffd-stress.c

180

wp_range(gopts->uffd, (unsigned long)gopts->area_dst + start_nr * gopts->page_size,

tools/testing/selftests/mm/uffd-stress.c

181

gopts->nr_pages_per_cpu * gopts->page_size, true);

tools/testing/selftests/mm/uffd-stress.c

188

copy_page_retry(gopts, page_nr * gopts->page_size);

tools/testing/selftests/mm/uffd-stress.c

267

uint64_t mem_size = gopts->nr_pages * gopts->page_size;

tools/testing/selftests/mm/uffd-stress.c

278

if (posix_memalign(&area, gopts->page_size, gopts->page_size))

tools/testing/selftests/mm/uffd-stress.c

281

bzero(zeropage, gopts->page_size);

tools/testing/selftests/mm/uffd-stress.c

350

gopts->nr_pages * gopts->page_size, false);

tools/testing/selftests/mm/uffd-stress.c

411

gopts->page_size = default_huge_page_size();

tools/testing/selftests/mm/uffd-stress.c

413

gopts->page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/uffd-stress.c

415

if (!gopts->page_size)

tools/testing/selftests/mm/uffd-stress.c

418

> gopts->page_size)

tools/testing/selftests/mm/uffd-stress.c

484

unsigned long nr = 2 * (bytes / gopts->page_size) + gopts->nr_parallel - 1;

tools/testing/selftests/mm/uffd-stress.c

490

gopts->nr_pages_per_cpu = bytes / gopts->page_size / gopts->nr_parallel;

tools/testing/selftests/mm/uffd-stress.c

493

bytes, gopts->page_size, gopts->nr_parallel);

tools/testing/selftests/mm/uffd-unit-tests.c

1016

uffd_register_poison(gopts->uffd, gopts->area_dst, poison_pages * gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

1017

memset(gopts->area_src, 0, poison_pages * gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

1030

unsigned long offset = nr * gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1044

for (i = bytes; i < bytes + gopts->page_size; ++i) {

tools/testing/selftests/mm/uffd-unit-tests.c

1088

uffd_move_handle_fault_common(gopts, msg, args, gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

1118

if (madvise(gopts->area_src, gopts->nr_pages * gopts->page_size, MADV_DONTFORK))

tools/testing/selftests/mm/uffd-unit-tests.c

1121

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

1129

step_size = chunk_size / gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1132

if (chunk_size > gopts->page_size) {

tools/testing/selftests/mm/uffd-unit-tests.c

1137

src_offs = (aligned_src - gopts->area_src) / gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1138

dst_offs = (aligned_dst - gopts->area_dst) / gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1180

if (chunk_size > gopts->page_size) {

tools/testing/selftests/mm/uffd-unit-tests.c

1198

uffd_move_test_common(gopts, targs, gopts->page_size, uffd_move_handle_fault);

tools/testing/selftests/mm/uffd-unit-tests.c

1203

if (madvise(gopts->area_dst, gopts->nr_pages * gopts->page_size, MADV_HUGEPAGE))

tools/testing/selftests/mm/uffd-unit-tests.c

1211

if (madvise(gopts->area_dst, gopts->nr_pages * gopts->page_size, MADV_NOHUGEPAGE))

tools/testing/selftests/mm/uffd-unit-tests.c

1330

ret = madvise(gopts->area_dst, gopts->page_size, MADV_REMOVE);

tools/testing/selftests/mm/uffd-unit-tests.c

1355

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

1404

if (madvise(gopts->area_src, gopts->nr_pages * gopts->page_size, MADV_NOHUGEPAGE)) {

tools/testing/selftests/mm/uffd-unit-tests.c

1418

if (madvise(gopts->area_src, gopts->nr_pages * gopts->page_size, MADV_HUGEPAGE)) {

tools/testing/selftests/mm/uffd-unit-tests.c

1452

ret = uffd_register_with_ioctls(gopts->uffd, gopts->area_dst, gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

1483

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

1791

gopts.page_size = hugepage_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1792

if (gopts.page_size == 0) {

tools/testing/selftests/mm/uffd-unit-tests.c

1797

gopts.page_size = psize();

tools/testing/selftests/mm/uffd-unit-tests.c

1801

gopts.nr_pages = MAX(UFFD_TEST_MEM_SIZE, gopts.page_size * 2)

tools/testing/selftests/mm/uffd-unit-tests.c

1802

/ gopts.page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

284

if (test_pin && pin_pages(&args, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

322

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

329

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

334

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, false);

tools/testing/selftests/mm/uffd-unit-tests.c

339

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

340

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

350

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

354

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

357

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

369

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

377

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

398

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

405

madvise(gopts->area_dst, gopts->page_size, MADV_PAGEOUT);

tools/testing/selftests/mm/uffd-unit-tests.c

418

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, false);

tools/testing/selftests/mm/uffd-unit-tests.c

428

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

450

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->page_size, false, true, false))

tools/testing/selftests/mm/uffd-unit-tests.c

457

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

463

if (pin_pages(&pin_args, gopts->area_dst, gopts->page_size)) {

tools/testing/selftests/mm/uffd-unit-tests.c

467

uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

491

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

513

for (j = 0; j < gopts->page_size; j++) {

tools/testing/selftests/mm/uffd-unit-tests.c

514

uint8_t v = *(uint8_t *)(p + (i * gopts->page_size) + j);

tools/testing/selftests/mm/uffd-unit-tests.c

535

if (uffd_register(gopts->uffd, gopts->area_dst_alias, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

545

memset(gopts->area_dst + (p * gopts->page_size), p % ((uint8_t)-1),

tools/testing/selftests/mm/uffd-unit-tests.c

546

gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

566

if (madvise(gopts->area_dst_alias, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

575

gopts->nr_pages * gopts->page_size /

tools/testing/selftests/mm/uffd-unit-tests.c

660

unsigned long offset = nr * gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

680

gopts->page_size, false);

tools/testing/selftests/mm/uffd-unit-tests.c

703

gopts->area_dst = mremap(gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

704

gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

728

for (i = 0; i < gopts->page_size; i++)

tools/testing/selftests/mm/uffd-unit-tests.c

729

if (*(gopts->area_dst + nr * gopts->page_size + i) != 0)

tools/testing/selftests/mm/uffd-unit-tests.c

749

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

808

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

873

uffdio_zeropage.range.len = gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

884

if (res != gopts->page_size)

tools/testing/selftests/mm/uffd-unit-tests.c

920

gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

923

uffd_register_detect_zeropage(gopts->uffd, gopts->area_dst_alias, gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

926

for (i = 0; i < gopts->page_size; i++)

tools/testing/selftests/mm/uffd-unit-tests.c

930

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

935

gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

961

uffdio_poison.range.len = gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

968

else if (res != gopts->page_size)

tools/testing/selftests/mm/uffd-unit-tests.c

986

offset &= ~(gopts->page_size-1);

tools/testing/selftests/mm/uffd-unit-tests.c

989

if (offset & gopts->page_size)

tools/testing/selftests/namespaces/listns_efault_test.c

181

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

190

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

259

long page_size;

tools/testing/selftests/namespaces/listns_efault_test.c

267

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/namespaces/listns_efault_test.c

268

ASSERT_GT(page_size, 0);

tools/testing/selftests/namespaces/listns_efault_test.c

271

map = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/namespaces/listns_efault_test.c

276

ret = munmap((char *)map + page_size, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

283

ns_ids = ((__u64 *)((char *)map + page_size)) - 5;

tools/testing/selftests/namespaces/listns_efault_test.c

397

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

40

long page_size;

tools/testing/selftests/namespaces/listns_efault_test.c

406

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

418

long page_size;

tools/testing/selftests/namespaces/listns_efault_test.c

426

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/namespaces/listns_efault_test.c

427

ASSERT_GT(page_size, 0);

tools/testing/selftests/namespaces/listns_efault_test.c

430

map = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/namespaces/listns_efault_test.c

434

ret = munmap((char *)map + page_size, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

438

ns_ids = ((__u64 *)((char *)map + page_size)) - 3;

tools/testing/selftests/namespaces/listns_efault_test.c

48

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/namespaces/listns_efault_test.c

49

ASSERT_GT(page_size, 0);

tools/testing/selftests/namespaces/listns_efault_test.c

539

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

547

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

56

map = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/namespaces/listns_efault_test.c

61

ret = munmap((char *)map + page_size, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

69

ns_ids = ((__u64 *)((char *)map + page_size)) - 1;

tools/testing/selftests/net/ipsec.c

1751

if (do_ping(cmd_fd, buf, page_size, src, true, 0, 0, udp_ping_send)) {

tools/testing/selftests/net/ipsec.c

1776

if (do_ping(cmd_fd, buf, page_size, tunsrc,

tools/testing/selftests/net/ipsec.c

1900

if (do_ping(cmd_fd, buf, page_size, tun_reply ? tunsrc : src,

tools/testing/selftests/net/ipsec.c

1986

data_map = mmap(0, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/net/ipsec.c

1993

randomize_buffer(data_map, page_size);

tools/testing/selftests/net/ipsec.c

2299

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/net/ipsec.c

2300

if (page_size < 1)

tools/testing/selftests/net/ipsec.c

68

static long page_size;

tools/testing/selftests/net/ipsec.c

782

ping_succeeded += !func(ping_sock, to, d_port, buf, page_size);

tools/testing/selftests/nolibc/nolibc-test.c

1230

int ret, fd, i, page_size;

tools/testing/selftests/nolibc/nolibc-test.c

1242

page_size = getpagesize();

tools/testing/selftests/nolibc/nolibc-test.c

1243

if (page_size < 0)

tools/testing/selftests/nolibc/nolibc-test.c

1263

file_size = 3*page_size;

tools/testing/selftests/nolibc/nolibc-test.c

1271

pa_offset = offset & ~(page_size - 1);

tools/testing/selftests/perf_events/watermark_signal.c

104

p = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

tools/testing/selftests/perf_events/watermark_signal.c

131

munmap(p, 2 * page_size);

tools/testing/selftests/perf_events/watermark_signal.c

49

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/powerpc/copyloops/exc_validate.c

103

q = p + page_size - MAX_LEN;

tools/testing/selftests/powerpc/copyloops/exc_validate.c

81

int page_size;

tools/testing/selftests/powerpc/copyloops/exc_validate.c

85

page_size = getpagesize();

tools/testing/selftests/powerpc/copyloops/exc_validate.c

86

p = mmap(NULL, page_size * 2, PROT_READ|PROT_WRITE,

tools/testing/selftests/powerpc/copyloops/exc_validate.c

94

memset(p, 0, page_size);

tools/testing/selftests/powerpc/copyloops/exc_validate.c

98

if (mprotect(p + page_size, page_size, PROT_NONE)) {

tools/testing/selftests/powerpc/mm/bad_accesses.c

69

unsigned long i, j, addr, region_shift, page_shift, page_size;

tools/testing/selftests/powerpc/mm/bad_accesses.c

82

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/powerpc/mm/bad_accesses.c

83

if (page_size == (64 * 1024))

tools/testing/selftests/powerpc/mm/bad_accesses.c

88

if (page_size == (64 * 1024) || !hash_mmu) {

tools/testing/selftests/powerpc/mm/bad_accesses.c

93

} else if (page_size == (4 * 1024) && hash_mmu) {

tools/testing/selftests/powerpc/mm/large_vm_fork_separation.c

27

unsigned long page_size;

tools/testing/selftests/powerpc/mm/large_vm_fork_separation.c

30

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/powerpc/mm/large_vm_fork_separation.c

31

SKIP_IF(page_size != 65536);

tools/testing/selftests/powerpc/mm/large_vm_fork_separation.c

34

p = mmap((void *)(512ul << 40), page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/powerpc/mm/large_vm_gpr_corruption.c

106

unsigned long page_size, addr, *p;

tools/testing/selftests/powerpc/mm/large_vm_gpr_corruption.c

118

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/powerpc/mm/large_vm_gpr_corruption.c

123

p = mmap((void *)addr, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/powerpc/mm/stack_expansion_ldst.c

157

static void test_one_type(enum access_type type, unsigned long page_size, unsigned long rlim_cur)

tools/testing/selftests/powerpc/mm/stack_expansion_ldst.c

162

for (delta = page_size; delta <= rlim_cur; delta += page_size)

tools/testing/selftests/powerpc/mm/stack_expansion_ldst.c

173

unsigned long page_size;

tools/testing/selftests/powerpc/mm/stack_expansion_ldst.c

176

page_size = getpagesize();

tools/testing/selftests/powerpc/mm/stack_expansion_ldst.c

181

test_one_type(LOAD, page_size, rlimit.rlim_cur);

tools/testing/selftests/powerpc/mm/stack_expansion_ldst.c

183

test_one_type(STORE, page_size, rlimit.rlim_cur);

tools/testing/selftests/powerpc/mm/tlbie_test.c

569

int page_size = getpagesize();

tools/testing/selftests/powerpc/mm/tlbie_test.c

570

size_t size = page_size;

tools/testing/selftests/powerpc/mm/tlbie_test.c

615

int page_size = getpagesize();

tools/testing/selftests/powerpc/mm/tlbie_test.c

653

shmid = shmget(shm_key, page_size, IPC_CREAT|0666);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c

179

size_t page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c

189

mmap_size = page_size * (1 + mmap_pages);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c

209

size_t page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c

210

struct perf_event_header *header = sample_buff + page_size;

tools/testing/selftests/powerpc/pmu/sampling_tests/misc.c

246

return sample_buff + page_size + data_tail;

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

125

page_size = getpagesize();

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

126

mem_region = mmap(NULL, page_size * 2, PROT_READ|PROT_WRITE,

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

131

for (i = 0; i < page_size; i++)

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

134

memset(mem_region+page_size, 0, page_size);

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

138

for (i = 0; i < page_size; i++)

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

38

static int page_size;

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

43

if (mprotect(mem_region + page_size, page_size, PROT_NONE)) {

tools/testing/selftests/powerpc/primitives/load_unaligned_zeropad.c

53

if (mprotect(mem_region + page_size, page_size, PROT_READ|PROT_WRITE)) {

tools/testing/selftests/proc/proc-maps-race.c

140

bytes_read = read(self->maps_fd, page->data, self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

493

return mmap(self->mod_info->addr, self->page_size, self->mod_info->prot | PROT_EXEC,

tools/testing/selftests/proc/proc-maps-race.c

499

return mmap(self->mod_info->addr, self->page_size, self->mod_info->prot,

tools/testing/selftests/proc/proc-maps-race.c

515

return mremap(self->mod_info->addr, self->page_size * 3,

tools/testing/selftests/proc/proc-maps-race.c

516

self->page_size, 0) != MAP_FAILED;

tools/testing/selftests/proc/proc-maps-race.c

521

return mremap(self->mod_info->addr, self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

522

self->page_size * 3, 0) != MAP_FAILED;

tools/testing/selftests/proc/proc-maps-race.c

543

return mremap(self->mod_info->next_addr + self->page_size * 2, self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

544

self->page_size, MREMAP_FIXED | MREMAP_MAYMOVE | MREMAP_DONTUNMAP,

tools/testing/selftests/proc/proc-maps-race.c

545

self->mod_info->addr + self->page_size) != MAP_FAILED;

tools/testing/selftests/proc/proc-maps-race.c

550

return mprotect(self->mod_info->addr + self->page_size, self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

576

self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);

tools/testing/selftests/proc/proc-maps-race.c

586

self->vma_count = self->page_size / 32 + 1;

tools/testing/selftests/proc/proc-maps-race.c

613

mod_info->child_mapped_addr[i] = mmap(NULL, self->page_size * 3, prot,

tools/testing/selftests/proc/proc-maps-race.c

640

munmap(mod_info->child_mapped_addr[i], self->page_size * 3);

tools/testing/selftests/proc/proc-maps-race.c

662

self->page1.data = malloc(self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

664

self->page2.data = malloc(self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

672

self->page_size * 3);

tools/testing/selftests/proc/proc-maps-race.c

711

munmap(self->mod_info->child_mapped_addr[i], self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

790

ASSERT_TRUE(query_addr_at(self->maps_fd, mod_info->addr + self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

880

(vma_end - vma_start == self->page_size * 3 ||

tools/testing/selftests/proc/proc-maps-race.c

881

vma_end - vma_start == self->page_size));

tools/testing/selftests/proc/proc-maps-race.c

94

int page_size;

tools/testing/selftests/proc/proc-maps-race.c

954

ASSERT_TRUE(query_addr_at(self->maps_fd, mod_info->addr + self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

962

vma_end - vma_start == self->page_size * 3) ||

tools/testing/selftests/proc/proc-maps-race.c

963

(vma_start == self->last_line.start_addr + self->page_size &&

tools/testing/selftests/proc/proc-maps-race.c

964

vma_end - vma_start == self->page_size));

tools/testing/selftests/ring-buffer/map_test.c

103

if (page_size < desc->meta->meta_struct_len) {

tools/testing/selftests/ring-buffer/map_test.c

106

munmap(desc->meta, page_size);

tools/testing/selftests/ring-buffer/map_test.c

107

page_size = meta_page_size;

tools/testing/selftests/ring-buffer/map_test.c

81

int page_size = getpagesize();

tools/testing/selftests/ring-buffer/map_test.c

96

map = mmap(NULL, page_size, PROT_READ, MAP_SHARED, desc->cpu_fd, 0);

tools/testing/selftests/seccomp/seccomp_bpf.c

781

int page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/seccomp/seccomp_bpf.c

783

ASSERT_LT(0, page_size);

tools/testing/selftests/seccomp/seccomp_bpf.c

796

NULL, page_size, PROT_READ, MAP_PRIVATE, fd, page_size);

tools/testing/selftests/seccomp/seccomp_bpf.c

800

NULL, page_size, PROT_READ, MAP_PRIVATE, fd, 0x0C0FFEE);

tools/testing/selftests/seccomp/seccomp_bpf.c

804

munmap(map1, page_size);

tools/testing/selftests/seccomp/seccomp_bpf.c

805

munmap(map2, page_size);

tools/testing/selftests/user_events/perf_test.c

158

int page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/user_events/perf_test.c

190

perf_page = mmap(NULL, page_size * 2, PROT_READ, MAP_SHARED, fd, 0);

tools/testing/selftests/user_events/perf_test.c

211

munmap(perf_page, page_size * 2);

tools/testing/selftests/user_events/perf_test.c

222

int page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/user_events/perf_test.c

252

perf_page = mmap(NULL, page_size * 2, PROT_READ, MAP_SHARED, fd, 0);

tools/testing/selftests/user_events/perf_test.c

264

munmap(perf_page, page_size * 2);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

62

size_t page_size = getpagesize();

tools/testing/selftests/vDSO/vdso_test_getrandom.c

69

alloc_size = (num * state_size_aligned + page_size - 1) & (~(page_size - 1));

tools/testing/selftests/vDSO/vdso_test_getrandom.c

70

num = (page_size / state_size_aligned) * (alloc_size / page_size);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

83

if (((uintptr_t)new_block & (page_size - 1)) + vgrnd.params.size_of_opaque_state > page_size)

tools/testing/selftests/vDSO/vdso_test_getrandom.c

84

new_block = (void *)(((uintptr_t)new_block + page_size - 1) & (~(page_size - 1)));

tools/testing/vsock/vsock_test.c

390

int page_size;

tools/testing/vsock/vsock_test.c

414

page_size = getpagesize();

tools/testing/vsock/vsock_test.c

415

max_msg_size = MAX_MSG_PAGES * page_size;

tools/testing/vsock/vsock_test.c

425

buf_size = page_size +

tools/testing/vsock/vsock_test.c

426

(rand() % (max_msg_size - page_size));

tools/testing/vsock/vsock_test.c

428

buf_size = 1 + (rand() % page_size);

tools/testing/vsock/vsock_test.c

768

int page_size = getpagesize();

tools/testing/vsock/vsock_test.c

769

int buf_size = page_size * 3;

tools/testing/vsock/vsock_test.c

789

if (munmap(broken_buf + page_size, page_size)) {

tools/testing/vsock/vsock_test.c

838

munmap(broken_buf, page_size);

tools/testing/vsock/vsock_test.c

839

munmap(broken_buf + page_size * 2, page_size);