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

183

unsigned long page_size);

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

84

unsigned long page_size);

arch/powerpc/include/asm/ps3.h

121

struct ps3_dma_region *r, enum ps3_dma_page_size page_size,

arch/powerpc/include/asm/ps3.h

150

enum ps3_mmio_page_size page_size;

arch/powerpc/include/asm/ps3.h

167

enum ps3_mmio_page_size page_size);

arch/powerpc/include/asm/ps3.h

85

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

1023

unsigned long page_size = 1UL << page_shift;

arch/powerpc/mm/book3s64/radix_tlb.c

1090

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

arch/powerpc/mm/book3s64/radix_tlb.c

1099

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

arch/powerpc/mm/book3s64/radix_tlb.c

1106

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

arch/powerpc/mm/book3s64/radix_tlb.c

1130

static int radix_get_mmu_psize(int page_size)

arch/powerpc/mm/book3s64/radix_tlb.c

1134

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

arch/powerpc/mm/book3s64/radix_tlb.c

1136

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

arch/powerpc/mm/book3s64/radix_tlb.c

1138

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

arch/powerpc/mm/book3s64/radix_tlb.c

1150

unsigned long page_size)

arch/powerpc/mm/book3s64/radix_tlb.c

1152

int psize = radix_get_mmu_psize(page_size);

arch/powerpc/mm/book3s64/radix_tlb.c

1188

int page_size = tlb->page_size;

arch/powerpc/mm/book3s64/radix_tlb.c

1222

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

arch/powerpc/mm/book3s64/radix_tlb.c

1241

unsigned long page_size = 1UL << page_shift;

arch/powerpc/mm/book3s64/radix_tlb.c

1291

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

arch/powerpc/mm/book3s64/radix_tlb.c

1293

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

arch/powerpc/mm/book3s64/radix_tlb.c

1296

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

arch/powerpc/mm/book3s64/radix_tlb.c

1499

unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

1505

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

arch/powerpc/mm/book3s64/radix_tlb.c

1508

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

arch/powerpc/mm/book3s64/radix_tlb.c

1513

unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

1519

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

arch/powerpc/mm/book3s64/radix_tlb.c

432

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

438

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

arch/powerpc/mm/book3s64/radix_tlb.c

453

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

459

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

arch/powerpc/mm/book3s64/radix_tlb.c

464

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

470

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

arch/powerpc/mm/book3s64/radix_tlb.c

473

fixup_tlbie_va_range(addr - page_size, pid, ap);

arch/powerpc/mm/book3s64/radix_tlb.c

521

unsigned long page_size;

arch/powerpc/mm/book3s64/radix_tlb.c

530

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

arch/powerpc/mm/book3s64/radix_tlb.c

546

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

552

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

arch/powerpc/mm/book3s64/radix_tlb.c

558

unsigned long pid, unsigned long page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

563

.pid = pid, .page_size = page_size,

arch/powerpc/mm/book3s64/radix_tlb.c

568

_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

189

unsigned long page_size)

arch/powerpc/mm/init_64.c

191

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

arch/powerpc/mm/init_64.c

207

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

arch/powerpc/mm/init_64.c

210

start = ALIGN_DOWN(start, page_size);

arch/powerpc/mm/init_64.c

214

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

arch/powerpc/mm/init_64.c

224

if (vmemmap_populated(start, page_size))

arch/powerpc/mm/init_64.c

232

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

arch/powerpc/mm/init_64.c

233

p = vmemmap_alloc_block_buf(page_size, node, altmap);

arch/powerpc/mm/init_64.c

240

p = vmemmap_alloc_block_buf(page_size, node, NULL);

arch/powerpc/mm/init_64.c

253

int nr_pfns = page_size >> PAGE_SHIFT;

arch/powerpc/mm/init_64.c

254

unsigned long page_order = get_order(page_size);

arch/powerpc/mm/init_64.c

264

start, start + page_size, p);

arch/powerpc/mm/init_64.c

266

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

arch/powerpc/mm/init_64.c

323

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

arch/powerpc/mm/init_64.c

324

unsigned long page_order = get_order(page_size);

arch/powerpc/mm/init_64.c

328

start = ALIGN_DOWN(start, page_size);

arch/powerpc/mm/init_64.c

336

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

arch/powerpc/mm/init_64.c

346

if (vmemmap_populated(start, page_size))

arch/powerpc/mm/init_64.c

361

if (page_size < PAGE_SIZE) {

arch/powerpc/mm/init_64.c

375

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

1119

struct ps3_dma_region *r, enum ps3_dma_page_size page_size,

arch/powerpc/platforms/ps3/mm.c

1128

r->page_size = page_size;

arch/powerpc/platforms/ps3/mm.c

1133

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

654

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

arch/powerpc/platforms/ps3/mm.c

657

BUG_ON(!r->page_size);

arch/powerpc/platforms/ps3/mm.c

664

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

arch/powerpc/platforms/ps3/mm.c

687

r->page_size,

arch/powerpc/platforms/ps3/mm.c

696

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

arch/powerpc/platforms/ps3/mm.c

782

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

arch/powerpc/platforms/ps3/mm.c

784

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

837

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

arch/powerpc/platforms/ps3/mm.c

839

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

897

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

899

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

arch/powerpc/platforms/ps3/mm.c

934

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

937

1 << r->page_size);

arch/powerpc/platforms/ps3/mm.c

977

if (r->page_size != PS3_DMA_16M) {

arch/powerpc/platforms/ps3/mm.c

980

r->page_size = PS3_DMA_16M;

arch/powerpc/platforms/ps3/mm.c

981

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

52

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

64

control_code_buffer_sz = page_size(image->control_code_page);

arch/riscv/kvm/gstage.c

168

gpa_t gpa, phys_addr_t hpa, unsigned long page_size,

arch/riscv/kvm/gstage.c

178

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

arch/riscv/kvm/gstage.c

218

unsigned long next_page_size, page_size;

arch/riscv/kvm/gstage.c

220

ret = gstage_level_to_page_size(ptep_level, &page_size);

arch/riscv/kvm/gstage.c

224

WARN_ON(addr & (page_size - 1));

arch/riscv/kvm/gstage.c

261

unsigned long page_size;

arch/riscv/kvm/gstage.c

266

ret = gstage_level_to_page_size(ptep_level, &page_size);

arch/riscv/kvm/gstage.c

273

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

arch/riscv/kvm/gstage.c

278

addr += page_size;

arch/riscv/kvm/gstage.c

296

unsigned long page_size;

arch/riscv/kvm/gstage.c

300

ret = gstage_level_to_page_size(ptep_level, &page_size);

arch/riscv/kvm/gstage.c

307

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

arch/riscv/kvm/gstage.c

312

addr += page_size;

arch/riscv/kvm/gstage.c

43

static int gstage_page_size_to_level(unsigned long page_size, u32 *out_level)

arch/riscv/kvm/gstage.c

49

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

2783

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

arch/sparc/mm/init_64.c

2789

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

110

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

arch/x86/coco/sev/internal.h

114

pfn, action, page_size, ret, svsm_ret);

arch/x86/coco/sev/svsm.c

109

pe->page_size = RMP_PG_SIZE_4K;

arch/x86/coco/sev/svsm.c

140

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

arch/x86/coco/sev/svsm.c

160

unsigned int page_size;

arch/x86/coco/sev/svsm.c

166

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

arch/x86/coco/sev/svsm.c

168

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

arch/x86/coco/sev/svsm.c

219

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

2318

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

383

size_remaining -= page_size(page);

drivers/dma-buf/heaps/system_heap.c

394

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

drivers/gpu/drm/drm_pagemap.c

266

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

drivers/gpu/drm/drm_pagemap.c

739

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

1288

resource_size_t page_size,

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

1317

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

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

1335

&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

101

unsigned int i, page_size;

drivers/gpu/drm/v3d/v3d_mmu.c

107

page_size = SZ_1M;

drivers/gpu/drm/v3d/v3d_mmu.c

111

page_size = SZ_64K;

drivers/gpu/drm/v3d/v3d_mmu.c

114

page_size = SZ_4K;

drivers/gpu/drm/v3d/v3d_mmu.c

117

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

drivers/gpu/drm/v3d/v3d_mmu.c

122

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

107

page_size);

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

51

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

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

58

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

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

68

phys_base = pte & ~(page_size - 1);

drivers/gpu/drm/xe/xe_bo.c

2984

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

drivers/gpu/drm/xe/xe_bo.c

2990

xe_assert(xe, page_size <= PAGE_SIZE);

drivers/gpu/drm/xe/xe_bo.c

2998

page_size, &cur);

drivers/gpu/drm/xe/xe_bo.c

3004

page_size, &cur);

drivers/gpu/drm/xe/xe_bo.c

3009

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

drivers/gpu/drm/xe/xe_bo.c

3013

return __xe_bo_addr(bo, offset, page_size);

drivers/gpu/drm/xe/xe_bo.c

3635

u32 page_size = max_t(u32, PAGE_SIZE,

drivers/gpu/drm/xe/xe_bo.c

3638

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

drivers/gpu/drm/xe/xe_bo.h

230

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

drivers/gpu/drm/xe/xe_bo.h

231

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

drivers/gpu/drm/xe/xe_bo.h

234

xe_bo_main_addr(struct xe_bo *bo, size_t page_size)

drivers/gpu/drm/xe/xe_bo.h

236

return xe_bo_addr(bo, 0, page_size);

drivers/gpu/drm/xe/xe_lmtt.c

469

u64 page_size = lmtt_page_size(lmtt);

drivers/gpu/drm/xe/xe_lmtt.c

474

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

drivers/gpu/drm/xe/xe_lmtt.c

475

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

drivers/gpu/drm/xe/xe_lmtt.c

489

xe_res_next(&cur, page_size);

drivers/gpu/drm/xe/xe_lmtt.c

490

start += page_size;

drivers/gpu/drm/xe/xe_pt.c

1185

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

drivers/gpu/drm/xe/xe_pt.c

1190

start = entry->ofs * page_size;

drivers/gpu/drm/xe/xe_pt.c

1191

end = start + page_size * entry->qwords;

drivers/gpu/drm/xe/xe_pt.c

1579

#define COMPUTE_RECLAIM_ADDRESS_MASK(page_size) \

drivers/gpu/drm/xe/xe_pt.c

1581

BUILD_BUG_ON(!__builtin_constant_p(page_size)); \

drivers/gpu/drm/xe/xe_pt.c

1582

ilog2(page_size) - XE_PTE_SHIFT; \

drivers/hv/hv_balloon.c

1613

range->page_size = HV_GPA_PAGE_RANGE_PAGE_SIZE_2MB;

drivers/infiniband/core/umem.c

101

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

drivers/infiniband/core/umem.c

104

if (!(pgsz_bitmap & page_size))

drivers/infiniband/core/umem.c

106

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

2732

unsigned int *meta_sg_offset, unsigned int page_size)

drivers/infiniband/core/verbs.c

2738

mr->page_size = page_size;

drivers/infiniband/core/verbs.c

2773

unsigned int *sg_offset, unsigned int page_size)

drivers/infiniband/core/verbs.c

2778

mr->page_size = page_size;

drivers/infiniband/core/verbs.c

2813

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

drivers/infiniband/core/verbs.c

2858

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

2782

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

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4234

unsigned long page_size;

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4245

page_size = ib_umem_find_best_pgsz(umem, BNXT_RE_PAGE_SIZE_SUPPORTED, virt_addr);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4246

if (!page_size) {

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4279

umem_pgs = ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/bnxt_re/ib_verbs.c

4281

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

1179

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

593

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

drivers/infiniband/hw/erdma/erdma_verbs.c

841

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

drivers/infiniband/hw/erdma/erdma_verbs.c

842

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

drivers/infiniband/hw/erdma/erdma_verbs.c

843

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

456

ibmr->page_size < HNS_HW_PAGE_SIZE ||

drivers/infiniband/hw/hns/hns_roce_mr.c

457

ibmr->page_size > HNS_HW_MAX_PAGE_SIZE)

drivers/infiniband/hw/hns/hns_roce_mr.c

482

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

drivers/infiniband/hw/hns/hns_roce_mr.c

558

size_t page_size = 1 << page_shift;

drivers/infiniband/hw/hns/hns_roce_mr.c

562

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

1132

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1145

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1156

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1177

u32 page_size;

drivers/infiniband/hw/irdma/type.h

1209

u32 page_size;

drivers/infiniband/hw/irdma/verbs.c

2800

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

drivers/infiniband/hw/irdma/verbs.c

2924

pg_size = iwmr->page_size;

drivers/infiniband/hw/irdma/verbs.c

3023

info->page_size = PAGE_SIZE;

drivers/infiniband/hw/irdma/verbs.c

3121

info->page_size = PAGE_SIZE;

drivers/infiniband/hw/irdma/verbs.c

3283

stag_info->page_size = iwmr->page_size;

drivers/infiniband/hw/irdma/verbs.c

3327

iwmr->page_size);

drivers/infiniband/hw/irdma/verbs.c

3387

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

drivers/infiniband/hw/irdma/verbs.c

3388

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

drivers/infiniband/hw/irdma/verbs.c

3395

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

drivers/infiniband/hw/irdma/verbs.c

3707

iwmr->page_size = ib_umem_find_best_pgsz(region,

drivers/infiniband/hw/irdma/verbs.c

3710

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

drivers/infiniband/hw/irdma/verbs.c

3717

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

drivers/infiniband/hw/irdma/verbs.c

3836

iwmr->page_size = SZ_4K;

drivers/infiniband/hw/irdma/verbs.c

4111

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

drivers/infiniband/hw/irdma/verbs.h

118

u64 page_size;

drivers/infiniband/hw/mlx4/mr.c

184

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

drivers/infiniband/hw/mlx4/qp.c

3325

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

drivers/infiniband/hw/mlx5/cq.c

1322

unsigned long page_size;

drivers/infiniband/hw/mlx5/cq.c

1328

page_size = mlx5_umem_find_best_cq_quantized_pgoff(

drivers/infiniband/hw/mlx5/cq.c

1332

if (!page_size) {

drivers/infiniband/hw/mlx5/cq.c

1336

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

drivers/infiniband/hw/mlx5/cq.c

1337

page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/cq.c

724

unsigned long page_size;

drivers/infiniband/hw/mlx5/cq.c

760

page_size = mlx5_umem_find_best_cq_quantized_pgoff(

drivers/infiniband/hw/mlx5/cq.c

763

if (!page_size) {

drivers/infiniband/hw/mlx5/cq.c

772

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

drivers/infiniband/hw/mlx5/cq.c

777

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

drivers/infiniband/hw/mlx5/cq.c

788

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

drivers/infiniband/hw/mlx5/cq.c

792

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/devx.c

2284

unsigned long page_size;

drivers/infiniband/hw/mlx5/devx.c

2295

page_size = ib_umem_find_best_pgoff(umem, pgsz_bitmap, U64_MAX);

drivers/infiniband/hw/mlx5/devx.c

2296

if (!page_size)

drivers/infiniband/hw/mlx5/devx.c

2305

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

drivers/infiniband/hw/mlx5/devx.c

2306

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

drivers/infiniband/hw/mlx5/devx.c

2307

page_size > PAGE_SIZE)

drivers/infiniband/hw/mlx5/devx.c

2308

page_size /= 2;

drivers/infiniband/hw/mlx5/devx.c

2310

return page_size;

drivers/infiniband/hw/mlx5/devx.c

2320

unsigned int page_size;

drivers/infiniband/hw/mlx5/devx.c

2344

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

drivers/infiniband/hw/mlx5/devx.c

2345

if (!page_size)

drivers/infiniband/hw/mlx5/devx.c

2350

ib_umem_num_dma_blocks(obj->umem, page_size));

drivers/infiniband/hw/mlx5/devx.c

2360

ib_umem_num_dma_blocks(obj->umem, page_size));

drivers/infiniband/hw/mlx5/devx.c

2362

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/devx.c

2364

ib_umem_dma_offset(obj->umem, page_size));

drivers/infiniband/hw/mlx5/devx.c

2369

mlx5_ib_populate_pas(obj->umem, page_size, mtt,

drivers/infiniband/hw/mlx5/mem.c

40

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

drivers/infiniband/hw/mlx5/mem.c

45

rdma_umem_for_each_dma_block (umem, &biter, page_size) {

drivers/infiniband/hw/mlx5/mem.c

63

unsigned long page_size;

drivers/infiniband/hw/mlx5/mem.c

66

page_size = ib_umem_find_best_pgoff(umem, pgsz_bitmap, pgoff_bitmask);

drivers/infiniband/hw/mlx5/mem.c

67

if (!page_size)

drivers/infiniband/hw/mlx5/mem.c

77

page_offset = ib_umem_dma_offset(umem, page_size);

drivers/infiniband/hw/mlx5/mem.c

78

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

drivers/infiniband/hw/mlx5/mem.c

79

page_size /= 2;

drivers/infiniband/hw/mlx5/mem.c

80

page_offset = ib_umem_dma_offset(umem, page_size);

drivers/infiniband/hw/mlx5/mem.c

87

if (!(pgsz_bitmap & page_size))

drivers/infiniband/hw/mlx5/mem.c

91

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

drivers/infiniband/hw/mlx5/mem.c

94

return page_size;

drivers/infiniband/hw/mlx5/mlx5_ib.h

1442

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

drivers/infiniband/hw/mlx5/mr.c

1102

u64 page_size = 1ULL << page_shift;

drivers/infiniband/hw/mlx5/mr.c

1106

offset = addr & (page_size - 1);

drivers/infiniband/hw/mlx5/mr.c

1107

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

drivers/infiniband/hw/mlx5/mr.c

1149

unsigned long page_size;

drivers/infiniband/hw/mlx5/mr.c

1152

page_size = mlx5_umem_dmabuf_default_pgsz(umem, iova);

drivers/infiniband/hw/mlx5/mr.c

1154

page_size = mlx5_umem_mkc_find_best_pgsz(dev, umem, iova,

drivers/infiniband/hw/mlx5/mr.c

1156

if (WARN_ON(!page_size))

drivers/infiniband/hw/mlx5/mr.c

1160

rb_key.ndescs = ib_umem_num_dma_blocks(umem, page_size);

drivers/infiniband/hw/mlx5/mr.c

1172

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

drivers/infiniband/hw/mlx5/mr.c

1188

mr->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/mr.c

1257

unsigned long page_size, bool populate,

drivers/infiniband/hw/mlx5/mr.c

1272

if (!page_size)

drivers/infiniband/hw/mlx5/mr.c

1280

mr->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/mr.c

1285

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

drivers/infiniband/hw/mlx5/mr.c

1483

unsigned long page_size = mlx5_umem_mkc_find_best_pgsz(

drivers/infiniband/hw/mlx5/mr.c

1487

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

drivers/infiniband/hw/mlx5/mr.c

1812

unsigned long *page_size)

drivers/infiniband/hw/mlx5/mr.c

1822

*page_size = mlx5_umem_mkc_find_best_pgsz(

drivers/infiniband/hw/mlx5/mr.c

1824

if (WARN_ON(!*page_size))

drivers/infiniband/hw/mlx5/mr.c

1827

ib_umem_num_dma_blocks(new_umem, *page_size);

drivers/infiniband/hw/mlx5/mr.c

1832

u64 iova, unsigned long page_size)

drivers/infiniband/hw/mlx5/mr.c

1859

mr->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/mr.c

1944

unsigned long page_size;

drivers/infiniband/hw/mlx5/mr.c

1953

&page_size)) {

drivers/infiniband/hw/mlx5/mr.c

1955

new_umem, iova, page_size);

drivers/infiniband/hw/mlx5/mr.c

2812

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

drivers/infiniband/hw/mlx5/mr.c

2824

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

drivers/infiniband/hw/mlx5/mr.c

2838

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

drivers/infiniband/hw/mlx5/mr.c

60

unsigned long page_size, bool populate,

drivers/infiniband/hw/mlx5/odp.c

840

unsigned long page_size;

drivers/infiniband/hw/mlx5/odp.c

854

page_size = mlx5_umem_dmabuf_find_best_pgsz(umem_dmabuf, access_mode);

drivers/infiniband/hw/mlx5/odp.c

855

if (!page_size) {

drivers/infiniband/hw/mlx5/odp.c

859

page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/qp.c

1009

page_size = mlx5_umem_find_best_quantized_pgoff(

drivers/infiniband/hw/mlx5/qp.c

1013

if (!page_size) {

drivers/infiniband/hw/mlx5/qp.c

1017

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

drivers/infiniband/hw/mlx5/qp.c

1035

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

drivers/infiniband/hw/mlx5/qp.c

1037

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/qp.c

1348

unsigned long page_size;

drivers/infiniband/hw/mlx5/qp.c

1359

page_size = mlx5_umem_find_best_quantized_pgoff(

drivers/infiniband/hw/mlx5/qp.c

1362

if (!page_size) {

drivers/infiniband/hw/mlx5/qp.c

1369

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

drivers/infiniband/hw/mlx5/qp.c

1399

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/qp.c

1403

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

drivers/infiniband/hw/mlx5/qp.c

1441

unsigned long page_size = 0;

drivers/infiniband/hw/mlx5/qp.c

1450

page_size = mlx5_umem_find_best_quantized_pgoff(umem, wq, log_wq_pg_sz,

drivers/infiniband/hw/mlx5/qp.c

1454

if (!page_size)

drivers/infiniband/hw/mlx5/qp.c

1458

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

drivers/infiniband/hw/mlx5/qp.c

1486

order_base_2(page_size) - MLX5_ADAPTER_PAGE_SHIFT);

drivers/infiniband/hw/mlx5/qp.c

1490

mlx5_ib_populate_pas(umem, page_size, pas, 0);

drivers/infiniband/hw/mlx5/qp.c

886

unsigned long page_size = 0;

drivers/infiniband/hw/mlx5/qp.c

900

page_size = mlx5_umem_find_best_quantized_pgoff(

drivers/infiniband/hw/mlx5/qp.c

903

if (!page_size) {

drivers/infiniband/hw/mlx5/qp.c

909

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

drivers/infiniband/hw/mlx5/qp.c

910

rwq->page_shift = order_base_2(page_size);

drivers/infiniband/hw/mlx5/qp.c

918

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

drivers/infiniband/hw/mlx5/qp.c

951

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

2058

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

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

942

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

drivers/infiniband/hw/ocrdma/ocrdma_verbs.c

958

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

1553

u32 page_cnt, page_size;

drivers/infiniband/hw/qedr/verbs.c

1592

page_size = PAGE_SIZE;

drivers/infiniband/hw/qedr/verbs.c

1604

page_size = QED_CHAIN_PAGE_SIZE;

drivers/infiniband/hw/qedr/verbs.c

1611

in_params.page_size = page_size;

drivers/infiniband/hw/qedr/verbs.c

3467

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

369

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

169

*page_size = 0;

drivers/input/mouse/elan_i2c_core.c

178

*page_size = ETP_FW_PAGE_SIZE_512;

drivers/input/mouse/elan_i2c_core.c

181

*page_size = ETP_FW_PAGE_SIZE_128;

drivers/input/mouse/elan_i2c_core.c

183

*page_size = ETP_FW_PAGE_SIZE;

drivers/input/mouse/elan_i2c_core.c

461

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

drivers/input/mouse/elan_i2c_core.c

468

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

148

__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

1213

unsigned int page_size;

drivers/iommu/iommufd/selftest.c

1221

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

drivers/iommu/iommufd/selftest.c

1222

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

drivers/iommu/iommufd/selftest.c

1223

(uintptr_t)uptr % page_size ||

drivers/iommu/iommufd/selftest.c

1229

for (; length; length -= page_size) {

drivers/iommu/iommufd/selftest.c

1254

iova += page_size;

drivers/iommu/iommufd/selftest.c

1255

uptr += page_size;

drivers/iommu/iommufd/selftest.c

1716

unsigned long page_size, void __user *uptr,

drivers/iommu/iommufd/selftest.c

1726

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

drivers/iommu/iommufd/selftest.c

1739

max = length / page_size;

drivers/iommu/iommufd/selftest.c

1755

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

drivers/iommu/iommufd/selftest.c

2155

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

1597

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

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

1608

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

1559

offset = page * msb->page_size;

drivers/memstick/core/ms_block.c

1637

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

drivers/memstick/core/ms_block.c

1640

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

drivers/memstick/core/ms_block.c

1661

offset, msb->page_size);

drivers/memstick/core/ms_block.c

1663

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

drivers/memstick/core/ms_block.c

1664

msb->page_size);

drivers/memstick/core/ms_block.c

1722

msb->page_size = sizeof(struct ms_boot_page);

drivers/memstick/core/ms_block.c

1733

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

drivers/memstick/core/ms_block.c

1736

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

drivers/memstick/core/ms_block.c

1738

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

drivers/memstick/core/ms_block.c

1740

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

drivers/memstick/core/ms_block.c

1769

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

drivers/memstick/core/ms_block.c

1838

offset += msb->page_size;

drivers/memstick/core/ms_block.c

1839

*sucessfuly_written += msb->page_size;

drivers/memstick/core/ms_block.c

1863

offset += msb->page_size;

drivers/memstick/core/ms_block.c

1864

*sucessfuly_read += msb->page_size;

drivers/memstick/core/ms_block.c

1910

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

drivers/memstick/core/ms_block.c

2081

.logical_block_size = msb->page_size,

drivers/memstick/core/ms_block.c

2084

.max_segment_size = MS_BLOCK_MAX_PAGES * msb->page_size,

drivers/memstick/core/ms_block.c

2112

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

400

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

drivers/misc/eeprom/at24.c

600

u32 byte_len, page_size, flags, addrw;

drivers/misc/eeprom/at24.c

620

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

drivers/misc/eeprom/at24.c

627

page_size = 1;

drivers/misc/eeprom/at24.c

658

page_size = 1;

drivers/misc/eeprom/at24.c

660

if (!page_size)

drivers/misc/eeprom/at24.c

663

if (!is_power_of_2(page_size))

drivers/misc/eeprom/at24.c

694

at24->page_size = page_size;

drivers/misc/eeprom/at24.c

709

page_size, at24_io_limit);

drivers/misc/eeprom/at24.c

82

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

13

flags = SLB_VSID_KERNEL | mmu_psize_defs[page_size].sllp;

drivers/misc/lkdtm/powerpc.c

9

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

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

1102

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

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

1118

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

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

1119

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

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

1538

BF_BCH_FLASH0LAYOUT1_PAGE_SIZE(geo->page_size) |

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

1556

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

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

1592

int meta, n, page_size;

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

1648

page_size = meta + ecc_parity_size

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

1651

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

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

1663

this->bch_flashlayout1 = BF_BCH_FLASH0LAYOUT1_PAGE_SIZE(page_size) |

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

1670

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

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

1675

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

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

1707

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

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

233

geo->page_size,

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

400

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

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

521

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

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

565

geo->page_size,

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

621

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

2149

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

drivers/mtd/spi-nor/core.c

2153

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

drivers/mtd/spi-nor/core.c

2204

u32 page_size = nor->params->page_size;

drivers/mtd/spi-nor/core.c

2215

size_t page_offset = addr & (page_size - 1);

drivers/mtd/spi-nor/core.c

2217

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

drivers/mtd/spi-nor/core.c

3051

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

drivers/mtd/spi-nor/core.c

3143

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

drivers/mtd/spi-nor/core.c

3525

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

drivers/mtd/spi-nor/core.c

3759

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

drivers/mtd/spi-nor/core.c

3760

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

drivers/mtd/spi-nor/core.h

380

u32 page_size;

drivers/mtd/spi-nor/core.h

520

u16 page_size;

drivers/mtd/spi-nor/debugfs.c

91

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

783

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

1087

req->page_size = BNGE_PAGE_SHIFT;

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

239

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

459

rmem->page_size = HW_CMPD_RING_SIZE;

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

471

rmem->page_size = HW_RXBD_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

480

rmem->page_size = HW_RXBD_RING_SIZE;

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

491

rmem->page_size = HW_TXBD_RING_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

235

.page_size = BCM5709_FLASH_PAGE_SIZE,

drivers/net/ethernet/broadcom/bnx2.c

4239

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

drivers/net/ethernet/broadcom/bnx2.c

4241

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

drivers/net/ethernet/broadcom/bnx2.c

4285

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

drivers/net/ethernet/broadcom/bnx2.c

4287

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

drivers/net/ethernet/broadcom/bnx2.c

4570

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

drivers/net/ethernet/broadcom/bnx2.c

4572

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

drivers/net/ethernet/broadcom/bnx2.c

4592

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

drivers/net/ethernet/broadcom/bnx2.c

4593

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

16152

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

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

16177

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

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

3615

head_page = head / rmem->page_size;

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

3616

source_offset = head % rmem->page_size;

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

3621

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

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

3627

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

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

3649

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

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

3659

pg_tbl_size = rmem->page_size;

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

3682

pg_tbl_size = rmem->page_size;

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

3694

rmem->page_size,

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

3702

rmem->page_size);

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

4177

rmem->page_size = HW_CMPD_RING_SIZE;

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

4273

rmem->page_size = HW_RXBD_RING_SIZE;

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

4282

rmem->page_size = HW_RXBD_RING_SIZE;

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

4343

rmem->page_size = HW_CMPD_RING_SIZE;

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

4358

rmem->page_size = HW_RXBD_RING_SIZE;

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

4367

rmem->page_size = HW_RXBD_RING_SIZE;

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

4378

rmem->page_size = HW_TXBD_RING_SIZE;

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

7139

req->page_size = BNXT_PAGE_SHIFT;

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

7599

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

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

9022

rmem->page_size = BNXT_PAGE_SIZE;

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

9098

int page_size = rmem->page_size;

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

9102

tail %= nr_pages * page_size;

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

9105

int i = head / (page_size * MAX_CTX_PAGES);

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

9115

if (head >= nr_pages * page_size)

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

915

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

7272

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

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

7275

unsigned int page_shift = fls(page_size) - 1;

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

7399

t4_write_reg(adap, SGE_FL_BUFFER_SIZE0_A, page_size);

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

9260

unsigned int page_shift, page_size, qpp_shift, qpp_mask;

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

9271

page_size = 1 << page_shift;

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

9306

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/chelsio/inline_crypto/chtls/chtls_io.c

1117

pg_size = page_size(page);

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

1186

.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

459

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

401

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

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

508

u32 max_pages, min_page_size, page_size, total_size;

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

519

page_size = min_page_size;

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

521

page_size = total_size / max_pages;

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

523

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

224

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/netronome/nfp/nfpcore/nfp_resource.c

103

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

1286

if (cp->page_size == 0x1000)

drivers/net/ethernet/sun/cassini.c

1288

else if (cp->page_size == 0x2000)

drivers/net/ethernet/sun/cassini.c

1290

else if (cp->page_size == 0x4000)

drivers/net/ethernet/sun/cassini.c

1295

if (size > cp->page_size)

drivers/net/ethernet/sun/cassini.c

1296

size = cp->page_size;

drivers/net/ethernet/sun/cassini.c

1310

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

1968

hlen = min(cp->page_size - off, dlen);

drivers/net/ethernet/sun/cassini.c

2042

hlen = min(cp->page_size - off, dlen);

drivers/net/ethernet/sun/cassini.c

3369

cp->page_size = (PAGE_SIZE << cp->page_order);

drivers/net/ethernet/sun/cassini.c

446

dma_unmap_page(&cp->pdev->dev, page->dma_addr, cp->page_size,

drivers/net/ethernet/sun/cassini.c

478

cp->page_size, DMA_FROM_DEVICE);

drivers/net/ethernet/sun/cassini.h

2811

int page_size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1264

u32 page_size = fwrt->fw_paging_db[idx].fw_paging_size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1267

range->range_data_size = cpu_to_le32(page_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1268

dma_sync_single_for_cpu(fwrt->trans->dev, addr, page_size,

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1270

memcpy(range->data, page_address(page), page_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1271

dma_sync_single_for_device(fwrt->trans->dev, addr, page_size,

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1282

u32 page_size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1291

page_size = fwrt->trans->init_dram.paging[idx].size;

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1294

range->range_data_size = cpu_to_le32(page_size);

drivers/net/wireless/intel/iwlwifi/fw/dbg.c

1296

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

1310

static inline u8 rtw_len_to_page(unsigned int len, u16 page_size)

drivers/net/wireless/realtek/rtw88/fw.c

1312

return DIV_ROUND_UP(len, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1315

static void rtw_rsvd_page_list_to_buf(struct rtw_dev *rtwdev, u16 page_size,

drivers/net/wireless/realtek/rtw88/fw.c

1322

memcpy(buf + page_margin + page_size * (page - 1),

drivers/net/wireless/realtek/rtw88/fw.c

1543

pg_size = rtwdev->chip->page_size;

drivers/net/wireless/realtek/rtw88/fw.c

1628

u16 page_size, page_margin, tx_desc_sz;

drivers/net/wireless/realtek/rtw88/fw.c

1634

page_size = chip->page_size;

drivers/net/wireless/realtek/rtw88/fw.c

1636

page_margin = page_size - tx_desc_sz;

drivers/net/wireless/realtek/rtw88/fw.c

1676

page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1678

total_page += rtw_len_to_page(iter->len, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1687

*size = (total_page - 1) * page_size + page_margin;

drivers/net/wireless/realtek/rtw88/fw.c

1700

rtw_rsvd_page_list_to_buf(rtwdev, page_size, page_margin,

drivers/net/wireless/realtek/rtw88/fw.c

1704

tx_desc_sz, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

1706

page += rtw_len_to_page(rsvd_pkt->skb->len, page_size);

drivers/net/wireless/realtek/rtw88/fw.c

2038

u16 page_size = chip->page_size;

drivers/net/wireless/realtek/rtw88/fw.c

2040

u16 buf_offset = page_size * page_offset;

drivers/net/wireless/realtek/rtw88/fw.c

2052

buf = kzalloc(page_size * pages, GFP_KERNEL);

drivers/net/wireless/realtek/rtw88/fw.c

2060

if (skb->len > page_size * page_cnt) {

drivers/net/wireless/realtek/rtw88/fw.c

2070

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

1220

u16 page_size;

drivers/net/wireless/realtek/rtw88/rtw8703b.c

1898

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8723d.c

2136

.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

1158

.page_size = 256,

drivers/net/wireless/realtek/rtw88/rtw8821c.c

1993

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8822b.c

2536

.page_size = TX_PAGE_SIZE,

drivers/net/wireless/realtek/rtw88/rtw8822c.c

5354

.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

3410

u32 page_size = wd_ring->page_size;

drivers/net/wireless/realtek/rtw89/pci.c

3412

u32 ring_sz = page_size * page_num;

drivers/net/wireless/realtek/rtw89/pci.c

3532

u32 page_size = RTW89_PCI_TXWD_PAGE_SIZE;

drivers/net/wireless/realtek/rtw89/pci.c

3534

u32 ring_sz = page_size * page_num;

drivers/net/wireless/realtek/rtw89/pci.c

3549

wd_ring->page_size = page_size;

drivers/net/wireless/realtek/rtw89/pci.c

3562

txwd->len = page_size;

drivers/net/wireless/realtek/rtw89/pci.c

3566

page_offset += page_size;

drivers/net/wireless/realtek/rtw89/pci.h

1568

u32 page_size;

drivers/net/wireless/realtek/rtw89/pci.h

1714

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

1502

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

1057

epc->mem->window.page_size);

drivers/pci/controller/dwc/pcie-designware-ep.c

1359

ep->page_size);

drivers/pci/controller/dwc/pcie-designware-ep.c

1366

epc->mem->window.page_size);

drivers/pci/controller/dwc/pcie-designware-ep.c

629

*pci_size = ALIGN(ofst + *pci_size, epc->mem->window.page_size);

drivers/pci/controller/dwc/pcie-designware.h

488

size_t page_size;

drivers/pci/controller/dwc/pcie-dw-rockchip.c

608

rockchip->pci.ep.page_size = SZ_64K;

drivers/pci/controller/dwc/pcie-stm32-ep.c

218

ep->page_size = stm32_pcie_epc_features.align;

drivers/pci/controller/dwc/pcie-tegra194.c

2028

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

15852

dma_free_coherent(&queue->phba->pcidev->dev, queue->page_size,

drivers/scsi/lpfc/lpfc_sli.c

15881

lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t page_size,

drivers/scsi/lpfc/lpfc_sli.c

15890

hw_page_size = page_size;

drivers/scsi/lpfc/lpfc_sli.c

15919

queue->page_size = hw_page_size;

drivers/scsi/lpfc/lpfc_sli.c

16373

(cq->page_size / SLI4_PAGE_SIZE));

drivers/scsi/lpfc/lpfc_sli.c

16420

memset(dmabuf->virt, 0, cq->page_size);

drivers/scsi/lpfc/lpfc_sli.c

16538

hw_page_size = cq->page_size;

drivers/scsi/lpfc/lpfc_sli.c

16974

hw_page_size = wq->page_size;

drivers/scsi/lpfc/lpfc_sli.c

16996

(wq->page_size > SLI4_PAGE_SIZE))

drivers/scsi/lpfc/lpfc_sli.c

17025

(wq->page_size / SLI4_PAGE_SIZE));

drivers/scsi/lpfc/lpfc_sli4.h

1080

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

2748

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

1213

u32 page_size;

drivers/usb/cdns3/cdnsp-mem.c

1220

page_size = 1 << 12;

drivers/usb/cdns3/cdnsp-mem.c

1249

page_size);

drivers/usb/cdns3/cdnsp-mem.c

1254

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

1674

void *buf = dma_alloc_coherent(dev, xhci->page_size, &dma,

drivers/usb/host/xhci-mem.c

1687

dma_free_coherent(dev, xhci->page_size,

drivers/usb/host/xhci-mem.c

1718

dma_free_coherent(dev, xhci->page_size,

drivers/usb/host/xhci-mem.c

1995

xhci->page_size = 0;

drivers/usb/host/xhci-mem.c

2429

TRB_SEGMENT_SIZE * 2, TRB_SEGMENT_SIZE * 2, xhci->page_size * 2);

drivers/usb/host/xhci-mem.c

2432

TRB_SEGMENT_SIZE, TRB_SEGMENT_SIZE, xhci->page_size);

drivers/usb/host/xhci-mem.c

2438

xhci->page_size);

drivers/usb/host/xhci.c

466

u32 page_size;

drivers/usb/host/xhci.c

468

page_size = readl(&xhci->op_regs->page_size) & XHCI_PAGE_SIZE_MASK;

drivers/usb/host/xhci.c

469

if (!is_power_of_2(page_size)) {

drivers/usb/host/xhci.c

470

xhci_warn(xhci, "Invalid page size register = 0x%x\n", page_size);

drivers/usb/host/xhci.c

472

page_size = 1;

drivers/usb/host/xhci.c

475

xhci->page_size = page_size << 12;

drivers/usb/host/xhci.c

477

xhci->page_size >> 10);

drivers/usb/host/xhci.h

107

__le32 page_size;

drivers/usb/host/xhci.h

1525

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

180

ret = qm_read_regs(qm, QM_PAGE_SIZE, &vf_data->page_size, 1);

drivers/vfio/pci/hisilicon/hisi_acc_vfio_pci.c

254

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

1496

u64 *page_size)

drivers/vfio/pci/mlx5/cmd.c

1501

u8 log_tracked_page = ilog2(*page_size);

drivers/vfio/pci/mlx5/cmd.c

1590

*page_size = host_qp->tracked_page_size;

drivers/vfio/pci/mlx5/cmd.h

243

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

1095

if (!IS_ALIGNED(range.iova, control.page_size) ||

drivers/vfio/vfio_main.c

1096

!IS_ALIGNED(range.length, control.page_size)) {

drivers/vfio/vfio_main.c

1119

&control.page_size);

drivers/vfio/vfio_main.c

1185

if (report.page_size < SZ_4K || !is_power_of_2(report.page_size))

drivers/vfio/vfio_main.c

1193

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/ntfs3/fslog.c

1024

u32 page_size;

fs/ntfs3/fslog.c

1091

off = (off & ~log->sys_page_mask) + log->page_size;

fs/ntfs3/fslog.c

1130

log->page_size) +

fs/ntfs3/fslog.c

1150

u32 bytes = log->page_size - page_off;

fs/ntfs3/fslog.c

1161

to_free = kmalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

1170

log->page_size, NULL, &log->read_ahead);

fs/ntfs3/fslog.c

1317

log->sys_page_size = log->page_size;

fs/ntfs3/fslog.c

1320

log->clst_per_page = log->page_size >> log->ni->mi.sbi->cluster_bits;

fs/ntfs3/fslog.c

1324

log->first_page = major_ver >= 2 ? 0x22 * log->page_size :

fs/ntfs3/fslog.c

1325

4 * log->page_size;

fs/ntfs3/fslog.c

1358

sizeof(short) * ((log->page_size >> SECTOR_SHIFT) + 1),

fs/ntfs3/fslog.c

1360

log->data_size = log->page_size - log->data_off;

fs/ntfs3/fslog.c

1430

u32 tail = log->page_size - page_off;

fs/ntfs3/fslog.c

1546

log->next_page + log->page_size :

fs/ntfs3/fslog.c

1632

final_off = 0x02 * log->page_size;

fs/ntfs3/fslog.c

1633

second_off = 0x12 * log->page_size;

fs/ntfs3/fslog.c

1636

page_bufs = kmalloc(log->page_size * 0x10, GFP_NOFS);

fs/ntfs3/fslog.c

1640

second_off = log->first_page - log->page_size;

fs/ntfs3/fslog.c

1641

final_off = second_off - log->page_size;

fs/ntfs3/fslog.c

1727

memmove(page_bufs, best_page, log->page_size);

fs/ntfs3/fslog.c

1736

saved_off + log->page_size == this_off &&

fs/ntfs3/fslog.c

1743

saved_off += log->page_size;

fs/ntfs3/fslog.c

1746

memmove(Add2Ptr(page_bufs, tails * log->page_size), best_page,

fs/ntfs3/fslog.c

1747

log->page_size);

fs/ntfs3/fslog.c

1776

final_off += log->page_size;

fs/ntfs3/fslog.c

1777

second_off += log->page_size;

fs/ntfs3/fslog.c

1867

log->page_size -

fs/ntfs3/fslog.c

2005

log->page_size -

fs/ntfs3/fslog.c

2047

if (log->page_size -

fs/ntfs3/fslog.c

2179

tails -= (page_off1 - page_off) / log->page_size;

fs/ntfs3/fslog.c

2191

page = kmalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

2202

memcpy(page, tmp_page, log->page_size);

fs/ntfs3/fslog.c

2212

ntfs_fix_pre_write(&page->rhdr, log->page_size);

fs/ntfs3/fslog.c

2216

log->page_size, 0);

fs/ntfs3/fslog.c

2222

second_off += log->page_size;

fs/ntfs3/fslog.c

2226

tmp_page = Add2Ptr(tmp_page, log->page_size);

fs/ntfs3/fslog.c

2268

u32 tail = log->page_size - off;

fs/ntfs3/fslog.c

2441

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

3790

log->page_size = norm_file_page(PAGE_SIZE, &log->l_size, true);

fs/ntfs3/fslog.c

3792

log->page_size = norm_file_page(PAGE_SIZE, &log->l_size, false);

fs/ntfs3/fslog.c

3794

if (!log->page_size) {

fs/ntfs3/fslog.c

3799

log->one_page_buf = kmalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

3805

log->page_mask = log->page_size - 1;

fs/ntfs3/fslog.c

3806

log->page_bits = blksize_bits(log->page_size);

fs/ntfs3/fslog.c

3856

log->page_size != log->rst_info.vbo) {

fs/ntfs3/fslog.c

3860

if (!read_log_page(log, log->page_size, &sp, &usa_error) &&

fs/ntfs3/fslog.c

3930

if (log->page_size != t32) {

fs/ntfs3/fslog.c

3932

log->page_size = norm_file_page(t32, &log->l_size,

fs/ntfs3/fslog.c

3936

if (log->page_size != t32 ||

fs/ntfs3/fslog.c

3937

log->page_size != le32_to_cpu(log->rst_info.r_page->page_size)) {

fs/ntfs3/fslog.c

3942

log->page_mask = log->page_size - 1;

fs/ntfs3/fslog.c

3943

log->page_bits = blksize_bits(log->page_size);

fs/ntfs3/fslog.c

3965

log->data_size = log->page_size - log->data_off;

fs/ntfs3/fslog.c

3989

tail = log->page_size - (off & log->page_mask) - 1;

fs/ntfs3/fslog.c

4229

if (sbi->cluster_size <= log->page_size)

fs/ntfs3/fslog.c

431

u32 page_size = le32_to_cpu(rhdr->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

5145

rh = kzalloc(log->page_size, GFP_NOFS);

fs/ntfs3/fslog.c

5153

t16 = (log->page_size >> SECTOR_SHIFT) + 1;

fs/ntfs3/fslog.c

5155

rh->sys_page_size = cpu_to_le32(log->page_size);

fs/ntfs3/fslog.c

5156

rh->page_size = cpu_to_le32(log->page_size);

fs/ntfs3/fslog.c

5173

ntfs_fix_pre_write(&rh->rhdr, log->page_size);

fs/ntfs3/fslog.c

5175

err = ntfs_sb_write_run(sbi, &ni->file.run, 0, rh, log->page_size, 0);

fs/ntfs3/fslog.c

5177

err = ntfs_sb_write_run(sbi, &log->ni->file.run, log->page_size,

fs/ntfs3/fslog.c

5178

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

290

extern bool __tlb_remove_page_size(struct mmu_gather *tlb, struct page *page, int page_size);

include/asm-generic/tlb.h

389

unsigned int page_size;

include/asm-generic/tlb.h

510

struct page *page, int page_size)

include/asm-generic/tlb.h

512

if (__tlb_remove_page_size(tlb, page, page_size))

include/asm-generic/tlb.h

527

unsigned int page_size)

include/asm-generic/tlb.h

530

if (tlb->page_size && tlb->page_size != page_size) {

include/asm-generic/tlb.h

535

tlb->page_size = page_size;

include/hyperv/hvgdk_mini.h

553

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

177

return (unsigned long)(bh)->b_data & (page_size(bh->b_page) - 1);

include/linux/highmem.h

373

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

201

__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

130

size_t page_size;

include/linux/pci-epc.h

320

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

1896

unsigned int page_size;

include/rdma/ib_verbs.h

4639

unsigned int *sg_offset, unsigned int page_size);

include/rdma/ib_verbs.h

4643

unsigned int *meta_sg_offset, unsigned int page_size);

include/rdma/ib_verbs.h

4647

unsigned int *sg_offset, unsigned int page_size)

include/rdma/ib_verbs.h

4651

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

835

__aligned_u64 page_size;

include/uapi/linux/vfio.h

1398

__aligned_u64 page_size;

include/uapi/linux/vfio.h

1446

__aligned_u64 page_size;

include/uapi/rdma/ocrdma-abi.h

87

__u32 page_size;

io_uring/rsrc.c

664

imu->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

7868

int page_size;

kernel/trace/trace.c

7878

page_size = ring_buffer_subbuf_size_get(iter->array_buffer->buffer);

kernel/trace/trace.c

7882

if (page_size != info->spare_size) {

kernel/trace/trace.c

7897

info->spare_size = page_size;

kernel/trace/trace.c

7904

if (info->read < page_size)

kernel/trace/trace.c

7934

size = page_size - info->read;

kernel/trace/trace.c

8056

int page_size;

kernel/trace/trace.c

8063

page_size = ring_buffer_subbuf_size_get(iter->array_buffer->buffer);

kernel/trace/trace.c

8064

if (*ppos & (page_size - 1))

kernel/trace/trace.c

8067

if (len & (page_size - 1)) {

kernel/trace/trace.c

8068

if (len < page_size)

kernel/trace/trace.c

8070

len &= (~(page_size - 1));

kernel/trace/trace.c

8080

for (i = 0; i < spd.nr_pages_max && len && entries; i++, len -= page_size) {

kernel/trace/trace.c

8113

spd.partial[i].len = page_size;

kernel/trace/trace.c

8117

*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

1478

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

426

tlb->page_size = 0;

mm/slub.c

6344

return page_size(page);

mm/slub.c

6590

ks = page_size(page);

mm/usercopy.c

201

if (n > page_size(page) - offset)

mm/vmalloc.c

3373

unsigned long page_size;

mm/vmalloc.c

3375

page_size = PAGE_SIZE << page_order;

mm/vmalloc.c

3377

end = max(addr + page_size, end);

samples/vfio-mdev/mtty.c

1289

u32 nnodes, u64 *page_size)

tools/lib/bpf/libbpf.c

13664

munmap(cpu_buf->base, pb->mmap_size + pb->page_size))

tools/lib/bpf/libbpf.c

13722

cpu_buf->base = mmap(NULL, pb->mmap_size + pb->page_size,

tools/lib/bpf/libbpf.c

13855

pb->page_size = getpagesize();

tools/lib/bpf/libbpf.c

13856

pb->mmap_size = pb->page_size * page_cnt;

tools/lib/bpf/libbpf.c

14005

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

263

.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

1428

page_size = getpagesize();

tools/mm/slabinfo.c

372

return s->slabs * (page_size << s->order);

tools/mm/slabinfo.c

577

s->slabs * (page_size << s->order));

tools/mm/slabinfo.c

582

page_size << s->order, s->partial, onoff(s->poison),

tools/mm/slabinfo.c

583

s->slabs * (page_size << s->order) - s->objects * s->object_size);

tools/mm/slabinfo.c

589

((page_size << s->order) - s->objs_per_slab * s->slab_size) *

tools/mm/slabinfo.c

672

(s->slabs * (page_size << s->order)) : 100,

tools/mm/slabinfo.c

97

int page_size;

tools/perf/arch/arm/util/cs-etm.c

373

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm/util/cs-etm.c

376

KiB(128) / page_size;

tools/perf/arch/arm/util/cs-etm.c

378

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm/util/cs-etm.c

382

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm/util/cs-etm.c

391

opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/arm/util/cs-etm.c

402

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/arm/util/cs-etm.c

408

opts->auxtrace_mmap_pages * (size_t)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

426

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm/util/cs-etm.c

428

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/arm/util/cs-etm.c

430

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

209

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

211

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

213

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

216

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

224

opts->auxtrace_snapshot_size = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/arm64/util/arm-spe.c

233

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

315

if (opts->auxtrace_snapshot_size > opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/arm64/util/arm-spe.c

318

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/arm64/util/arm-spe.c

337

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

339

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

341

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/arm64/util/arm-spe.c

347

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

31

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/powerpc/util/auxtrace.c

33

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/tests/amd-ibs-period.c

154

base = (void *)rb + page_size;

tools/perf/arch/x86/tests/amd-ibs-period.c

21

static int page_size;

tools/perf/arch/x86/tests/amd-ibs-period.c

24

#define PERF_MMAP_DATA_SIZE (PERF_MMAP_DATA_PAGES * page_size)

tools/perf/arch/x86/tests/amd-ibs-period.c

27

#define PERF_MMAP_TOTAL_SIZE (PERF_MMAP_TOTAL_PAGES * page_size)

tools/perf/arch/x86/tests/amd-ibs-period.c

63

p = zalloc(2 * page_size);

tools/perf/arch/x86/tests/amd-ibs-period.c

69

func = (void *)((unsigned long)(p + page_size - 1) & ~(page_size - 1));

tools/perf/arch/x86/tests/amd-ibs-period.c

71

ret = mprotect(func, page_size, PROT_READ | PROT_WRITE | PROT_EXEC);

tools/perf/arch/x86/tests/amd-ibs-period.c

945

page_size = sysconf(_SC_PAGESIZE);

tools/perf/arch/x86/util/intel-bts.c

155

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-bts.c

157

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-bts.c

159

opts->mmap_pages = KiB(256) / 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->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-bts.c

171

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/x86/util/intel-bts.c

175

opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/x86/util/intel-bts.c

178

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/x86/util/intel-bts.c

192

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-bts.c

194

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-bts.c

196

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-bts.c

202

size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-pt.c

679

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-pt.c

681

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-pt.c

683

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

687

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

691

opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-pt.c

695

sz = round_up(sz, page_size) / page_size;

tools/perf/arch/x86/util/intel-pt.c

699

opts->auxtrace_mmap_pages * (size_t)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

726

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

728

size_t sz = round_up(max_sz, page_size) / page_size;

tools/perf/arch/x86/util/intel-pt.c

732

if (max_sz > opts->auxtrace_mmap_pages * (size_t)page_size) {

tools/perf/arch/x86/util/intel-pt.c

735

opts->auxtrace_mmap_pages * (size_t)page_size);

tools/perf/arch/x86/util/intel-pt.c

749

opts->auxtrace_mmap_pages = MiB(4) / page_size;

tools/perf/arch/x86/util/intel-pt.c

751

opts->auxtrace_mmap_pages = KiB(128) / page_size;

tools/perf/arch/x86/util/intel-pt.c

753

opts->mmap_pages = KiB(256) / page_size;

tools/perf/arch/x86/util/intel-pt.c

759

size_t sz = opts->auxtrace_mmap_pages * (size_t)page_size;

tools/perf/arch/x86/util/intel-pt.c

775

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

248

unsigned int page_size;

tools/perf/bench/mem-functions.c

277

page_size = (unsigned int)perf_atoll((char *)page_size_str);

tools/perf/bench/mem-functions.c

278

if (page_size != (1 << PAGE_SHIFT_4KB) &&

tools/perf/bench/mem-functions.c

279

page_size != (1 << PAGE_SHIFT_2MB) &&

tools/perf/bench/mem-functions.c

280

page_size != (1 << PAGE_SHIFT_1GB)) {

tools/perf/bench/mem-functions.c

284

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

315

if (llabs(skew) >= page_size)

tools/perf/util/auxtrace.c

1229

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

2553

size = round_up(start, page_size) + page_size - args->start;

tools/perf/util/bpf-event.c

717

.len = page_size,

tools/perf/util/copyfile.c

50

pgoff = off_in & ~(page_size - 1);

tools/perf/util/evlist.c

903

max -= (page_size / 1024);

tools/perf/util/evlist.c

906

pages = (max * 1024) / page_size;

tools/perf/util/evlist.c

920

return (pages + 1) * page_size;

tools/perf/util/evlist.c

941

pages = PERF_ALIGN(val, page_size) / page_size;

tools/perf/util/evlist.c

960

unit_number__scnprintf(buf, sizeof(buf), pages * page_size);

tools/perf/util/evlist.c

976

if (max > SIZE_MAX / page_size)

tools/perf/util/evlist.c

977

max = SIZE_MAX / page_size;

tools/perf/util/machine.c

1156

.end = va + page_size,

tools/perf/util/mmap.c

324

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

2183

if (event_size <= mmap_size - head % page_size) {

tools/perf/util/session.c

2335

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

1899

char *buf = malloc(page_size);

tools/perf/util/symbol-elf.c

1911

n = page_size;

tools/perf/util/symbol-elf.c

2055

.p_align = page_size,

tools/perf/util/symbol-elf.c

2269

u64 s = round_down(sdat->addr, page_size);

tools/perf/util/symbol-elf.c

2354

kci->stext = round_down(kci->stext, page_size);

tools/perf/util/symbol-elf.c

2356

kci->stext = round_down(kci->first_symbol, page_size);

tools/perf/util/symbol-elf.c

2359

kci->etext = round_up(kci->etext, page_size);

tools/perf/util/symbol-elf.c

2361

kci->etext = round_up(kci->last_symbol, page_size);

tools/perf/util/symbol-elf.c

2362

kci->etext += page_size;

tools/perf/util/symbol-elf.c

2369

kci->first_module = round_down(kci->first_module, page_size);

tools/perf/util/symbol-elf.c

2373

page_size);

tools/perf/util/symbol-elf.c

2374

kci->last_module_symbol += page_size;

tools/perf/util/symbol-elf.c

2420

buf_from = malloc(page_size);

tools/perf/util/symbol-elf.c

2421

buf_to = malloc(page_size);

tools/perf/util/symbol-elf.c

2427

ret = read(from, buf_from, page_size);

tools/perf/util/symbol-elf.c

2544

offset = round_up(offset, page_size);

tools/perf/util/symbol-elf.c

2596

off_t offset = page_size, sz;

tools/perf/util/synthetic-events.c

2405

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

231

skel->bss->page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

377

int page_size = getpagesize();

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

387

mem = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

399

value.udata = mem + page_size - offsetof(struct user_data, b);

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

405

value.udata = mem + page_size - sizeof(struct user_data);

tools/testing/selftests/bpf/prog_tests/task_local_storage.c

412

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

2380

u64 page_size, umem_size;

tools/testing/selftests/bpf/prog_tests/test_xsk.c

2390

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

2392

assert(umem_size % page_size > MIN_PKT_SIZE);

tools/testing/selftests/bpf/prog_tests/test_xsk.c

2393

assert(umem_size % 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

663

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

195

if (ctx->optlen != page_size * 2)

tools/testing/selftests/bpf/progs/sockopt_sk.c

209

if (optval_end - optval != page_size)

tools/testing/selftests/bpf/progs/sockopt_sk.c

235

if (ctx->optlen > 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

2085

unsigned long page_size;

tools/testing/selftests/iommu/iommufd.c

2150

self->page_size = MOCK_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2151

self->bitmap_size = variant->buffer_size / self->page_size;

tools/testing/selftests/iommu/iommufd.c

2296

uint32_t page_size = MOCK_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2301

page_size = MOCK_HUGE_PAGE_SIZE;

tools/testing/selftests/iommu/iommufd.c

2318

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2323

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2329

MOCK_APERTURE_START, self->page_size, 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

2361

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2368

MOCK_APERTURE_START, self->page_size, page_size,

tools/testing/selftests/iommu/iommufd.c

2376

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/page_fault_test.c

578

uint64_t guest_page_size = vm->page_size;

tools/testing/selftests/kvm/arm64/sea_to_user.c

262

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

205

mem = mmap(NULL, page_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

220

TEST_ASSERT_EQ(sb.st_blksize, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

231

page_size - 1, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

234

ret = fallocate(fd, FALLOC_FL_KEEP_SIZE, total_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

237

ret = fallocate(fd, FALLOC_FL_KEEP_SIZE, total_size + page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

241

total_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

245

total_size + page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

249

page_size, page_size - 1);

tools/testing/selftests/kvm/guest_memfd_test.c

253

page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

256

ret = fallocate(fd, FALLOC_FL_KEEP_SIZE, page_size, page_size);

tools/testing/selftests/kvm/guest_memfd_test.c

26

static size_t page_size;

tools/testing/selftests/kvm/guest_memfd_test.c

267

{0, page_size - 1},

tools/testing/selftests/kvm/guest_memfd_test.c

268

{0, page_size + 1},

tools/testing/selftests/kvm/guest_memfd_test.c

271

{1, page_size - 1},

tools/testing/selftests/kvm/guest_memfd_test.c

272

{1, page_size},

tools/testing/selftests/kvm/guest_memfd_test.c

273

{1, page_size + 1},

tools/testing/selftests/kvm/guest_memfd_test.c

275

{page_size, 1},

tools/testing/selftests/kvm/guest_memfd_test.c

276

{page_size, page_size - 1},

tools/testing/selftests/kvm/guest_memfd_test.c

277

{page_size, page_size + 1},

tools/testing/selftests/kvm/guest_memfd_test.c

296

for (size = 1; size < page_size; size++) {

tools/testing/selftests/kvm/guest_memfd_test.c

309

fd1 = __vm_create_guest_memfd(vm, page_size, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

314

TEST_ASSERT(st1.st_size == page_size, "memfd st_size should match requested size");

tools/testing/selftests/kvm/guest_memfd_test.c

316

fd2 = __vm_create_guest_memfd(vm, page_size * 2, 0);

tools/testing/selftests/kvm/guest_memfd_test.c

321

TEST_ASSERT(st2.st_size == page_size * 2, "second memfd st_size should match requested size");

tools/testing/selftests/kvm/guest_memfd_test.c

325

TEST_ASSERT(st1.st_size == page_size, "first memfd st_size should still match requested size");

tools/testing/selftests/kvm/guest_memfd_test.c

339

fd = __vm_create_guest_memfd(vm, page_size, flag);

tools/testing/selftests/kvm/guest_memfd_test.c

355

int fd = vm_create_guest_memfd(__vm, page_size * 4, __flags); \

tools/testing/selftests/kvm/guest_memfd_test.c

357

test_##__test(fd, page_size * 4); \

tools/testing/selftests/kvm/guest_memfd_test.c

449

size = vm->page_size;

tools/testing/selftests/kvm/guest_memfd_test.c

478

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

1286

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(uint64_t page_size);

tools/testing/selftests/kvm/kvm_page_table_test.c

241

uint64_t 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((vaddr % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/arm64/processor.c

133

" vaddr: 0x%lx vm->page_size: 0x%x", vaddr, vm->page_size);

tools/testing/selftests/kvm/lib/arm64/processor.c

137

TEST_ASSERT((paddr % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/arm64/processor.c

139

" paddr: 0x%lx vm->page_size: 0x%x", paddr, vm->page_size);

tools/testing/selftests/kvm/lib/arm64/processor.c

143

paddr, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/arm64/processor.c

237

return pte_addr(vm, *ptep) + (gva & (vm->page_size - 1));

tools/testing/selftests/kvm/lib/arm64/processor.c

423

stack_size = vm->page_size == 4096 ? DEFAULT_STACK_PGS * vm->page_size :

tools/testing/selftests/kvm/lib/arm64/processor.c

424

vm->page_size;

tools/testing/selftests/kvm/lib/arm64/processor.c

540

vm->page_size, MEM_REGION_DATA);

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

vm_vaddr_t mmio_gva = vm_vaddr_unused_gap(vm, vm->page_size, KVM_UTIL_MIN_VADDR);

tools/testing/selftests/kvm/lib/elf.c

160

vm_vaddr_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

1005

gpa, npages, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

1012

vm, gpa, (gpa + npages * vm->page_size) - 1);

tools/testing/selftests/kvm/lib/kvm_util.c

1018

gpa, npages, vm->page_size,

tools/testing/selftests/kvm/lib/kvm_util.c

1122

region->region.memory_size = npages * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1399

uint64_t pages = (sz + vm->page_size - 1) >> vm->page_shift;

tools/testing/selftests/kvm/lib/kvm_util.c

1402

uint64_t pgidx_start = (vaddr_min + vm->page_size - 1) >> vm->page_shift;

tools/testing/selftests/kvm/lib/kvm_util.c

1403

if ((pgidx_start * vm->page_size) < vaddr_min)

tools/testing/selftests/kvm/lib/kvm_util.c

1459

return pgidx_start * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1467

uint64_t pages = (sz >> vm->page_shift) + ((sz % vm->page_size) != 0);

tools/testing/selftests/kvm/lib/kvm_util.c

1471

KVM_UTIL_MIN_PFN * vm->page_size,

tools/testing/selftests/kvm/lib/kvm_util.c

1482

pages--, vaddr += vm->page_size, paddr += vm->page_size) {

tools/testing/selftests/kvm/lib/kvm_util.c

1590

size_t page_size = vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1591

size_t size = npages * page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1599

vaddr += page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1600

paddr += page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

1791

uint32_t page_size = getpagesize();

tools/testing/selftests/kvm/lib/kvm_util.c

1800

page_size * KVM_DIRTY_LOG_PAGE_OFFSET);

tools/testing/selftests/kvm/lib/kvm_util.c

1804

page_size * KVM_DIRTY_LOG_PAGE_OFFSET);

tools/testing/selftests/kvm/lib/kvm_util.c

1808

page_size * KVM_DIRTY_LOG_PAGE_OFFSET);

tools/testing/selftests/kvm/lib/kvm_util.c

1974

fprintf(stream, "%*spage_size: 0x%x\n", indent, "", vm->page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

2110

TEST_ASSERT((paddr_min % vm->page_size) == 0, "Min physical address "

tools/testing/selftests/kvm/lib/kvm_util.c

2113

paddr_min, vm->page_size);

tools/testing/selftests/kvm/lib/kvm_util.c

2132

paddr_min, vm->page_size, memslot);

tools/testing/selftests/kvm/lib/kvm_util.c

2144

return base * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

2217

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

uint64_t 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

987

size_t mem_size = npages * vm->page_size;

tools/testing/selftests/kvm/lib/kvm_util.c

996

TEST_ASSERT((gpa % vm->page_size) == 0, "Guest physical "

tools/testing/selftests/kvm/lib/kvm_util.c

999

gpa, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

115

return pte_addr(vm, *ptep) + (gva & (vm->page_size - 1));

tools/testing/selftests/kvm/lib/loongarch/processor.c

123

TEST_ASSERT((vaddr % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/loongarch/processor.c

125

"vaddr: 0x%lx vm->page_size: 0x%x", vaddr, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

129

TEST_ASSERT((paddr % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/loongarch/processor.c

131

"paddr: 0x%lx vm->page_size: 0x%x", paddr, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

135

paddr, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

212

memset(addr, 0, vm->page_size);

tools/testing/selftests/kvm/lib/loongarch/processor.c

344

val = __vm_vaddr_alloc(vm, vm->page_size,

tools/testing/selftests/kvm/lib/loongarch/processor.c

347

val = val + vm->page_size;

tools/testing/selftests/kvm/lib/loongarch/processor.c

367

stack_size = vm->page_size;

tools/testing/selftests/kvm/lib/loongarch/ucall.c

16

vm_vaddr_t mmio_gva = vm_vaddr_unused_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

143

return pte_addr(vm, *ptep) + (gva & (vm->page_size - 1));

tools/testing/selftests/kvm/lib/riscv/processor.c

323

stack_size = vm->page_size == 4096 ? DEFAULT_STACK_PGS * vm->page_size :

tools/testing/selftests/kvm/lib/riscv/processor.c

324

vm->page_size;

tools/testing/selftests/kvm/lib/riscv/processor.c

453

vm->page_size, MEM_REGION_DATA);

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((vaddr % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/riscv/processor.c

85

" vaddr: 0x%lx vm->page_size: 0x%x", vaddr, vm->page_size);

tools/testing/selftests/kvm/lib/riscv/processor.c

89

TEST_ASSERT((paddr % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/riscv/processor.c

91

" paddr: 0x%lx vm->page_size: 0x%x", paddr, vm->page_size);

tools/testing/selftests/kvm/lib/riscv/processor.c

95

paddr, vm->max_gfn, vm->page_size);

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

171

TEST_ASSERT(vm->page_size == PAGE_SIZE, "Unsupported page size: 0x%x",

tools/testing/selftests/kvm/lib/s390/processor.c

172

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, paddr), 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

63

TEST_ASSERT((gpa % vm->page_size) == 0,

tools/testing/selftests/kvm/lib/s390/processor.c

66

gva, vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

70

gva, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/s390/processor.c

94

TEST_ASSERT(vm->page_size == PAGE_SIZE, "Unsupported page size: 0x%x",

tools/testing/selftests/kvm/lib/s390/processor.c

95

vm->page_size);

tools/testing/selftests/kvm/lib/ucall_common.c

17

int ucall_nr_pages_required(uint64_t 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

278

paddr, vm->max_gfn, vm->page_size);

tools/testing/selftests/kvm/lib/x86/processor.c

502

size_t page_size = PG_LEVEL_SIZE(level);

tools/testing/selftests/kvm/lib/x86/processor.c

503

size_t npages = size / page_size;

tools/testing/selftests/kvm/lib/x86/processor.c

510

nested_paddr += page_size;

tools/testing/selftests/kvm/lib/x86/processor.c

511

paddr += page_size;

tools/testing/selftests/kvm/lib/x86/sev.c

32

const uint64_t size = (j - i + 1) * vm->page_size;

tools/testing/selftests/kvm/lib/x86/sev.c

33

const uint64_t offset = (i - lowest_page_in_region) * vm->page_size;

tools/testing/selftests/kvm/memslot_modification_stress_test.c

60

uint64_t 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

194

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

225

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

264

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

295

guest_page_size = vm_guest_mode_params[VM_MODE_DEFAULT].page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

299

TEST_ASSERT(data->vm->page_size == guest_page_size, "Invalid VM page size");

tools/testing/selftests/kvm/memslot_perf_test.c

354

sync->guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

451

uint32_t page_size = (typeof(page_size))READ_ONCE(sync->guest_page_size);

tools/testing/selftests/kvm/memslot_perf_test.c

462

ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

480

uint32_t page_size = (typeof(page_size))READ_ONCE(sync->guest_page_size);

tools/testing/selftests/kvm/memslot_perf_test.c

491

ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

499

ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

547

uint32_t page_size = (typeof(page_size))READ_ONCE(sync->guest_page_size);

tools/testing/selftests/kvm/memslot_perf_test.c

557

ptr < MEM_TEST_GPA + MEM_TEST_SIZE; ptr += page_size)

tools/testing/selftests/kvm/memslot_perf_test.c

563

for (ptr = MEM_TEST_GPA + page_size / 2;

tools/testing/selftests/kvm/memslot_perf_test.c

564

ptr < MEM_TEST_GPA + MEM_TEST_SIZE; ptr += page_size) {

tools/testing/selftests/kvm/memslot_perf_test.c

582

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

642

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

668

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

683

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

723

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

750

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

760

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

769

uint32_t guest_page_size = data->vm->page_size;

tools/testing/selftests/kvm/memslot_perf_test.c

928

uint32_t 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

~((uint64_t)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/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

105

map = mmap(NULL, page_size, PROT_READ, MAP_SHARED, mfd, 0);

tools/testing/selftests/liveupdate/luo_test_utils.c

118

munmap(map, page_size);

tools/testing/selftests/liveupdate/luo_test_utils.c

60

long page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/liveupdate/luo_test_utils.c

68

if (ftruncate(mfd, page_size) != 0)

tools/testing/selftests/liveupdate/luo_test_utils.c

71

map = mmap(NULL, page_size, PROT_WRITE, MAP_SHARED, mfd, 0);

tools/testing/selftests/liveupdate/luo_test_utils.c

75

snprintf(map, page_size, "%s", data);

tools/testing/selftests/liveupdate/luo_test_utils.c

76

munmap(map, page_size);

tools/testing/selftests/liveupdate/luo_test_utils.c

96

long page_size = sysconf(_SC_PAGE_SIZE);

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

210

size_t page_size, i;

tools/testing/selftests/mm/compaction_test.c

233

page_size = getpagesize();

tools/testing/selftests/mm/compaction_test.c

258

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

tools/testing/selftests/mm/droppable.c

21

size_t page_size = getpagesize();

tools/testing/selftests/mm/droppable.c

31

for (size_t i = 0; i < alloc_size; i += page_size)

tools/testing/selftests/mm/droppable.c

38

*(char *)malloc(page_size) = 'B';

tools/testing/selftests/mm/droppable.c

42

for (size_t i = 0; i < alloc_size; i += page_size) {

tools/testing/selftests/mm/guard-regions.c

1000

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1006

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1017

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1021

ptr = mmap_(self, variant, NULL, 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

1026

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1027

ASSERT_EQ(madvise(&ptr[4 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1031

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1036

ptr_new = mmap_(self, variant, NULL, 5 * page_size, PROT_NONE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1039

ASSERT_EQ(mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

1044

ASSERT_FALSE(try_read_write_buf(&ptr_new[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1050

munmap(ptr_new, 5 * page_size);

tools/testing/selftests/mm/guard-regions.c

1063

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1067

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1071

ASSERT_EQ(munmap(&ptr[5 * page_size], 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1074

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1075

ASSERT_EQ(madvise(&ptr[4 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1079

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1082

ptr = mremap(ptr, 5 * page_size, 10 * page_size, 0);

tools/testing/selftests/mm/guard-regions.c

1089

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1092

ptr_new = mmap_(self, variant, NULL, 20 * page_size, PROT_NONE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1096

ptr = mremap(ptr, 10 * page_size, 20 * page_size,

tools/testing/selftests/mm/guard-regions.c

1104

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1113

munmap(ptr, 20 * page_size);

tools/testing/selftests/mm/guard-regions.c

1125

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1130

ptr = mmap_(self, variant, NULL, 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

1135

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1136

ASSERT_EQ(madvise(&ptr[4 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1140

ASSERT_FALSE(try_read_write_buf(&ptr[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

1143

ptr = mremap(ptr, 5 * page_size, 3 * page_size, MREMAP_MAYMOVE);

tools/testing/selftests/mm/guard-regions.c

1151

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1166

ptr = mremap(ptr, 3 * page_size, 5 * page_size, 0);

tools/testing/selftests/mm/guard-regions.c

1174

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1180

munmap(ptr, 5 * page_size);

tools/testing/selftests/mm/guard-regions.c

1189

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1195

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1200

ASSERT_EQ(madvise(ptr, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1209

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1216

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1228

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1235

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1244

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1253

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1258

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1270

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1278

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1280

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1286

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1301

for (i = 0; i < 10 * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

1309

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1318

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1327

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1332

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_WIPEONFORK), 0);

tools/testing/selftests/mm/guard-regions.c

1335

ASSERT_EQ(madvise(ptr, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1344

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1358

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1365

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1371

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1379

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1384

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1388

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1394

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_FREE), 0);

tools/testing/selftests/mm/guard-regions.c

1398

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1404

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1410

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1414

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1419

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1422

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_POPULATE_READ), -1);

tools/testing/selftests/mm/guard-regions.c

1426

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_POPULATE_WRITE), -1);

tools/testing/selftests/mm/guard-regions.c

1430

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1436

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1441

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1446

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1450

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1456

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_COLD), 0);

tools/testing/selftests/mm/guard-regions.c

1460

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1466

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_PAGEOUT), 0);

tools/testing/selftests/mm/guard-regions.c

1470

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1476

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1482

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1518

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1524

range.len = 10 * page_size;

tools/testing/selftests/mm/guard-regions.c

1530

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1534

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1542

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1557

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1562

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1567

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1568

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1571

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_SEQUENTIAL), 0);

tools/testing/selftests/mm/guard-regions.c

1575

char *ptr2 = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1577

ASSERT_EQ(madvise(ptr2, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1581

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_PAGEOUT), 0);

tools/testing/selftests/mm/guard-regions.c

1585

char *chrp = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1597

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1600

if (!check_pattern(ptr, 10, page_size))

tools/testing/selftests/mm/guard-regions.c

1603

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1612

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1619

ptr_shared = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1623

ptr_private = mmap(NULL, 10 * page_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, self->fd, 0);

tools/testing/selftests/mm/guard-regions.c

1627

set_pattern(ptr_shared, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1631

char *ptr = &ptr_shared[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1633

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1638

ASSERT_EQ(try_read_buf(&ptr_shared[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1640

ASSERT_TRUE(try_read_buf(&ptr_private[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1645

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1647

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1652

ASSERT_EQ(try_read_buf(&ptr_shared[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1654

ASSERT_EQ(try_read_buf(&ptr_private[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1658

ASSERT_EQ(madvise(ptr_shared, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1662

ASSERT_TRUE(try_read_buf(&ptr_shared[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1664

ASSERT_EQ(try_read_buf(&ptr_private[i * page_size]), i % 2 != 0);

tools/testing/selftests/mm/guard-regions.c

1668

ASSERT_EQ(madvise(ptr_private, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1672

ASSERT_TRUE(try_read_buf(&ptr_shared[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1674

ASSERT_TRUE(try_read_buf(&ptr_private[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1678

ASSERT_TRUE(check_pattern(ptr_shared, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1679

ASSERT_TRUE(check_pattern(ptr_private, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1683

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1685

memset(ptr, 'a' + i, page_size);

tools/testing/selftests/mm/guard-regions.c

1698

ASSERT_EQ(madvise(ptr_private, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1708

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1713

ASSERT_TRUE(try_read_buf(&ptr_shared[i * page_size]));

tools/testing/selftests/mm/guard-regions.c

1717

ASSERT_EQ(madvise(ptr_private, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1731

char *ptr = &ptr_private[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1738

char *ptr_s = &ptr_shared[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1740

ASSERT_EQ(memcmp(ptr, ptr_s, page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1745

ASSERT_TRUE(is_buf_eq(ptr, page_size, 'a' + i));

tools/testing/selftests/mm/guard-regions.c

1748

ASSERT_EQ(munmap(ptr_shared, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1749

ASSERT_EQ(munmap(ptr_private, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1755

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1763

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1766

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1767

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1775

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1780

char *ptr_pg = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1782

ASSERT_EQ(madvise(ptr_pg, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1787

char *ptr_pg = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1793

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1796

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

1798

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1803

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1810

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1815

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1821

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_PAGEOUT), 0);

tools/testing/selftests/mm/guard-regions.c

1824

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1825

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1831

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1833

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1838

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1845

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1850

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1855

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1862

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1870

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1874

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1876

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

1881

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1887

ASSERT_EQ(ftruncate(self->fd, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1891

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1897

ASSERT_EQ(ftruncate(self->fd, 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1898

ASSERT_EQ(ftruncate(self->fd, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1902

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1907

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1912

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1920

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

1923

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1926

ASSERT_EQ(madvise(&ptr[3 * page_size], 4 * page_size,

tools/testing/selftests/mm/guard-regions.c

1940

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1946

ASSERT_EQ(madvise(&ptr[3 * page_size], 4 * page_size,

tools/testing/selftests/mm/guard-regions.c

1951

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

1957

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

1960

ASSERT_TRUE(check_pattern(ptr, 3, page_size));

tools/testing/selftests/mm/guard-regions.c

1962

ASSERT_TRUE(is_buf_eq(&ptr[3 * page_size], 4 * page_size, '\0'));

tools/testing/selftests/mm/guard-regions.c

1964

ASSERT_TRUE(check_pattern_offset(ptr, 3, page_size, 7));

tools/testing/selftests/mm/guard-regions.c

1966

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1976

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

1990

ASSERT_EQ(ftruncate(self->fd, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

1993

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

1995

set_pattern(ptr, 10, page_size);

tools/testing/selftests/mm/guard-regions.c

1996

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2002

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ, 0, 0);

tools/testing/selftests/mm/guard-regions.c

2006

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

2010

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2012

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2017

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2023

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

2026

ASSERT_TRUE(check_pattern(ptr, 10, page_size));

tools/testing/selftests/mm/guard-regions.c

2030

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2035

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2047

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2055

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ, 0, 0);

tools/testing/selftests/mm/guard-regions.c

2060

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2062

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2067

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2073

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

2077

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2083

ASSERT_TRUE(is_buf_eq(ptr, 10 * page_size, '\0'));

tools/testing/selftests/mm/guard-regions.c

2085

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2093

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2101

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

2107

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2116

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2118

ASSERT_EQ(madvise(ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2123

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

213

static void set_pattern(char *ptr, size_t num_pages, size_t page_size)

tools/testing/selftests/mm/guard-regions.c

2131

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2139

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2154

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

2159

pm_scan_args.end = (long)ptr + 10 * page_size;

tools/testing/selftests/mm/guard-regions.c

2161

ASSERT_EQ(pm_scan_args.walk_end, (long)ptr + 10 * page_size);

tools/testing/selftests/mm/guard-regions.c

2165

char *ptr_p = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2167

ASSERT_EQ(syscall(__NR_madvise, ptr_p, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2175

ASSERT_EQ(pm_scan_args.walk_end, (long)ptr + 10 * page_size);

tools/testing/selftests/mm/guard-regions.c

2179

long ptr_p = (long)&ptr[2 * i * page_size];

tools/testing/selftests/mm/guard-regions.c

218

char *ptr2 = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2182

ASSERT_EQ(pm_regs[i].end, ptr_p + page_size);

tools/testing/selftests/mm/guard-regions.c

2187

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2192

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2194

const unsigned long num_pages = size / page_size;

tools/testing/selftests/mm/guard-regions.c

220

memset(ptr2, 'a' + (i % 26), page_size);

tools/testing/selftests/mm/guard-regions.c

2223

char *ptr_page = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2225

ASSERT_EQ(madvise(ptr_page, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2248

char *ptr_page = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

2257

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

2263

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

2270

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

228

static bool check_pattern_offset(char *ptr, size_t num_pages, size_t page_size,

tools/testing/selftests/mm/guard-regions.c

2280

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

2285

ASSERT_EQ(madvise(&ptr[i * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

2291

ASSERT_EQ(munmap(&ptr[4 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

2295

ASSERT_TRUE(check_vmflag_guard(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

2308

ptr2 = mmap_(self, variant, &ptr[4 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

2309

PROT_READ | PROT_WRITE, MAP_FIXED, 4 * page_size);

tools/testing/selftests/mm/guard-regions.c

2320

ASSERT_EQ(procmap.query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/guard-regions.c

233

for (i = 0; i < num_pages * page_size; i++) {

tools/testing/selftests/mm/guard-regions.c

234

size_t offset = pgoff * page_size + i;

tools/testing/selftests/mm/guard-regions.c

236

char expected = 'a' + ((offset / page_size) % 26);

tools/testing/selftests/mm/guard-regions.c

246

static bool check_pattern(char *ptr, size_t num_pages, size_t page_size)

tools/testing/selftests/mm/guard-regions.c

248

return check_pattern_offset(ptr, num_pages, page_size, 0);

tools/testing/selftests/mm/guard-regions.c

277

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

285

ptr = mmap_(self, variant, NULL, 10 * page_size, PROT_READ | PROT_WRITE, 0, 0);

tools/testing/selftests/mm/guard-regions.c

289

munmap(&ptr[5 * page_size], page_size);

tools/testing/selftests/mm/guard-regions.c

292

ptr2 = mmap_(self, variant, &ptr[5 * page_size], page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/guard-regions.c

293

MAP_FIXED, 5 * page_size);

tools/testing/selftests/mm/guard-regions.c

305

if (procmap.query.vma_end != (unsigned long)ptr + 10 * page_size)

tools/testing/selftests/mm/guard-regions.c

314

self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/guard-regions.c

329

ASSERT_EQ(ftruncate(self->fd, 100 * self->page_size), 0);

tools/testing/selftests/mm/guard-regions.c

349

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

353

ptr = mmap_(self, variant, NULL, NUM_PAGES * page_size,

tools/testing/selftests/mm/guard-regions.c

360

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

367

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

373

ASSERT_EQ(madvise(&ptr[(NUM_PAGES - 1) * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

378

ASSERT_FALSE(try_read_write_buf(&ptr[(NUM_PAGES - 1) * page_size]));

tools/testing/selftests/mm/guard-regions.c

381

ASSERT_FALSE(madvise(ptr, page_size, MADV_GUARD_REMOVE));

tools/testing/selftests/mm/guard-regions.c

387

ASSERT_FALSE(madvise(&ptr[(NUM_PAGES - 1) * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

391

ASSERT_TRUE(try_read_write_buf(&ptr[(NUM_PAGES - 1) * page_size]));

tools/testing/selftests/mm/guard-regions.c

398

ASSERT_EQ(madvise(ptr, 3 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

402

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

409

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

415

ASSERT_EQ(madvise(ptr, NUM_PAGES * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

419

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

428

ASSERT_EQ(madvise(ptr, NUM_PAGES * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

430

for (i = 0; i < NUM_PAGES * page_size; i += page_size) {

tools/testing/selftests/mm/guard-regions.c

436

ASSERT_EQ(munmap(ptr, NUM_PAGES * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

442

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

447

ptr_region = mmap_(self, variant, NULL, 100 * page_size,

tools/testing/selftests/mm/guard-regions.c

452

ptr1 = mmap_(self, variant, ptr_region, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

457

ptr2 = mmap_(self, variant, &ptr_region[50 * page_size], 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

462

ptr3 = mmap_(self, variant, &ptr_region[80 * page_size], 20 * page_size,

tools/testing/selftests/mm/guard-regions.c

467

ASSERT_EQ(munmap(&ptr_region[10 * page_size], 40 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

468

ASSERT_EQ(munmap(&ptr_region[55 * page_size], 25 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

488

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_INSTALL), -1);

tools/testing/selftests/mm/guard-regions.c

49

unsigned long page_size;

tools/testing/selftests/mm/guard-regions.c

492

char *curr = &ptr1[i * page_size];

tools/testing/selftests/mm/guard-regions.c

498

char *curr = &ptr2[i * page_size];

tools/testing/selftests/mm/guard-regions.c

504

char *curr = &ptr3[i * page_size];

tools/testing/selftests/mm/guard-regions.c

511

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_REMOVE), -1);

tools/testing/selftests/mm/guard-regions.c

515

char *curr = &ptr1[i * page_size];

tools/testing/selftests/mm/guard-regions.c

521

char *curr = &ptr2[i * page_size];

tools/testing/selftests/mm/guard-regions.c

527

char *curr = &ptr3[i * page_size];

tools/testing/selftests/mm/guard-regions.c

533

ptr = mmap_(self, variant, &ptr_region[10 * page_size], 40 * page_size,

tools/testing/selftests/mm/guard-regions.c

536

ptr = mmap_(self, variant, &ptr_region[55 * page_size], 25 * page_size,

tools/testing/selftests/mm/guard-regions.c

551

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

553

char *curr = &ptr_region[i * page_size];

tools/testing/selftests/mm/guard-regions.c

557

ASSERT_EQ(madvise(ptr_region, 100 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

559

char *curr = &ptr_region[i * page_size];

tools/testing/selftests/mm/guard-regions.c

565

ASSERT_EQ(munmap(ptr_region, 100 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

574

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

580

ptr_region = mmap_(self, variant, NULL, 100 * page_size,

tools/testing/selftests/mm/guard-regions.c

589

ptr1 = mmap_(self, variant, &ptr_region[page_size], 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

594

vec[0].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

595

vec[1].iov_base = &ptr1[9 * page_size];

tools/testing/selftests/mm/guard-regions.c

596

vec[1].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

599

ptr2 = mmap_(self, variant, &ptr_region[50 * page_size], 5 * page_size,

tools/testing/selftests/mm/guard-regions.c

603

vec[2].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

604

vec[3].iov_base = &ptr2[4 * page_size];

tools/testing/selftests/mm/guard-regions.c

605

vec[3].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

608

ptr3 = mmap_(self, variant, &ptr_region[79 * page_size], 20 * page_size,

tools/testing/selftests/mm/guard-regions.c

612

vec[4].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

613

vec[5].iov_base = &ptr3[19 * page_size];

tools/testing/selftests/mm/guard-regions.c

614

vec[5].iov_len = page_size;

tools/testing/selftests/mm/guard-regions.c

617

ASSERT_EQ(munmap(ptr_region, page_size), 0);

tools/testing/selftests/mm/guard-regions.c

618

ASSERT_EQ(munmap(&ptr_region[11 * page_size], 39 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

619

ASSERT_EQ(munmap(&ptr_region[55 * page_size], 24 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

620

ASSERT_EQ(munmap(&ptr_region[99 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

630

ASSERT_EQ(count, 6 * page_size);

tools/testing/selftests/mm/guard-regions.c

635

ASSERT_FALSE(try_read_write_buf(&ptr1[9 * page_size]));

tools/testing/selftests/mm/guard-regions.c

638

ASSERT_FALSE(try_read_write_buf(&ptr2[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

641

ASSERT_FALSE(try_read_write_buf(&ptr3[19 * page_size]));

tools/testing/selftests/mm/guard-regions.c

649

ASSERT_TRUE(try_read_write_buf(&ptr1[9 * page_size]));

tools/testing/selftests/mm/guard-regions.c

652

ASSERT_TRUE(try_read_write_buf(&ptr2[4 * page_size]));

tools/testing/selftests/mm/guard-regions.c

655

ASSERT_TRUE(try_read_write_buf(&ptr3[19 * page_size]));

tools/testing/selftests/mm/guard-regions.c

658

ASSERT_EQ(munmap(ptr1, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

659

ASSERT_EQ(munmap(ptr2, 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

660

ASSERT_EQ(munmap(ptr3, 20 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

666

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

669

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

674

ASSERT_EQ(madvise(ptr, page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

675

ASSERT_EQ(madvise(&ptr[9 * page_size], page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

679

ASSERT_FALSE(try_read_write_buf(&ptr[9 * page_size]));

tools/testing/selftests/mm/guard-regions.c

682

ASSERT_EQ(munmap(ptr, page_size), 0);

tools/testing/selftests/mm/guard-regions.c

683

ASSERT_EQ(munmap(&ptr[9 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

686

ptr_new1 = mmap_(self, variant, ptr, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/guard-regions.c

689

ptr_new2 = mmap_(self, variant, &ptr[9 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

698

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

704

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

708

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

713

ASSERT_EQ(madvise(&ptr[5 * page_size], 2 * page_size,

tools/testing/selftests/mm/guard-regions.c

717

ASSERT_FALSE(try_read_write_buf(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

718

ASSERT_FALSE(try_read_write_buf(&ptr[6 * page_size]));

tools/testing/selftests/mm/guard-regions.c

721

ASSERT_EQ(mprotect(&ptr[5 * page_size], 2 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

724

ASSERT_FALSE(try_read_buf(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

725

ASSERT_FALSE(try_read_buf(&ptr[6 * page_size]));

tools/testing/selftests/mm/guard-regions.c

728

ASSERT_EQ(madvise(&ptr[5 * page_size], 2 * page_size,

tools/testing/selftests/mm/guard-regions.c

732

ASSERT_FALSE(try_read_buf(&ptr[5 * page_size]));

tools/testing/selftests/mm/guard-regions.c

733

ASSERT_FALSE(try_read_buf(&ptr[6 * page_size]));

tools/testing/selftests/mm/guard-regions.c

736

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

740

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

746

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

752

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

756

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

761

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

765

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

771

ASSERT_EQ(munmap(&ptr[2 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

772

ASSERT_EQ(munmap(&ptr[5 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

773

ASSERT_EQ(munmap(&ptr[8 * page_size], page_size), 0);

tools/testing/selftests/mm/guard-regions.c

777

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

782

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

787

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

792

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

798

ptr_new = mmap_(self, variant, &ptr[2 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

801

ptr_new = mmap_(self, variant, &ptr[5 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

804

ptr_new = mmap_(self, variant, &ptr[8 * page_size], page_size,

tools/testing/selftests/mm/guard-regions.c

810

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

818

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

822

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

828

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

829

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

833

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

839

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ | PROT_WRITE), 0);

tools/testing/selftests/mm/guard-regions.c

840

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size,

tools/testing/selftests/mm/guard-regions.c

845

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

851

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

852

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/guard-regions.c

855

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/guard-regions.c

859

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

865

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ | PROT_WRITE), 0);

tools/testing/selftests/mm/guard-regions.c

866

ASSERT_EQ(mprotect(&ptr[7 * page_size], 3 * page_size,

tools/testing/selftests/mm/guard-regions.c

871

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

877

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

883

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

887

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

893

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

900

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

901

int res = madvise(curr, page_size, MADV_GUARD_INSTALL);

tools/testing/selftests/mm/guard-regions.c

907

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_DONTNEED), 0);

tools/testing/selftests/mm/guard-regions.c

911

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

931

result = try_write_buf(&ptr[i * page_size]);

tools/testing/selftests/mm/guard-regions.c

938

ASSERT_EQ(munmap(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

944

const unsigned long page_size = self->page_size;

tools/testing/selftests/mm/guard-regions.c

948

ptr = mmap_(self, variant, NULL, 10 * page_size,

tools/testing/selftests/mm/guard-regions.c

954

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

960

ASSERT_EQ(mlock(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

963

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_INSTALL), -1);

tools/testing/selftests/mm/guard-regions.c

967

ASSERT_EQ(munlock(ptr, 10 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

970

ASSERT_EQ(madvise(ptr, 5 * page_size, MADV_GUARD_INSTALL), 0);

tools/testing/selftests/mm/guard-regions.c

974

char *curr = &ptr[i * page_size];

tools/testing/selftests/mm/guard-regions.c

990

ASSERT_EQ(mlock(&ptr[5 * page_size], 5 * page_size), 0);

tools/testing/selftests/mm/guard-regions.c

996

ASSERT_EQ(madvise(ptr, 10 * page_size, MADV_GUARD_REMOVE), 0);

tools/testing/selftests/mm/hmm-tests.c

1003

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1051

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1107

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1157

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1219

ret = munmap(buffer->ptr + self->page_size, self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1227

ret = mprotect(buffer->ptr + 2 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1230

ptr = (int *)(buffer->ptr + 2 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1235

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1238

ptr = (int *)(buffer->ptr + 3 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1240

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1245

ret = mprotect(buffer->ptr + 4 * self->page_size, 2 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1248

ptr = (int *)(buffer->ptr + 4 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1250

ptr = (int *)(buffer->ptr + 5 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1254

buffer->ptr = p + 2 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

1260

buffer->ptr = p + 5 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

1287

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1346

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

139

self->page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/hmm-tests.c

140

self->page_shift = ffs(self->page_size) - 1;

tools/testing/selftests/mm/hmm-tests.c

1406

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

150

self->page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/hmm-tests.c

151

self->page_shift = ffs(self->page_size) - 1;

tools/testing/selftests/mm/hmm-tests.c

1533

ret = munmap(buffer->ptr + self->page_size, self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1537

ret = mprotect(buffer->ptr + 2 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1540

ptr = (int *)(buffer->ptr + 2 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1545

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1548

ptr = (int *)(buffer->ptr + 3 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1550

ret = mprotect(buffer->ptr + 3 * self->page_size, self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1555

ret = mprotect(buffer->ptr + 4 * self->page_size, 3 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1558

ptr = (int *)(buffer->ptr + 4 * self->page_size);

tools/testing/selftests/mm/hmm-tests.c

1562

buffer->ptr = p + 5 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

1568

buffer->ptr = p + 6 * self->page_size;

tools/testing/selftests/mm/hmm-tests.c

1763

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1817

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1870

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

1980

GUP_BASIC_TEST, 1, self->page_size, 0), 0);

tools/testing/selftests/mm/hmm-tests.c

1982

(unsigned long)buffer->ptr + 1 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1983

GUP_FAST_BENCHMARK, 1, self->page_size, 0), 0);

tools/testing/selftests/mm/hmm-tests.c

1985

(unsigned long)buffer->ptr + 2 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1986

PIN_FAST_BENCHMARK, 1, self->page_size, FOLL_LONGTERM), 0);

tools/testing/selftests/mm/hmm-tests.c

1988

(unsigned long)buffer->ptr + 3 * self->page_size,

tools/testing/selftests/mm/hmm-tests.c

1989

PIN_LONGTERM_BENCHMARK, 1, self->page_size, 0), 0);

tools/testing/selftests/mm/hmm-tests.c

307

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

329

i = 2 * self->page_size / sizeof(*ptr);

tools/testing/selftests/mm/hmm-tests.c

338

val = *(int *)(buffer->ptr + self->page_size);

tools/testing/selftests/mm/hmm-tests.c

349

for (i = 0; i < 2 * self->page_size / sizeof(*ptr); ++i)

tools/testing/selftests/mm/hmm-tests.c

370

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

429

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

477

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

552

self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

654

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

74

unsigned int page_size;

tools/testing/selftests/mm/hmm-tests.c

892

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

947

npages = ALIGN(HMM_BUFFER_SIZE, self->page_size) >> self->page_shift;

tools/testing/selftests/mm/hmm-tests.c

97

unsigned int page_size;

tools/testing/selftests/mm/khugepaged.c

1012

page_size);

tools/testing/selftests/mm/khugepaged.c

1200

page_size = getpagesize();

tools/testing/selftests/mm/khugepaged.c

1206

hpage_pmd_nr = hpage_pmd_size / page_size;

tools/testing/selftests/mm/khugepaged.c

276

for (i = start / page_size; i < end / page_size; i++)

tools/testing/selftests/mm/khugepaged.c

277

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

338

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

tools/testing/selftests/mm/khugepaged.c

339

if (p[i * page_size / sizeof(*p)] != i + 0xdead0000) {

tools/testing/selftests/mm/khugepaged.c

341

i, p[i * page_size / sizeof(*p)]);

tools/testing/selftests/mm/khugepaged.c

632

madvise(p, page_size, MADV_DONTNEED);

tools/testing/selftests/mm/khugepaged.c

669

ops->fault(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

694

ops->fault(p, 0, (hpage_pmd_nr - max_ptes_none - fault_nr_pages) * page_size);

tools/testing/selftests/mm/khugepaged.c

697

validate_memory(p, 0, (hpage_pmd_nr - max_ptes_none - fault_nr_pages) * page_size);

tools/testing/selftests/mm/khugepaged.c

700

ops->fault(p, 0, (hpage_pmd_nr - max_ptes_none) * page_size);

tools/testing/selftests/mm/khugepaged.c

704

(hpage_pmd_nr - max_ptes_none) * page_size);

tools/testing/selftests/mm/khugepaged.c

719

if (madvise(p, page_size, MADV_PAGEOUT)) {

tools/testing/selftests/mm/khugepaged.c

723

if (check_swap(p, page_size)) {

tools/testing/selftests/mm/khugepaged.c

746

if (madvise(p, (max_ptes_swap + 1) * page_size, MADV_PAGEOUT)) {

tools/testing/selftests/mm/khugepaged.c

750

if (check_swap(p, (max_ptes_swap + 1) * page_size)) {

tools/testing/selftests/mm/khugepaged.c

765

if (madvise(p, max_ptes_swap * page_size, MADV_PAGEOUT)) {

tools/testing/selftests/mm/khugepaged.c

769

if (check_swap(p, max_ptes_swap * page_size)) {

tools/testing/selftests/mm/khugepaged.c

799

madvise(p + page_size, hpage_pmd_size - page_size, MADV_DONTNEED);

tools/testing/selftests/mm/khugepaged.c

807

validate_memory(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

818

madvise(p, page_size, MADV_NOHUGEPAGE);

tools/testing/selftests/mm/khugepaged.c

849

p = mremap(BASE_ADDR - i * page_size,

tools/testing/selftests/mm/khugepaged.c

850

i * page_size + hpage_pmd_size,

tools/testing/selftests/mm/khugepaged.c

851

(i + 1) * page_size,

tools/testing/selftests/mm/khugepaged.c

860

(i + 1) * page_size,

tools/testing/selftests/mm/khugepaged.c

861

(i + 1) * page_size + hpage_pmd_size,

tools/testing/selftests/mm/khugepaged.c

863

BASE_ADDR - (i + 1) * page_size);

tools/testing/selftests/mm/khugepaged.c

892

ops->fault(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

909

ops->fault(p, page_size, 2 * page_size);

tools/testing/selftests/mm/khugepaged.c

913

validate_memory(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

926

validate_memory(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

948

madvise(p, page_size, MADV_NOHUGEPAGE);

tools/testing/selftests/mm/khugepaged.c

954

ops->fault(p, 0, page_size);

tools/testing/selftests/mm/khugepaged.c

999

ops->fault(p, 0, (hpage_pmd_nr - max_ptes_shared - 1) * 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

342

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

350

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

354

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

366

map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

370

if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

375

memset(map_ptr + page_size, '+', 1);

tools/testing/selftests/mm/ksm_tests.c

384

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

390

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

395

int timeout, bool use_zero_pages, size_t page_size)

tools/testing/selftests/mm/ksm_tests.c

409

map_ptr = allocate_memory(NULL, prot, mapping, 0, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

413

if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

429

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

434

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

460

bool merge_across_nodes, size_t page_size)

tools/testing/selftests/mm/ksm_tests.c

485

numa1_map_ptr = numa_alloc_onnode(page_size, first_node);

tools/testing/selftests/mm/ksm_tests.c

486

numa2_map_ptr = numa_alloc_onnode(page_size, get_next_mem_node(first_node));

tools/testing/selftests/mm/ksm_tests.c

492

memset(numa1_map_ptr, '*', page_size);

tools/testing/selftests/mm/ksm_tests.c

493

memset(numa2_map_ptr, '*', page_size);

tools/testing/selftests/mm/ksm_tests.c

496

if (ksm_merge_pages(merge_type, numa1_map_ptr, page_size, start_time, timeout) ||

tools/testing/selftests/mm/ksm_tests.c

497

ksm_merge_pages(merge_type, numa2_map_ptr, page_size, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

511

numa_free(numa1_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

512

numa_free(numa2_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

517

numa_free(numa1_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

518

numa_free(numa2_map_ptr, page_size);

tools/testing/selftests/mm/ksm_tests.c

684

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

693

map_ptr = allocate_memory(NULL, prot, mapping, '*', page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

702

memset(map_ptr + page_size * i, '-', 1);

tools/testing/selftests/mm/ksm_tests.c

711

printf("Total size: %lu MiB\n\n", (page_size * page_count) / MB);

tools/testing/selftests/mm/ksm_tests.c

715

printf("Average speed: %.3f MiB/s\n\n", ((page_size * (page_count / 2)) / MB) /

tools/testing/selftests/mm/ksm_tests.c

720

memset(map_ptr + page_size * i, '+', i / 2 + 1);

tools/testing/selftests/mm/ksm_tests.c

721

memset(map_ptr + page_size * (i + 1), '+', i / 2 + 1);

tools/testing/selftests/mm/ksm_tests.c

723

if (ksm_merge_pages(merge_type, map_ptr, page_size * page_count, start_time, timeout))

tools/testing/selftests/mm/ksm_tests.c

731

memset(map_ptr + page_size * i, '-', 1);

tools/testing/selftests/mm/ksm_tests.c

743

printf("Average speed: %.3f MiB/s\n", ((page_size * (page_count / 2)) / MB) /

tools/testing/selftests/mm/ksm_tests.c

746

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

751

munmap(map_ptr, page_size * page_count);

tools/testing/selftests/mm/ksm_tests.c

762

size_t page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/ksm_tests.c

875

ksm_scan_limit_sec, page_size);

tools/testing/selftests/mm/ksm_tests.c

879

ksm_scan_limit_sec, page_size);

tools/testing/selftests/mm/ksm_tests.c

884

page_size);

tools/testing/selftests/mm/ksm_tests.c

888

ksm_scan_limit_sec, merge_across_nodes, page_size);

tools/testing/selftests/mm/ksm_tests.c

916

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

101

self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/memory-failure.c

172

ASSERT_TRUE(check_memory(vaddr, self->page_size));

tools/testing/selftests/mm/memory-failure.c

185

ASSERT_EQ(1UL << siginfo.si_addr_lsb, self->page_size);

tools/testing/selftests/mm/memory-failure.c

197

ASSERT_EQ(size, self->corrupted_size + self->page_size / 1024);

tools/testing/selftests/mm/memory-failure.c

226

addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/memory-failure.c

230

memset(addr, 0xce, self->page_size);

tools/testing/selftests/mm/memory-failure.c

248

ASSERT_EQ(munmap(addr, self->page_size), 0);

tools/testing/selftests/mm/memory-failure.c

283

fd = prepare_file("./clean-page-cache-test-file", self->page_size);

tools/testing/selftests/mm/memory-failure.c

290

addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/memory-failure.c

294

memset(addr, 0xce, self->page_size);

tools/testing/selftests/mm/memory-failure.c

313

ASSERT_EQ(munmap(addr, self->page_size), 0);

tools/testing/selftests/mm/memory-failure.c

325

fd = prepare_file("./dirty-page-cache-test-file", self->page_size);

tools/testing/selftests/mm/memory-failure.c

332

addr = mmap(0, self->page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/memory-failure.c

336

memset(addr, 0xce, self->page_size);

tools/testing/selftests/mm/memory-failure.c

354

ASSERT_EQ(munmap(addr, self->page_size), 0);

tools/testing/selftests/mm/memory-failure.c

45

unsigned long page_size;

tools/testing/selftests/mm/memory-failure.c

61

return madvise(vaddr, self->page_size, MADV_HWPOISON);

tools/testing/selftests/mm/memory-failure.c

72

return madvise(vaddr, self->page_size, MADV_SOFT_OFFLINE);

tools/testing/selftests/mm/merge.c

1002

ptr = mmap(&carveout[page_size], 15 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

1023

ptr3 = &ptr[10 * page_size];

tools/testing/selftests/mm/merge.c

1024

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1025

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 2000);

tools/testing/selftests/mm/merge.c

1027

ptr2 = &ptr[5 * page_size];

tools/testing/selftests/mm/merge.c

1028

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1029

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

1048

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1049

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

105

ASSERT_EQ(munmap(self->carveout, 30 * self->page_size), 0);

tools/testing/selftests/mm/merge.c

1054

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

1064

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1065

MREMAP_MAYMOVE | MREMAP_FIXED, ptr + page_size * 1000);

tools/testing/selftests/mm/merge.c

1083

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1084

MREMAP_MAYMOVE | MREMAP_FIXED, &carveout[page_size]);

tools/testing/selftests/mm/merge.c

1089

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

1099

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1100

MREMAP_MAYMOVE | MREMAP_FIXED, ptr + page_size * 1000);

tools/testing/selftests/mm/merge.c

1118

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1119

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr2[5 * page_size]);

tools/testing/selftests/mm/merge.c

1124

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 10 * page_size);

tools/testing/selftests/mm/merge.c

113

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1141

ptr = sys_mremap(ptr, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1142

MREMAP_MAYMOVE | MREMAP_FIXED, &carveout[page_size]);

tools/testing/selftests/mm/merge.c

1147

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

1157

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1158

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

1176

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1177

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

1182

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

1192

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1193

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 1000);

tools/testing/selftests/mm/merge.c

1211

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

1212

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[10 * page_size]);

tools/testing/selftests/mm/merge.c

1217

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

1223

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1239

ptr_a = mmap(&self->carveout[page_size + 3 * page_size],

tools/testing/selftests/mm/merge.c

1240

3 * page_size,

tools/testing/selftests/mm/merge.c

1259

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

126

ptr = mmap(&carveout[page_size], 10 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

1260

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1264

ptr_b = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1273

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1275

&self->carveout[page_size + 3 * page_size]);

tools/testing/selftests/mm/merge.c

1282

offset = variant->forked ? 3 * page_size : 6 * page_size;

tools/testing/selftests/mm/merge.c

1289

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1307

ptr_a = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1326

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1327

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1331

ptr_b = mmap(&self->carveout[page_size + 3 * page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1340

ptr_a = mremap(ptr_a, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1342

&self->carveout[page_size]);

tools/testing/selftests/mm/merge.c

1348

offset = variant->forked ? 3 * page_size : 6 * page_size;

tools/testing/selftests/mm/merge.c

1355

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

137

ASSERT_EQ(mprotect(ptr, 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

1371

ptr_b = mmap(&self->carveout[page_size + 3 * page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1390

ptr_b = mremap(ptr_b, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1391

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1396

ptr_a = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1402

ptr_c = mmap(&self->carveout[page_size + 3 * page_size + 3 * page_size],

tools/testing/selftests/mm/merge.c

1403

3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

1411

ptr_b = mremap(ptr_b, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1413

&self->carveout[page_size + 3 * page_size]);

tools/testing/selftests/mm/merge.c

1419

offset = variant->forked ? 3 * page_size : 9 * page_size;

tools/testing/selftests/mm/merge.c

1426

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + 3 * page_size);

tools/testing/selftests/mm/merge.c

1433

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

1451

ptr_bc = mmap(&self->carveout[page_size + 3 * page_size],

tools/testing/selftests/mm/merge.c

1452

3 * page_size + 3 * page_size,

tools/testing/selftests/mm/merge.c

147

ptr[5 * page_size] = 'x';

tools/testing/selftests/mm/merge.c

1473

ptr_b = mremap(ptr_bc, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1474

MREMAP_FIXED | MREMAP_MAYMOVE, &self->carveout[20 * page_size]);

tools/testing/selftests/mm/merge.c

1478

ptr_a = mmap(&self->carveout[page_size], 3 * page_size,

tools/testing/selftests/mm/merge.c

1487

ptr_b = mremap(ptr_b, 3 * page_size, 3 * page_size,

tools/testing/selftests/mm/merge.c

1489

&self->carveout[page_size + 3 * page_size]);

tools/testing/selftests/mm/merge.c

1496

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_b + 6 * page_size);

tools/testing/selftests/mm/merge.c

1500

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr_a + 9 * page_size);

tools/testing/selftests/mm/merge.c

157

ASSERT_EQ(mprotect(&ptr[5 * page_size], 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

162

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

167

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

177

ptr = mmap(&carveout[page_size], 10 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

188

ASSERT_EQ(mprotect(&ptr[5 * page_size], 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

20

unsigned int page_size;

tools/testing/selftests/mm/merge.c

207

ASSERT_EQ(mprotect(ptr, 5 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

212

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

217

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

227

ptr = mmap(&carveout[2 * page_size], 9 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

238

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

239

ASSERT_EQ(mprotect(&ptr[6 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

249

ptr[3 * page_size] = 'x';

tools/testing/selftests/mm/merge.c

25

static char *map_carveout(unsigned int page_size)

tools/testing/selftests/mm/merge.c

258

ASSERT_EQ(mprotect(&ptr[3 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

263

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 9 * page_size);

tools/testing/selftests/mm/merge.c

268

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

27

return mmap(NULL, 30 * page_size, PROT_NONE,

tools/testing/selftests/mm/merge.c

278

ptr = mmap(&carveout[2 * page_size], 9 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

289

ASSERT_EQ(mprotect(&ptr[6 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

308

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

317

ASSERT_EQ(mprotect(&ptr[3 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

322

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 9 * page_size);

tools/testing/selftests/mm/merge.c

327

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

337

ptr = mmap(&carveout[2 * page_size], 9 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

348

ASSERT_EQ(mprotect(ptr, 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

358

ptr[3 * page_size] = 'x';

tools/testing/selftests/mm/merge.c

367

ASSERT_EQ(mprotect(&ptr[6 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

376

ASSERT_EQ(mprotect(&ptr[3 * page_size], 3 * page_size, PROT_READ), 0);

tools/testing/selftests/mm/merge.c

381

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 9 * page_size);

tools/testing/selftests/mm/merge.c

386

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

398

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

417

for (i = 0; i < 5 * page_size; i += page_size)

tools/testing/selftests/mm/merge.c

429

ptr2 = mmap(&ptr[5 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

436

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 5 * page_size);

tools/testing/selftests/mm/merge.c

441

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

453

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

472

for (i = 0; i < 5 * page_size; i += page_size)

tools/testing/selftests/mm/merge.c

484

ptr2 = mmap(&carveout[6 * page_size], 5 * page_size, PROT_READ | PROT_WRITE | PROT_EXEC,

tools/testing/selftests/mm/merge.c

491

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 5 * page_size);

tools/testing/selftests/mm/merge.c

505

ASSERT_EQ(mprotect(ptr, 5 * page_size, PROT_READ | PROT_WRITE | PROT_EXEC), 0);

tools/testing/selftests/mm/merge.c

509

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 5 * page_size);

tools/testing/selftests/mm/merge.c

515

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

526

ASSERT_EQ(ftruncate(fd, page_size), 0);

tools/testing/selftests/mm/merge.c

53

self->page_size = psize();

tools/testing/selftests/mm/merge.c

539

ptr1 = mmap(&carveout[page_size], 10 * page_size, PROT_EXEC,

tools/testing/selftests/mm/merge.c

543

ptr2 = mremap(ptr1, page_size, 2 * page_size,

tools/testing/selftests/mm/merge.c

544

MREMAP_MAYMOVE | MREMAP_FIXED, ptr1 + 5 * page_size);

tools/testing/selftests/mm/merge.c

547

ASSERT_NE(mremap(ptr2, page_size, page_size,

tools/testing/selftests/mm/merge.c

55

self->carveout = map_carveout(self->page_size);

tools/testing/selftests/mm/merge.c

557

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

573

ptr = mmap(&carveout[page_size], page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

576

ptr2 = mmap(&carveout[2 * page_size], page_size,

tools/testing/selftests/mm/merge.c

582

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 2 * page_size);

tools/testing/selftests/mm/merge.c

585

ASSERT_EQ(munmap(ptr2, page_size), 0);

tools/testing/selftests/mm/merge.c

602

ptr2 = mmap(&carveout[2 * page_size], page_size,

tools/testing/selftests/mm/merge.c

608

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 2 * page_size);

tools/testing/selftests/mm/merge.c

611

ASSERT_EQ(munmap(ptr, 2 * page_size), 0);

tools/testing/selftests/mm/merge.c

614

ptr = mmap(&carveout[page_size], page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

617

ptr2 = mmap(&carveout[2 * page_size], page_size,

tools/testing/selftests/mm/merge.c

623

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 2 * page_size);

tools/testing/selftests/mm/merge.c

628

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

63

ASSERT_EQ(munmap(self->carveout, 30 * self->page_size), 0);

tools/testing/selftests/mm/merge.c

641

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

644

ptr2 = mmap(&carveout[7 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

649

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

650

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

678

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

679

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

684

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

689

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

702

ptr = mmap(&carveout[6 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

705

ptr2 = mmap(&carveout[14 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

710

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

711

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

739

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

740

MREMAP_MAYMOVE | MREMAP_FIXED, &carveout[page_size]);

tools/testing/selftests/mm/merge.c

745

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr2 + 10 * page_size);

tools/testing/selftests/mm/merge.c

75

unsigned int page_size;

tools/testing/selftests/mm/merge.c

750

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

763

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

766

ptr2 = mmap(&carveout[7 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

769

ptr3 = mmap(&carveout[14 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

774

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

775

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 2000);

tools/testing/selftests/mm/merge.c

779

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

780

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

802

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

803

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[10 * page_size]);

tools/testing/selftests/mm/merge.c

820

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

821

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

826

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 10 * page_size);

tools/testing/selftests/mm/merge.c

830

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr3 + 5 * page_size);

tools/testing/selftests/mm/merge.c

835

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

848

ptr = mmap(&carveout[page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

851

ptr2 = mmap(&carveout[7 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

854

ptr3 = mmap(&carveout[14 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

859

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

860

MREMAP_MAYMOVE | MREMAP_FIXED, ptr3 + page_size * 2000);

tools/testing/selftests/mm/merge.c

865

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

866

MREMAP_MAYMOVE | MREMAP_FIXED, ptr2 + page_size * 1000);

tools/testing/selftests/mm/merge.c

887

ptr3 = sys_mremap(ptr3, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

888

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[10 * page_size]);

tools/testing/selftests/mm/merge.c

905

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

906

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

911

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

916

unsigned int page_size = self->page_size;

tools/testing/selftests/mm/merge.c

928

ptr = mmap(&carveout[page_size], 15 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

951

ASSERT_EQ(munmap(&ptr[5 * page_size], 5 * page_size), 0);

tools/testing/selftests/mm/merge.c

961

ptr2 = mmap(&carveout[20 * page_size], 5 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/merge.c

97

self->page_size = psize();

tools/testing/selftests/mm/merge.c

979

ptr2 = sys_mremap(ptr2, 5 * page_size, 5 * page_size,

tools/testing/selftests/mm/merge.c

98

self->carveout = map_carveout(self->page_size);

tools/testing/selftests/mm/merge.c

980

MREMAP_MAYMOVE | MREMAP_FIXED, &ptr[5 * page_size]);

tools/testing/selftests/mm/merge.c

985

ASSERT_EQ(procmap->query.vma_end, (unsigned long)ptr + 15 * page_size);

tools/testing/selftests/mm/merge.c

990

unsigned int page_size = self->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

179

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

181

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

186

if (mlock2_(map, 2 * page_size, 0)) {

tools/testing/selftests/mm/mlock2-tests.c

187

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

194

if (munlock(map, 2 * page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

195

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

200

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

216

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

219

is_vma_lock_on_fault((unsigned long)map + page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

230

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

232

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

237

if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {

tools/testing/selftests/mm/mlock2-tests.c

238

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

245

if (munlock(map, 2 * page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

246

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

251

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

257

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

259

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

266

if (mlock2_(map, 2 * page_size, MLOCK_ONFAULT)) {

tools/testing/selftests/mm/mlock2-tests.c

267

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

272

is_vma_lock_on_fault((unsigned long)map + page_size),

tools/testing/selftests/mm/mlock2-tests.c

274

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

280

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

282

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

288

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

295

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

300

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

306

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

308

map = mmap(NULL, 2 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

314

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

321

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

328

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

335

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

340

munmap(map, 2 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

346

unsigned long page_size = getpagesize();

tools/testing/selftests/mm/mlock2-tests.c

351

map = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mlock2-tests.c

356

if (call_mlock && mlock2_(map, 3 * page_size, MLOCK_ONFAULT)) {

tools/testing/selftests/mm/mlock2-tests.c

357

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

362

get_vm_area((unsigned long)map + page_size, &page2) ||

tools/testing/selftests/mm/mlock2-tests.c

363

get_vm_area((unsigned long)map + page_size * 2, &page3)) {

tools/testing/selftests/mm/mlock2-tests.c

364

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

374

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

378

if (munlock(map + page_size, page_size)) {

tools/testing/selftests/mm/mlock2-tests.c

379

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

384

get_vm_area((unsigned long)map + page_size, &page2) ||

tools/testing/selftests/mm/mlock2-tests.c

385

get_vm_area((unsigned long)map + page_size * 2, &page3)) {

tools/testing/selftests/mm/mlock2-tests.c

386

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

392

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

397

if (munlock(map, page_size * 3)) {

tools/testing/selftests/mm/mlock2-tests.c

398

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

403

get_vm_area((unsigned long)map + page_size, &page2) ||

tools/testing/selftests/mm/mlock2-tests.c

404

get_vm_area((unsigned long)map + page_size * 2, &page3)) {

tools/testing/selftests/mm/mlock2-tests.c

405

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

411

munmap(map, 3 * page_size);

tools/testing/selftests/mm/mlock2-tests.c

416

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

1338

int page_size;

tools/testing/selftests/mm/mremap_test.c

1375

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/mm/mremap_test.c

1378

test_cases[0] = MAKE_TEST(page_size, page_size, page_size,

tools/testing/selftests/mm/mremap_test.c

1382

test_cases[1] = MAKE_TEST(page_size, page_size/4, page_size,

tools/testing/selftests/mm/mremap_test.c

1385

test_cases[2] = MAKE_TEST(page_size/4, page_size, page_size,

tools/testing/selftests/mm/mremap_test.c

1427

perf_test_cases[0] = MAKE_TEST(page_size, page_size, _1GB, NON_OVERLAPPING, EXPECT_SUCCESS,

tools/testing/selftests/mm/mremap_test.c

1455

mremap_expand_merge(maps_fp, page_size);

tools/testing/selftests/mm/mremap_test.c

1456

mremap_expand_merge_offset(maps_fp, page_size);

tools/testing/selftests/mm/mremap_test.c

1460

mremap_shrink_multiple_vmas(page_size, /* inplace= */true);

tools/testing/selftests/mm/mremap_test.c

1461

mremap_shrink_multiple_vmas(page_size, /* inplace= */false);

tools/testing/selftests/mm/mremap_test.c

1462

mremap_move_multiple_vmas(pattern_seed, page_size, /* dontunmap= */ false);

tools/testing/selftests/mm/mremap_test.c

1463

mremap_move_multiple_vmas(pattern_seed, page_size, /* dontunmap= */ true);

tools/testing/selftests/mm/mremap_test.c

1464

mremap_move_multiple_vmas_split(pattern_seed, page_size, /* dontunmap= */ false);

tools/testing/selftests/mm/mremap_test.c

1465

mremap_move_multiple_vmas_split(pattern_seed, page_size, /* dontunmap= */ true);

tools/testing/selftests/mm/mremap_test.c

1466

mremap_move_multi_invalid_vmas(maps_fp, page_size);

tools/testing/selftests/mm/mremap_test.c

253

static void mremap_expand_merge(FILE *maps_fp, unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

259

start = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_test.c

267

munmap(start + page_size, page_size);

tools/testing/selftests/mm/mremap_test.c

268

remap = mremap(start, page_size, 2 * page_size, 0);

tools/testing/selftests/mm/mremap_test.c

271

munmap(start, page_size);

tools/testing/selftests/mm/mremap_test.c

272

munmap(start + 2 * page_size, page_size);

tools/testing/selftests/mm/mremap_test.c

277

(unsigned long)(start + 3 * page_size));

tools/testing/selftests/mm/mremap_test.c

278

munmap(start, 3 * page_size);

tools/testing/selftests/mm/mremap_test.c

292

static void mremap_expand_merge_offset(FILE *maps_fp, unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

299

start = mmap(NULL, 3 * page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_test.c

308

munmap(start + 2 * page_size, page_size);

tools/testing/selftests/mm/mremap_test.c

309

remap = mremap(start + page_size, page_size, 2 * page_size, 0);

tools/testing/selftests/mm/mremap_test.c

312

munmap(start, 2 * page_size);

tools/testing/selftests/mm/mremap_test.c

317

(unsigned long)(start + 3 * page_size));

tools/testing/selftests/mm/mremap_test.c

318

munmap(start, 3 * page_size);

tools/testing/selftests/mm/mremap_test.c

398

char *ptr, unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

405

char *buf = &ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

406

size_t size = i == 4 ? 2 * page_size : page_size;

tools/testing/selftests/mm/mremap_test.c

423

unsigned long page_size,

tools/testing/selftests/mm/mremap_test.c

428

const size_t size = 11 * page_size;

tools/testing/selftests/mm/mremap_test.c

469

if (munmap(&ptr[i * page_size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

481

size_t size = i == 4 ? 2 * page_size : page_size;

tools/testing/selftests/mm/mremap_test.c

482

char *buf = &ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

495

if (!is_multiple_vma_range_ok(pattern_seed, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

508

if (!is_multiple_vma_range_ok(pattern_seed, &tgt_ptr[size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

528

if (!is_multiple_vma_range_ok(pattern_seed, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

548

static void mremap_shrink_multiple_vmas(unsigned long page_size,

tools/testing/selftests/mm/mremap_test.c

552

const size_t size = 10 * page_size;

tools/testing/selftests/mm/mremap_test.c

587

if (munmap(&ptr[i * page_size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

602

res = mremap(ptr, size, page_size, 0);

tools/testing/selftests/mm/mremap_test.c

604

res = mremap(ptr, size, page_size, MREMAP_MAYMOVE | MREMAP_FIXED,

tools/testing/selftests/mm/mremap_test.c

628

unsigned long page_size,

tools/testing/selftests/mm/mremap_test.c

633

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

670

if (munmap(&ptr[5 * page_size], page_size)) {

tools/testing/selftests/mm/mremap_test.c

680

char *buf = &ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

685

for (j = 0; j < page_size; j++)

tools/testing/selftests/mm/mremap_test.c

705

if (mremap(&ptr[2 * page_size], size - 3 * page_size, size - 3 * page_size,

tools/testing/selftests/mm/mremap_test.c

714

for (i = 0; i < 2 * page_size; i++)

tools/testing/selftests/mm/mremap_test.c

720

char *buf = &tgt_ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

725

for (j = 0; j < page_size; j++) {

tools/testing/selftests/mm/mremap_test.c

752

unsigned long page_size)

tools/testing/selftests/mm/mremap_test.c

755

const size_t size = 10 * page_size;

tools/testing/selftests/mm/mremap_test.c

812

void *unmap_ptr = &ptr[(i + 1) * page_size];

tools/testing/selftests/mm/mremap_test.c

813

unsigned long start = (unsigned long)&ptr[i * page_size];

tools/testing/selftests/mm/mremap_test.c

817

.len = page_size,

tools/testing/selftests/mm/mremap_test.c

827

if (munmap(unmap_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

853

if (is_ptr_mapped(maps_fp, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

864

res = mremap(ptr, page_size, page_size,

tools/testing/selftests/mm/mremap_test.c

876

if (munmap(tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

881

res = mmap(ptr, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/mm/mremap_test.c

906

if (!is_ptr_mapped(maps_fp, tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

917

if (munmap(tgt_ptr, page_size)) {

tools/testing/selftests/mm/mremap_test.c

922

if (munmap(ptr, size - 2 * page_size)) {

tools/testing/selftests/mm/mremap_test.c

928

res = mmap(&ptr[i * page_size], page_size,

tools/testing/selftests/mm/mremap_test.c

958

&tgt_ptr[i * page_size], page_size);

tools/testing/selftests/mm/mremap_test.c

985

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

1020

map = aligned_alloc(page_size, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1024

wp_init(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1025

wp_addr_range(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1028

if (pagemap_ioctl(map, page_size, &vec, 1, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

1034

wp_addr_range(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1038

if (pagemap_ioctl(map, page_size, &vec, 1, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

1044

wp_addr_range(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1046

wp_free(map, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1061

mem_size = 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1062

vec_size = mem_size / page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1169

nr_pages = (sbuf.st_size + page_size - 1) / page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1170

force_read_pages(fmem, nr_pages, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1184

buf_size = page_size * 10;

tools/testing/selftests/mm/pagemap_ioctl.c

1212

LEN(vec[0]) == (buf_size/page_size) &&

tools/testing/selftests/mm/pagemap_ioctl.c

1237

mem = mmap(0, 2 * page_size, PROT_READ|PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);

tools/testing/selftests/mm/pagemap_ioctl.c

1240

wp_init(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1241

wp_addr_range(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1244

memset(mem, 1, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1246

ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,

tools/testing/selftests/mm/pagemap_ioctl.c

1254

wp_addr_range(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1256

ksft_test_result(pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

1261

mem2 = mmap(mem + page_size, page_size, PROT_READ|PROT_WRITE,

tools/testing/selftests/mm/pagemap_ioctl.c

1265

wp_init(mem2, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1266

wp_addr_range(mem2, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1269

mprotect(mem, page_size, PROT_NONE);

tools/testing/selftests/mm/pagemap_ioctl.c

1270

mprotect(mem, 2 * page_size, PROT_READ);

tools/testing/selftests/mm/pagemap_ioctl.c

1271

mprotect(mem, 2 * page_size, PROT_READ|PROT_WRITE);

tools/testing/selftests/mm/pagemap_ioctl.c

1274

memset(mem, 2, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1277

mprotect(mem, page_size, PROT_NONE);

tools/testing/selftests/mm/pagemap_ioctl.c

1278

mprotect(mem, page_size, PROT_READ);

tools/testing/selftests/mm/pagemap_ioctl.c

1279

mprotect(mem, page_size, PROT_READ|PROT_WRITE);

tools/testing/selftests/mm/pagemap_ioctl.c

1281

ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,

tools/testing/selftests/mm/pagemap_ioctl.c

1290

wp_addr_range(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1292

memset(mem, 'A', 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1294

ret = pagemap_ioctl(mem, 2 * page_size, &vec, 1, 0, 0, PAGE_IS_WRITTEN,

tools/testing/selftests/mm/pagemap_ioctl.c

1302

wp_free(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1303

munmap(mem, 2 * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1315

int reset, int page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

1326

arg.end = (uintptr_t)(mem + count * page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1390

static void transact_test(int page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

1414

count = get_dirty_pages_reset(mem, nthreads * pages_per_thread, 1, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1416

count = get_dirty_pages_reset(mem, nthreads * pages_per_thread, 1, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1432

page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1442

c = get_dirty_pages_reset(mem, nthreads * pages_per_thread, 1, page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

1491

mem_size = 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1497

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

tools/testing/selftests/mm/pagemap_ioctl.c

1501

(mem_size / page_size), PAGE_IS_PFNZERO, 0, 0, PAGE_IS_PFNZERO);

tools/testing/selftests/mm/pagemap_ioctl.c

1505

ksft_test_result(ret == 1 && LEN(vec) == (mem_size / page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

1534

ksft_test_result(ret == 1 && LEN(vec) == (hpage_size / page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

1559

page_size = getpagesize();

tools/testing/selftests/mm/pagemap_ioctl.c

1570

mem_size = 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1583

mem_size = 512 * 10 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

1655

buf_size = page_size * 10;

tools/testing/selftests/mm/pagemap_ioctl.c

1684

buf_size = page_size * 10;

tools/testing/selftests/mm/pagemap_ioctl.c

1721

transact_test(page_size);

tools/testing/selftests/mm/pagemap_ioctl.c

191

mem_size = num_pages * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

211

vec_size = mem_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

248

mem_size = num_pages * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

321

for (i = 0; i < mem_size; i += 2 * page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

329

ksft_test_result((unsigned long long)ret == mem_size/(page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

355

for (i = 0; i < mem_size; i += 2 * page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

357

mem[(mem_size/page_size - 1) * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

376

vec_size = mem_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

38

size_t page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

380

ret = pagemap_ioctl(mem + page_size, 2 * page_size, vec, 1,

tools/testing/selftests/mm/pagemap_ioctl.c

392

vec[0].start == (uintptr_t)(mem + page_size) &&

tools/testing/selftests/mm/pagemap_ioctl.c

395

vec2[1].start == (uintptr_t)(mem + 3 * page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

42

#define LEN(region) ((region.end - region.start)/page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

424

ksft_test_result(ret == 1 && LEN(vec[0]) == mem_size/page_size,

tools/testing/selftests/mm/pagemap_ioctl.c

436

mem_size = 1050 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

437

vec_size = mem_size/(page_size*2);

tools/testing/selftests/mm/pagemap_ioctl.c

456

for (i = 0; i < mem_size/page_size; i += 2)

tools/testing/selftests/mm/pagemap_ioctl.c

457

mem[i * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

461

mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);

tools/testing/selftests/mm/pagemap_ioctl.c

469

mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);

tools/testing/selftests/mm/pagemap_ioctl.c

477

mem_size/(page_size*5), PAGE_IS_WRITTEN, 0, 0, PAGE_IS_WRITTEN);

tools/testing/selftests/mm/pagemap_ioctl.c

483

ksft_test_result(total_pages == mem_size/(page_size*2), "%s Smaller max_pages\n", __func__);

tools/testing/selftests/mm/pagemap_ioctl.c

491

mem_size = 10000 * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

509

for (i = 0; i < mem_size; i += page_size) {

tools/testing/selftests/mm/pagemap_ioctl.c

542

mem_size = vec_size * page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

610

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

621

for (i = 0; i < mem_size; i += 2 * page_size)

tools/testing/selftests/mm/pagemap_ioctl.c

635

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

642

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

670

ksft_test_result(ret == 1 && walk_end == (long)(mem + page_size * 2),

tools/testing/selftests/mm/pagemap_ioctl.c

697

vec_size = mem_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

717

ksft_test_result(written == 1 && LEN(vec[0]) == mem_size/page_size,

tools/testing/selftests/mm/pagemap_ioctl.c

726

memset(mem + page_size, 0, mem_size - (2 * page_size));

tools/testing/selftests/mm/pagemap_ioctl.c

750

mem[vec_size/2 * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

766

mem[vec_size/2 * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

767

mem[(vec_size/2 + 1) * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

769

written = pagemap_ioctl(&mem[vec_size/2 * page_size], 2 * page_size, vec, 1, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

774

ksft_test_result(written == 1 && vec[0].start == (uintptr_t)(&mem[vec_size/2 * page_size])

tools/testing/selftests/mm/pagemap_ioctl.c

807

unsigned long long vec_size = map_size/page_size;

tools/testing/selftests/mm/pagemap_ioctl.c

856

map[vec_size/2 * page_size]++;

tools/testing/selftests/mm/pagemap_ioctl.c

967

hpage_size/(2*page_size), PAGE_IS_WRITTEN, 0, 0,

tools/testing/selftests/mm/pagemap_ioctl.c

972

ksft_test_result(ret == 1 && LEN(vec[0]) == hpage_size/(2*page_size),

tools/testing/selftests/mm/pagemap_ioctl.c

980

ksft_test_result(ret2 == 1 && LEN(vec[0]) == (map_size - hpage_size/2)/page_size,

tools/testing/selftests/mm/pagemap_ioctl.c

999

long vec_size = len / 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

319

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

356

gopts->nr_pages * gopts->page_size, false);

tools/testing/selftests/mm/uffd-stress.c

417

gopts->page_size = default_huge_page_size();

tools/testing/selftests/mm/uffd-stress.c

419

gopts->page_size = sysconf(_SC_PAGE_SIZE);

tools/testing/selftests/mm/uffd-stress.c

421

if (!gopts->page_size)

tools/testing/selftests/mm/uffd-stress.c

424

> gopts->page_size)

tools/testing/selftests/mm/uffd-stress.c

487

get_free_hugepages() < 2 * (bytes / gopts->page_size) + gopts->nr_parallel - 1) {

tools/testing/selftests/mm/uffd-stress.c

492

gopts->nr_pages_per_cpu = bytes / gopts->page_size / gopts->nr_parallel;

tools/testing/selftests/mm/uffd-stress.c

495

bytes, gopts->page_size, gopts->nr_parallel);

tools/testing/selftests/mm/uffd-unit-tests.c

1007

offset &= ~(gopts->page_size-1);

tools/testing/selftests/mm/uffd-unit-tests.c

1010

if (offset & gopts->page_size)

tools/testing/selftests/mm/uffd-unit-tests.c

1037

uffd_register_poison(gopts->uffd, gopts->area_dst, poison_pages * gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

1038

memset(gopts->area_src, 0, poison_pages * gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

1051

unsigned long offset = nr * gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1065

for (i = bytes; i < bytes + gopts->page_size; ++i) {

tools/testing/selftests/mm/uffd-unit-tests.c

1109

uffd_move_handle_fault_common(gopts, msg, args, gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

1139

if (madvise(gopts->area_src, gopts->nr_pages * gopts->page_size, MADV_DONTFORK))

tools/testing/selftests/mm/uffd-unit-tests.c

1142

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

1150

step_size = chunk_size / gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1153

if (chunk_size > gopts->page_size) {

tools/testing/selftests/mm/uffd-unit-tests.c

1158

src_offs = (aligned_src - gopts->area_src) / gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1159

dst_offs = (aligned_dst - gopts->area_dst) / gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

1201

if (chunk_size > gopts->page_size) {

tools/testing/selftests/mm/uffd-unit-tests.c

1219

uffd_move_test_common(gopts, targs, gopts->page_size, uffd_move_handle_fault);

tools/testing/selftests/mm/uffd-unit-tests.c

1224

if (madvise(gopts->area_dst, gopts->nr_pages * gopts->page_size, MADV_HUGEPAGE))

tools/testing/selftests/mm/uffd-unit-tests.c

1232

if (madvise(gopts->area_dst, gopts->nr_pages * gopts->page_size, MADV_NOHUGEPAGE))

tools/testing/selftests/mm/uffd-unit-tests.c

1351

ret = madvise(gopts->area_dst, gopts->page_size, MADV_REMOVE);

tools/testing/selftests/mm/uffd-unit-tests.c

1376

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

1425

if (madvise(gopts->area_src, gopts->nr_pages * gopts->page_size, MADV_NOHUGEPAGE)) {

tools/testing/selftests/mm/uffd-unit-tests.c

1439

if (madvise(gopts->area_src, gopts->nr_pages * gopts->page_size, MADV_HUGEPAGE)) {

tools/testing/selftests/mm/uffd-unit-tests.c

1473

ret = uffd_register_with_ioctls(gopts->uffd, gopts->area_dst, gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

1504

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

1762

gopts.page_size = default_huge_page_size();

tools/testing/selftests/mm/uffd-unit-tests.c

1763

if (gopts.page_size == 0) {

tools/testing/selftests/mm/uffd-unit-tests.c

1768

gopts.page_size = psize();

tools/testing/selftests/mm/uffd-unit-tests.c

1772

gopts.nr_pages = MAX(UFFD_TEST_MEM_SIZE, gopts.page_size * 2)

tools/testing/selftests/mm/uffd-unit-tests.c

1773

/ gopts.page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

305

if (test_pin && pin_pages(&args, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

343

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

350

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

355

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, false);

tools/testing/selftests/mm/uffd-unit-tests.c

360

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

361

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

371

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

375

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

378

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

390

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

398

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

419

if (madvise(gopts->area_dst, gopts->page_size, MADV_DONTNEED))

tools/testing/selftests/mm/uffd-unit-tests.c

426

madvise(gopts->area_dst, gopts->page_size, MADV_PAGEOUT);

tools/testing/selftests/mm/uffd-unit-tests.c

439

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, false);

tools/testing/selftests/mm/uffd-unit-tests.c

449

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

471

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->page_size, false, true, false))

tools/testing/selftests/mm/uffd-unit-tests.c

478

wp_range(gopts->uffd, (uint64_t)gopts->area_dst, gopts->page_size, true);

tools/testing/selftests/mm/uffd-unit-tests.c

484

if (pin_pages(&pin_args, gopts->area_dst, gopts->page_size)) {

tools/testing/selftests/mm/uffd-unit-tests.c

488

uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

512

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

534

for (j = 0; j < gopts->page_size; j++) {

tools/testing/selftests/mm/uffd-unit-tests.c

535

uint8_t v = *(uint8_t *)(p + (i * gopts->page_size) + j);

tools/testing/selftests/mm/uffd-unit-tests.c

556

if (uffd_register(gopts->uffd, gopts->area_dst_alias, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

566

memset(gopts->area_dst + (p * gopts->page_size), p % ((uint8_t)-1),

tools/testing/selftests/mm/uffd-unit-tests.c

567

gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

587

if (madvise(gopts->area_dst_alias, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

596

gopts->nr_pages * gopts->page_size /

tools/testing/selftests/mm/uffd-unit-tests.c

681

unsigned long offset = nr * gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

701

gopts->page_size, false);

tools/testing/selftests/mm/uffd-unit-tests.c

724

gopts->area_dst = mremap(gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

725

gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

749

for (i = 0; i < gopts->page_size; i++)

tools/testing/selftests/mm/uffd-unit-tests.c

750

if (*(gopts->area_dst + nr * gopts->page_size + i) != 0)

tools/testing/selftests/mm/uffd-unit-tests.c

770

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

829

if (uffd_register(gopts->uffd, gopts->area_dst, gopts->nr_pages * gopts->page_size,

tools/testing/selftests/mm/uffd-unit-tests.c

894

uffdio_zeropage.range.len = gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

905

if (res != gopts->page_size)

tools/testing/selftests/mm/uffd-unit-tests.c

941

gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

944

uffd_register_detect_zeropage(gopts->uffd, gopts->area_dst_alias, gopts->page_size);

tools/testing/selftests/mm/uffd-unit-tests.c

947

for (i = 0; i < gopts->page_size; i++)

tools/testing/selftests/mm/uffd-unit-tests.c

951

if (uffd_unregister(gopts->uffd, gopts->area_dst, gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

956

gopts->page_size))

tools/testing/selftests/mm/uffd-unit-tests.c

982

uffdio_poison.range.len = gopts->page_size;

tools/testing/selftests/mm/uffd-unit-tests.c

989

else if (res != gopts->page_size)

tools/testing/selftests/namespaces/listns_efault_test.c

184

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

253

long page_size;

tools/testing/selftests/namespaces/listns_efault_test.c

261

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/namespaces/listns_efault_test.c

262

ASSERT_GT(page_size, 0);

tools/testing/selftests/namespaces/listns_efault_test.c

265

map = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/namespaces/listns_efault_test.c

270

ret = munmap((char *)map + page_size, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

277

ns_ids = ((__u64 *)((char *)map + page_size)) - 5;

tools/testing/selftests/namespaces/listns_efault_test.c

393

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

405

long page_size;

tools/testing/selftests/namespaces/listns_efault_test.c

41

long page_size;

tools/testing/selftests/namespaces/listns_efault_test.c

413

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/namespaces/listns_efault_test.c

414

ASSERT_GT(page_size, 0);

tools/testing/selftests/namespaces/listns_efault_test.c

417

map = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/namespaces/listns_efault_test.c

421

ret = munmap((char *)map + page_size, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

425

ns_ids = ((__u64 *)((char *)map + page_size)) - 3;

tools/testing/selftests/namespaces/listns_efault_test.c

49

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/namespaces/listns_efault_test.c

50

ASSERT_GT(page_size, 0);

tools/testing/selftests/namespaces/listns_efault_test.c

527

munmap(map, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

57

map = mmap(NULL, page_size * 2, PROT_READ | PROT_WRITE,

tools/testing/selftests/namespaces/listns_efault_test.c

62

ret = munmap((char *)map + page_size, page_size);

tools/testing/selftests/namespaces/listns_efault_test.c

70

ns_ids = ((__u64 *)((char *)map + page_size)) - 1;

tools/testing/selftests/net/ipsec.c

1754

if (do_ping(cmd_fd, buf, page_size, src, true, 0, 0, udp_ping_send)) {

tools/testing/selftests/net/ipsec.c

1779

if (do_ping(cmd_fd, buf, page_size, tunsrc,

tools/testing/selftests/net/ipsec.c

1903

if (do_ping(cmd_fd, buf, page_size, tun_reply ? tunsrc : src,

tools/testing/selftests/net/ipsec.c

1989

data_map = mmap(0, page_size, PROT_READ | PROT_WRITE,

tools/testing/selftests/net/ipsec.c

1996

randomize_buffer(data_map, page_size);

tools/testing/selftests/net/ipsec.c

2303

page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/net/ipsec.c

2304

if (page_size < 1)

tools/testing/selftests/net/ipsec.c

70

static long page_size;

tools/testing/selftests/net/ipsec.c

785

ping_succeeded += !func(ping_sock, to, d_port, buf, page_size);

tools/testing/selftests/nolibc/nolibc-test.c

1131

int ret, fd, i, page_size;

tools/testing/selftests/nolibc/nolibc-test.c

1143

page_size = getpagesize();

tools/testing/selftests/nolibc/nolibc-test.c

1144

if (page_size < 0)

tools/testing/selftests/nolibc/nolibc-test.c

1164

file_size = 3*page_size;

tools/testing/selftests/nolibc/nolibc-test.c

1172

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

116

bytes_read = read(self->maps_fd, self->page1.data, self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

122

bytes_read = read(self->maps_fd, self->page2.data, self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

343

return mmap(self->mod_info->addr, self->page_size, self->mod_info->prot | PROT_EXEC,

tools/testing/selftests/proc/proc-maps-race.c

349

return mmap(self->mod_info->addr, self->page_size, self->mod_info->prot,

tools/testing/selftests/proc/proc-maps-race.c

365

return mremap(self->mod_info->addr, self->page_size * 3,

tools/testing/selftests/proc/proc-maps-race.c

366

self->page_size, 0) != MAP_FAILED;

tools/testing/selftests/proc/proc-maps-race.c

371

return mremap(self->mod_info->addr, self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

372

self->page_size * 3, 0) != MAP_FAILED;

tools/testing/selftests/proc/proc-maps-race.c

393

return mremap(self->mod_info->next_addr + self->page_size * 2, self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

394

self->page_size, MREMAP_FIXED | MREMAP_MAYMOVE | MREMAP_DONTUNMAP,

tools/testing/selftests/proc/proc-maps-race.c

395

self->mod_info->addr + self->page_size) != MAP_FAILED;

tools/testing/selftests/proc/proc-maps-race.c

400

return mprotect(self->mod_info->addr + self->page_size, self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

424

self->page_size = (unsigned long)sysconf(_SC_PAGESIZE);

tools/testing/selftests/proc/proc-maps-race.c

433

self->vma_count = self->page_size / 32 + 1;

tools/testing/selftests/proc/proc-maps-race.c

460

mod_info->child_mapped_addr[i] = mmap(NULL, self->page_size * 3, prot,

tools/testing/selftests/proc/proc-maps-race.c

487

munmap(mod_info->child_mapped_addr[i], self->page_size * 3);

tools/testing/selftests/proc/proc-maps-race.c

500

self->page1.data = malloc(self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

502

self->page2.data = malloc(self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

543

munmap(self->mod_info->child_mapped_addr[i], self->page_size);

tools/testing/selftests/proc/proc-maps-race.c

622

ASSERT_TRUE(query_addr_at(self->maps_fd, mod_info->addr + self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

711

(vma_end - vma_start == self->page_size * 3 ||

tools/testing/selftests/proc/proc-maps-race.c

712

vma_end - vma_start == self->page_size));

tools/testing/selftests/proc/proc-maps-race.c

785

ASSERT_TRUE(query_addr_at(self->maps_fd, mod_info->addr + self->page_size,

tools/testing/selftests/proc/proc-maps-race.c

793

vma_end - vma_start == self->page_size * 3) ||

tools/testing/selftests/proc/proc-maps-race.c

794

(vma_start == self->last_line.start_addr + self->page_size &&

tools/testing/selftests/proc/proc-maps-race.c

795

vma_end - vma_start == self->page_size));

tools/testing/selftests/proc/proc-maps-race.c

80

int 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

775

int page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/seccomp/seccomp_bpf.c

777

ASSERT_LT(0, page_size);

tools/testing/selftests/seccomp/seccomp_bpf.c

790

NULL, page_size, PROT_READ, MAP_PRIVATE, fd, page_size);

tools/testing/selftests/seccomp/seccomp_bpf.c

794

NULL, page_size, PROT_READ, MAP_PRIVATE, fd, 0x0C0FFEE);

tools/testing/selftests/seccomp/seccomp_bpf.c

798

munmap(map1, page_size);

tools/testing/selftests/seccomp/seccomp_bpf.c

799

munmap(map2, page_size);

tools/testing/selftests/user_events/perf_test.c

138

int page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/user_events/perf_test.c

170

perf_page = mmap(NULL, page_size * 2, PROT_READ, MAP_SHARED, fd, 0);

tools/testing/selftests/user_events/perf_test.c

191

munmap(perf_page, page_size * 2);

tools/testing/selftests/user_events/perf_test.c

202

int page_size = sysconf(_SC_PAGESIZE);

tools/testing/selftests/user_events/perf_test.c

232

perf_page = mmap(NULL, page_size * 2, PROT_READ, MAP_SHARED, fd, 0);

tools/testing/selftests/user_events/perf_test.c

244

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

358

int page_size;

tools/testing/vsock/vsock_test.c

382

page_size = getpagesize();

tools/testing/vsock/vsock_test.c

383

max_msg_size = MAX_MSG_PAGES * page_size;

tools/testing/vsock/vsock_test.c

393

buf_size = page_size +

tools/testing/vsock/vsock_test.c

394

(rand() % (max_msg_size - page_size));

tools/testing/vsock/vsock_test.c

396

buf_size = 1 + (rand() % page_size);

tools/testing/vsock/vsock_test.c

736

int page_size = getpagesize();

tools/testing/vsock/vsock_test.c

737

int buf_size = page_size * 3;

tools/testing/vsock/vsock_test.c

757

if (munmap(broken_buf + page_size, page_size)) {

tools/testing/vsock/vsock_test.c

806

munmap(broken_buf, page_size);

tools/testing/vsock/vsock_test.c

807

munmap(broken_buf + page_size * 2, page_size);