crypto/openssl/crypto/mem_sec.c

502

pgsize = PAGE_SIZE;

crypto/openssl/crypto/mem_sec.c

510

pgsize = PAGE_SIZE;

crypto/openssl/crypto/mem_sec.c

82

#ifndef PAGE_SIZE

lib/libc/gmon/mcount.c

101

>= (uintfptr_t)(VM_MAXUSER_ADDRESS + UPAGES * PAGE_SIZE))

lib/libc/tests/sys/brk_test.c

120

newbrk = sbrk(PAGE_SIZE * 2);

lib/libc/tests/sys/brk_test.c

123

n = (void *)(((uintptr_t)oldbrk + PAGE_SIZE) & ~PAGE_SIZE);

lib/libc/tests/sys/brk_test.c

125

error = mincore(n, PAGE_SIZE, &v);

lib/libc/tests/sys/brk_test.c

56

error = brk((void *)((intptr_t)oldbrk + PAGE_SIZE * 2));

lib/libc/tests/sys/brk_test.c

89

oldbrk = sbrk(PAGE_SIZE * 2 + 1);

lib/libc/tests/sys/brk_test.c

91

memset(oldbrk, 0, PAGE_SIZE * 2 + 1);

lib/libc/tests/sys/brk_test.c

92

newbrk = sbrk(-(PAGE_SIZE * 2 + 1));

lib/libkvm/kvm_amd64.h

66

_Static_assert(PAGE_SIZE == AMD64_PAGE_SIZE, "PAGE_SIZE mismatch");

lib/libkvm/kvm_arm.h

87

_Static_assert(PAGE_SIZE == ARM_PAGE_SIZE, "PAGE_SIZE mismatch");

lib/libkvm/kvm_i386.h

65

_Static_assert(PAGE_SIZE == I386_PAGE_SIZE, "PAGE_SIZE mismatch");

lib/libkvm/kvm_riscv.h

65

_Static_assert(PAGE_SIZE == RISCV_PAGE_SIZE, "PAGE_SIZE mismatch");

lib/libsecureboot/vectx.c

251

x = MIN(PAGE_SIZE, x);

lib/libsecureboot/vectx.c

272

if (ctx->vec_closing && d < PAGE_SIZE) {

lib/libsecureboot/vectx.c

312

unsigned char buf[PAGE_SIZE];

lib/libsecureboot/vectx.c

329

n = vectx_read(ctx, buf, PAGE_SIZE);

lib/libsecureboot/vectx.c

373

delta = MIN(PAGE_SIZE, delta);

lib/libsecureboot/veopen.c

350

unsigned char buf[PAGE_SIZE];

lib/libsys/getpagesize.c

48

value = PAGE_SIZE;

lib/libsys/getpagesizes.c

61

ps[0] = PAGE_SIZE;

lib/libsys/x86/__vdso_gettc.c

271

new_map = mmap(NULL, PAGE_SIZE, PROT_READ, MAP_SHARED, fd, 0);

lib/libsys/x86/__vdso_gettc.c

276

munmap((void *)new_map, PAGE_SIZE);

lib/libthr/arch/amd64/include/pthread_md.h

43

#define THR_PAGE_SIZE_MIN PAGE_SIZE

lib/libthr/arch/arm/include/pthread_md.h

41

#define THR_PAGE_SIZE_MIN PAGE_SIZE

lib/libthr/arch/i386/include/pthread_md.h

43

#define THR_PAGE_SIZE_MIN PAGE_SIZE

lib/libthr/arch/powerpc/include/pthread_md.h

42

#define THR_PAGE_SIZE_MIN PAGE_SIZE

lib/libthr/arch/riscv/include/pthread_md.h

48

#define THR_PAGE_SIZE_MIN PAGE_SIZE

lib/libvmmapi/vmmapi.c

1024

n = MIN(len, PAGE_SIZE - off);

sbin/nvmecontrol/firmware.c

173

if ((chunk = aligned_alloc(PAGE_SIZE, max_xfer_size)) == NULL)

sbin/nvmecontrol/modules/wdc/wdc.c

191

buf = aligned_alloc(PAGE_SIZE, max_xfer_size);

sbin/nvmecontrol/modules/wdc/wdc.c

340

buf = aligned_alloc(PAGE_SIZE, max_xfer_size);

stand/common/load_elf.c

276

ef->firstpage = malloc(PAGE_SIZE);

stand/common/load_elf.c

296

bytes_read = VECTX_READ(VECTX_HANDLE(ef), ef->firstpage, PAGE_SIZE);

stand/common/modinfo.c

219

return (roundup(addr, PAGE_SIZE));

stand/efi/loader/arch/amd64/multiboot2.c

236

(*result)->f_size = roundup((*result)->f_size, PAGE_SIZE);

stand/efi/loader/arch/amd64/multiboot2.c

333

_Static_assert(sizeof(header) <= PAGE_SIZE, "header too big");

stand/efi/loader/arch/amd64/multiboot2.c

343

EFI_SIZE_TO_PAGES(PAGE_SIZE), &addr);

stand/efi/loader/arch/amd64/multiboot2.c

460

payload_base = kern_base + fp->f_size - PAGE_SIZE;

stand/efi/loader/arch/amd64/multiboot2.c

467

header.modulep_offset = modulep - (fp->f_addr + fp->f_size - PAGE_SIZE);

stand/efi/loader/arch/amd64/multiboot2.c

468

archsw.arch_copyin(&header, fp->f_addr + fp->f_size - PAGE_SIZE,

stand/efi/loader/arch/amd64/multiboot2.c

475

if (*total_size > PAGE_SIZE)

stand/efi/loader/arch/amd64/multiboot2.c

487

BS->FreePages(addr, EFI_SIZE_TO_PAGES(PAGE_SIZE));

stand/efi/loader/arch/amd64/multiboot2.c

538

rfp->f_size = roundup(rfp->f_size, PAGE_SIZE);

stand/efi/loader/arch/amd64/multiboot2.c

539

rfp->f_size += PAGE_SIZE;

stand/i386/boot2/boot2.c

304

fs_off = PAGE_SIZE;

stand/i386/boot2/boot2.c

307

p += roundup2(hdr.ex.a_text, PAGE_SIZE);

stand/i386/boot2/boot2.c

324

p += roundup2(ep[1].p_memsz, PAGE_SIZE);

stand/i386/gptboot/gptboot.c

417

fs_off = PAGE_SIZE;

stand/i386/gptboot/gptboot.c

420

p += roundup2(hdr.ex.a_text, PAGE_SIZE);

stand/i386/gptboot/gptboot.c

423

p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE);

stand/i386/gptboot/gptboot.c

454

p += roundup2(ep[1].p_memsz, PAGE_SIZE);

stand/i386/gptzfsboot/zfsboot.c

375

lseek(fd, PAGE_SIZE, SEEK_SET);

stand/i386/gptzfsboot/zfsboot.c

381

p += roundup2(hdr.ex.a_text, PAGE_SIZE);

stand/i386/gptzfsboot/zfsboot.c

387

p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE);

stand/i386/gptzfsboot/zfsboot.c

433

p += roundup2(ep[1].p_memsz, PAGE_SIZE);

stand/i386/isoboot/isoboot.c

356

fs_off = PAGE_SIZE;

stand/i386/isoboot/isoboot.c

359

p += roundup2(hdr.ex.a_text, PAGE_SIZE);

stand/i386/isoboot/isoboot.c

362

p += hdr.ex.a_data + roundup2(hdr.ex.a_bss, PAGE_SIZE);

stand/i386/isoboot/isoboot.c

393

p += roundup2(ep[1].p_memsz, PAGE_SIZE);

stand/i386/libi386/elf64_freebsd.c

92

bzero(PT4, PAGE_SIZE);

stand/i386/libi386/elf64_freebsd.c

93

bzero(PT3, PAGE_SIZE);

stand/i386/libi386/elf64_freebsd.c

94

bzero(PT2, PAGE_SIZE);

stand/i386/libi386/multiboot.c

153

(*result)->f_size = roundup((*result)->f_size, PAGE_SIZE);

stand/i386/libi386/multiboot.c

174

_Static_assert(sizeof(header) <= PAGE_SIZE, "header too large for page");

stand/i386/libi386/multiboot.c

287

mb_mod[0].mod_end = fp->f_addr + fp->f_size - PAGE_SIZE;

stand/i386/libi386/multiboot.c

371

rfp->f_size = roundup(rfp->f_size, PAGE_SIZE);

stand/i386/libi386/multiboot.c

372

rfp->f_size += PAGE_SIZE;

stand/kboot/kboot/arch/aarch64/exec.c

56

#define LOADER_PAGE_SIZE PAGE_SIZE

stand/kboot/kboot/arch/amd64/elf64_freebsd.c

69

#define LOADER_PAGE_SIZE PAGE_SIZE

stand/kboot/kboot/main.c

613

chunk = min(PAGE_SIZE, len);

stand/kboot/kboot/main.c

654

loaded_segments[a].memsz = roundup2(loaded_segments[a].memsz,PAGE_SIZE);

stand/kboot/libkboot/dfk.c

52

uint8_t buf[PAGE_SIZE];

stand/kboot/libkboot/dfk.c

61

char buf[PAGE_SIZE];

stand/libofw/ofw_copy.c

80

if ((nlen + resid) < PAGE_SIZE*MAPMEM_PAGE_INC) {

stand/libofw/ofw_copy.c

81

dlen = PAGE_SIZE*MAPMEM_PAGE_INC;

stand/libofw/ofw_copy.c

83

dlen = roundup(nlen + resid, PAGE_SIZE);

stand/uboot/copy.c

44

#define KERN_ALIGN PAGE_SIZE

stand/userboot/userboot/elf64_freebsd.c

100

bzero(PT3, PAGE_SIZE);

stand/userboot/userboot/elf64_freebsd.c

101

bzero(PT2, PAGE_SIZE);

stand/userboot/userboot/elf64_freebsd.c

99

bzero(PT4, PAGE_SIZE);

sys/amd64/acpica/acpi_wakeup.c

338

*wakeaddr = contigmalloc(PAGE_SIZE, M_DEVBUF,

sys/amd64/acpica/acpi_wakeup.c

339

M_NOWAIT, 0x500, 0xa0000, PAGE_SIZE, 0ul);

sys/amd64/acpica/acpi_wakeup.c

422

bcopy(kernel_pmap->pm_pmltop, pt5, PAGE_SIZE);

sys/amd64/acpica/acpi_wakeup.c

426

bcopy(kernel_pmap->pm_pmltop, pt4, PAGE_SIZE);

sys/amd64/acpica/acpi_wakeup.c

68

CTASSERT(sizeof(wakecode) < PAGE_SIZE - 1024);

sys/amd64/amd64/efirt_machdep.c

260

va += PAGE_SIZE) {

sys/amd64/amd64/elf_machdep.c

131

.sv_shared_page_len = PAGE_SIZE,

sys/amd64/amd64/elf_machdep.c

160

sv->sv_maxuser -= PAGE_SIZE;

sys/amd64/amd64/elf_machdep.c

161

sv->sv_shared_page_base -= PAGE_SIZE;

sys/amd64/amd64/elf_machdep.c

162

sv->sv_usrstack -= PAGE_SIZE;

sys/amd64/amd64/elf_machdep.c

163

sv->sv_psstrings -= PAGE_SIZE;

sys/amd64/amd64/elf_machdep.c

88

.sv_shared_page_len = PAGE_SIZE,

sys/amd64/amd64/genassym.c

95

ASSYM(PAGE_SIZE, PAGE_SIZE);

sys/amd64/amd64/kexec_support.c

119

l++, pg += PAGE_SIZE) {

sys/amd64/amd64/kexec_support.c

170

va += PAGE_SIZE;

sys/amd64/amd64/kexec_support.c

174

va += PAGE_SIZE;

sys/amd64/amd64/kexec_support.c

178

va += PAGE_SIZE;

sys/amd64/amd64/kexec_support.c

212

PAGE_SIZE, true, false, &pct_iter);

sys/amd64/amd64/kexec_support.c

292

pages += howmany(pages * PAGE_SIZE, NBPDR);

sys/amd64/amd64/kexec_support.c

293

pages += howmany(pages * PAGE_SIZE, NBPDP);

sys/amd64/amd64/kexec_support.c

294

pages += howmany(pages * PAGE_SIZE, NBPML4);

sys/amd64/amd64/kexec_support.c

297

pages += howmany(kexec_do_reboot_size, PAGE_SIZE);

sys/amd64/amd64/kexec_support.c

72

vm_size_t stride = do_pte ? PAGE_SIZE : NBPDR;

sys/amd64/amd64/machdep.c

1080

phys_avail[pa_indx] += PAGE_SIZE;

sys/amd64/amd64/machdep.c

1091

phys_avail[pa_indx] = pa + PAGE_SIZE; /* end */

sys/amd64/amd64/machdep.c

1096

dump_avail[da_indx] += PAGE_SIZE;

sys/amd64/amd64/machdep.c

1104

dump_avail[da_indx] = pa + PAGE_SIZE; /* end */

sys/amd64/amd64/machdep.c

1122

while (phys_avail[pa_indx - 1] + PAGE_SIZE +

sys/amd64/amd64/machdep.c

1321

physfree = roundup2(physfree, PAGE_SIZE);

sys/amd64/amd64/machdep.c

1370

kstack0_sz = thread0.td_kstack_pages * PAGE_SIZE;

sys/amd64/amd64/machdep.c

294

(uintmax_t)size, (uintmax_t)size / PAGE_SIZE);

sys/amd64/amd64/machdep.c

857

#define PAGES_PER_GB (1024 * 1024 * 1024 / PAGE_SIZE)

sys/amd64/amd64/machdep.c

960

if (physmem_start < PAGE_SIZE)

sys/amd64/amd64/machdep.c

961

physmap[0] = PAGE_SIZE;

sys/amd64/amd64/machdep.c

963

physmap[0] = round_page(physmap[1] - PAGE_SIZE);

sys/amd64/amd64/machdep.c

994

for (pa = round_page(physmap[i]); pa < end; pa += PAGE_SIZE) {

sys/amd64/amd64/mem.c

155

p = pmap_mapdev(v, PAGE_SIZE);

sys/amd64/amd64/mem.c

157

pmap_unmapdev(p, PAGE_SIZE);

sys/amd64/amd64/mem.c

99

c = ulmin(iov->iov_len, PAGE_SIZE - (u_int)(v & PAGE_MASK));

sys/amd64/amd64/minidump_machdep.c

103

if ((((uintptr_t)pa) % PAGE_SIZE) != 0) {

sys/amd64/amd64/minidump_machdep.c

135

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

sys/amd64/amd64/minidump_machdep.c

194

pmapsize += PAGE_SIZE;

sys/amd64/amd64/minidump_machdep.c

214

pa += PAGE_SIZE;

sys/amd64/amd64/minidump_machdep.c

233

pa += PAGE_SIZE;

sys/amd64/amd64/minidump_machdep.c

265

dumpsize += PAGE_SIZE;

sys/amd64/amd64/minidump_machdep.c

270

dumpsize += PAGE_SIZE;

sys/amd64/amd64/minidump_machdep.c

300

error = blk_write(di, (char *)&fakepd, 0, PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

314

error = blk_write(di, (char *)fakepd, 0, PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

334

error = blk_write(di, (char *)&fakepd, 0, PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

350

error = blk_write(di, (char *)&fakepd, 0, PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

364

error = blk_write(di, (char *)pd, 0, PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

367

error = blk_write(di, (char *)&fakepd, 0, PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

378

error = blk_write(di, 0, pa, PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

91

maxdumpsz = min(di->maxiosize, MAXDUMPPGS * PAGE_SIZE);

sys/amd64/amd64/minidump_machdep.c

93

maxdumpsz = PAGE_SIZE;

sys/amd64/amd64/minidump_machdep.c

95

if ((sz % PAGE_SIZE) != 0) {

sys/amd64/amd64/mp_machdep.c

1014

addr += PAGE_SIZE;

sys/amd64/amd64/mp_machdep.c

349

MPASS(bootMP_size <= PAGE_SIZE);

sys/amd64/amd64/mp_machdep.c

352

PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);

sys/amd64/amd64/mp_machdep.c

429

bootstacks[cpu] = kmem_malloc(kstack_pages * PAGE_SIZE,

sys/amd64/amd64/mp_machdep.c

444

kstack_pages * PAGE_SIZE - 8;

sys/amd64/amd64/mp_machdep.c

771

ipi_range_size += (addr2 - addr1) / PAGE_SIZE;

sys/amd64/amd64/mp_machdep.c

94

#define AP_BOOTPT_SZ (PAGE_SIZE * 4)

sys/amd64/amd64/mp_machdep.c

954

addr += PAGE_SIZE;

sys/amd64/amd64/mp_machdep.c

980

addr += PAGE_SIZE;

sys/amd64/amd64/mp_machdep.c

991

d.addr += PAGE_SIZE;

sys/amd64/amd64/pmap.c

10512

error = vmem_alloc(kernel_arena, PAGE_SIZE,

sys/amd64/amd64/pmap.c

10571

vmem_free(kernel_arena, vaddr[i], PAGE_SIZE);

sys/amd64/amd64/pmap.c

10798

error = pmap_large_map_getva(len, PAGE_SIZE, 0, &vmem_res);

sys/amd64/amd64/pmap.c

10836

inc = PAGE_SIZE;

sys/amd64/amd64/pmap.c

10916

inc = PAGE_SIZE;

sys/amd64/amd64/pmap.c

11039

inc = PAGE_SIZE;

sys/amd64/amd64/pmap.c

11341

for (; sva < eva; sva += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

11384

sva = rounddown2(sva, PAGE_SIZE);

sys/amd64/amd64/pmap.c

11386

eva = roundup2(eva, PAGE_SIZE);

sys/amd64/amd64/pmap.c

11389

for (va = sva; va < eva; va += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

11609

ptep++, va += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

11707

static uint8_t data[PAGE_SIZE * SAN_EARLY_PAGES] __aligned(PAGE_SIZE);

sys/amd64/amd64/pmap.c

11717

offset += PAGE_SIZE;

sys/amd64/amd64/pmap.c

12023

sbuf_new_for_sysctl(sb, NULL, PAGE_SIZE, req);

sys/amd64/amd64/pmap.c

12148

sva += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

1641

bzero((void *)ret, n * PAGE_SIZE);

sys/amd64/amd64/pmap.c

1642

*firstaddr += n * PAGE_SIZE;

sys/amd64/amd64/pmap.c

2173

v = (c)va; va += ((n)*PAGE_SIZE); p = pte; pte += (n);

sys/amd64/amd64/pmap.c

2329

1, 0, (1ULL << 32), PAGE_SIZE, 0, VM_MEMATTR_DEFAULT));

sys/amd64/amd64/pmap.c

2441

for (j = 0; j < s; j += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

2625

error = vmem_alloc(kernel_arena, PAGE_SIZE, M_BESTFIT | M_WAITOK,

sys/amd64/amd64/pmap.c

2652

(vmem_size_t)lm_ents * NBPML4, PAGE_SIZE, 0, M_WAITOK);

sys/amd64/amd64/pmap.c

3269

#define PMAP_INVLPG_THRESHOLD (4 * 1024 * PAGE_SIZE)

sys/amd64/amd64/pmap.c

3290

for (d.addr = sva; d.addr < eva; d.addr += PAGE_SIZE)

sys/amd64/amd64/pmap.c

3339

for (addr = sva; addr < eva; addr += PAGE_SIZE)

sys/amd64/amd64/pmap.c

3343

for (addr = sva; addr < eva; addr += PAGE_SIZE)

sys/amd64/amd64/pmap.c

3658

if (count >= PMAP_CLFLUSH_THRESHOLD / PAGE_SIZE ||

sys/amd64/amd64/pmap.c

3668

eva = daddr + PAGE_SIZE;

sys/amd64/amd64/pmap.c

3727

error = vmem_alloc(kernel_arena, PAGE_SIZE, M_BESTFIT | M_WAITOK,

sys/amd64/amd64/pmap.c

3731

for (; spa < epa; spa += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

3736

pmap_flush_cache_range(vaddr, vaddr + PAGE_SIZE);

sys/amd64/amd64/pmap.c

3739

vmem_free(kernel_arena, vaddr, PAGE_SIZE);

sys/amd64/amd64/pmap.c

3964

PAGE_SIZE);

sys/amd64/amd64/pmap.c

3993

va += PAGE_SIZE;

sys/amd64/amd64/pmap.c

4914

dummypa = vm_phys_early_alloc(-1, PAGE_SIZE);

sys/amd64/amd64/pmap.c

4917

dummypt = vm_phys_early_alloc(-1, PAGE_SIZE);

sys/amd64/amd64/pmap.c

4919

dummypd = vm_phys_early_alloc(-1, PAGE_SIZE * npdpg);

sys/amd64/amd64/pmap.c

4978

pa = vm_phys_early_alloc(domain, PAGE_SIZE);

sys/amd64/amd64/pmap.c

4989

dump_add_page(pa + i * PAGE_SIZE);

sys/amd64/amd64/pmap.c

5735

va_last = va + NBPDR - PAGE_SIZE;

sys/amd64/amd64/pmap.c

5744

va += PAGE_SIZE;

sys/amd64/amd64/pmap.c

5801

va_last = va + NBPDR - PAGE_SIZE;

sys/amd64/amd64/pmap.c

5804

va += PAGE_SIZE;

sys/amd64/amd64/pmap.c

5884

newpte += PAGE_SIZE;

sys/amd64/amd64/pmap.c

5913

xpte++, newpte += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

6164

pmap->pm_stats.wired_count -= NBPDR / PAGE_SIZE;

sys/amd64/amd64/pmap.c

6167

pmap_resident_count_adj(pmap, -NBPDR / PAGE_SIZE);

sys/amd64/amd64/pmap.c

6174

va < eva; va += PAGE_SIZE, m++) {

sys/amd64/amd64/pmap.c

6287

sva += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

6300

sva += PAGE_SIZE;

sys/amd64/amd64/pmap.c

6350

if (sva + PAGE_SIZE == eva) {

sys/amd64/amd64/pmap.c

6397

pmap_resident_count_adj(pmap, -NBPDP / PAGE_SIZE);

sys/amd64/amd64/pmap.c

6611

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/amd64/amd64/pmap.c

6779

sva += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

6900

pa = (newpde & (PG_PS_FRAME | PG_V)) + NBPDR - PAGE_SIZE;

sys/amd64/amd64/pmap.c

6929

pa -= PAGE_SIZE;

sys/amd64/amd64/pmap.c

7071

pmap->pm_stats.wired_count += pagesizes[psind] / PAGE_SIZE;

sys/amd64/amd64/pmap.c

7073

pmap->pm_stats.wired_count -= pagesizes[psind] / PAGE_SIZE;

sys/amd64/amd64/pmap.c

7075

pmap_resident_count_adj(pmap, pagesizes[psind] / PAGE_SIZE);

sys/amd64/amd64/pmap.c

7606

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/amd64/amd64/pmap.c

7615

pmap->pm_stats.wired_count += NBPDR / PAGE_SIZE;

sys/amd64/amd64/pmap.c

7616

pmap_resident_count_adj(pmap, NBPDR / PAGE_SIZE);

sys/amd64/amd64/pmap.c

7666

m = vm_radix_iter_jump(&pages, NBPDR / PAGE_SIZE);

sys/amd64/amd64/pmap.c

7830

va = (vm_offset_t)crashdumpmap + (i * PAGE_SIZE);

sys/amd64/amd64/pmap.c

7884

for (pa = ptepa + PAGE_SIZE; pa < ptepa + size;

sys/amd64/amd64/pmap.c

7885

pa += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

7917

pmap_resident_count_adj(pmap, NBPDR / PAGE_SIZE);

sys/amd64/amd64/pmap.c

7979

pmap->pm_stats.wired_count -= NBPDP / PAGE_SIZE;

sys/amd64/amd64/pmap.c

8001

PAGE_SIZE;

sys/amd64/amd64/pmap.c

8009

sva += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

8121

pmap_resident_count_adj(dst_pmap, NBPDP / PAGE_SIZE);

sys/amd64/amd64/pmap.c

8160

PAGE_SIZE);

sys/amd64/amd64/pmap.c

8178

for (; addr < va_next; addr += PAGE_SIZE, src_pte++) {

sys/amd64/amd64/pmap.c

8280

if (off == 0 && size == PAGE_SIZE)

sys/amd64/amd64/pmap.c

8315

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/amd64/amd64/pmap.c

8316

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/amd64/amd64/pmap.c

8619

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/amd64/amd64/pmap.c

8628

pmap_resident_count_adj(pmap, -NBPDR / PAGE_SIZE);

sys/amd64/amd64/pmap.c

8633

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/amd64/amd64/pmap.c

9226

va -= PAGE_SIZE;

sys/amd64/amd64/pmap.c

9243

sva += PAGE_SIZE) {

sys/amd64/amd64/pmap.c

9453

for (tmpsize = 0; tmpsize < size; tmpsize += PAGE_SIZE)

sys/amd64/amd64/pmap.c

9612

pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,

sys/amd64/amd64/pmap.c

9631

PAGE_SIZE, PROT_NONE, m->md.pat_mode, 0);

sys/amd64/amd64/pmap.c

9814

tmpva += PAGE_SIZE;

sys/amd64/amd64/pmap.c

9894

pa_end = pa_start + PAGE_SIZE;

sys/amd64/amd64/pmap.c

9896

pa_end += PAGE_SIZE;

sys/amd64/amd64/pmap.c

9907

pa_end = pa_start + PAGE_SIZE;

sys/amd64/amd64/pmap.c

9910

tmpva += PAGE_SIZE;

sys/amd64/amd64/sys_machdep.c

426

uap->start + uap->length > IOPAGES * PAGE_SIZE * NBBY)

sys/amd64/amd64/sys_machdep.c

471

if (uap->start >= IOPAGES * PAGE_SIZE * NBBY)

sys/amd64/amd64/sys_machdep.c

485

for (i = uap->start + 1; i < IOPAGES * PAGE_SIZE * NBBY; i++) {

sys/amd64/amd64/uio_machdep.c

91

cnt = min(cnt, PAGE_SIZE - page_offset);

sys/amd64/amd64/vm_machdep.c

90

td->td_kstack_pages * PAGE_SIZE;

sys/amd64/include/intr_machdep.h

42

#define DBLFAULT_STACK_SIZE PAGE_SIZE

sys/amd64/include/intr_machdep.h

43

#define NMI_STACK_SIZE PAGE_SIZE

sys/amd64/include/intr_machdep.h

44

#define MCE_STACK_SIZE PAGE_SIZE

sys/amd64/include/intr_machdep.h

45

#define DBG_STACK_SIZE PAGE_SIZE

sys/amd64/include/param.h

105

#define NPDPEPG (PAGE_SIZE/(sizeof (pdp_entry_t)))

sys/amd64/include/param.h

111

#define NPML4EPG (PAGE_SIZE/(sizeof (pml4_entry_t)))

sys/amd64/include/param.h

117

#define NPML5EPG (PAGE_SIZE/(sizeof (pml5_entry_t)))

sys/amd64/include/param.h

131

#define IOPERM_BITMAP_SIZE (IOPAGES * PAGE_SIZE + 1)

sys/amd64/include/param.h

93

#define NPTEPG (PAGE_SIZE/(sizeof (pt_entry_t)))

sys/amd64/include/param.h

97

#define PAGE_MASK (PAGE_SIZE-1)

sys/amd64/include/param.h

99

#define NPDEPG (PAGE_SIZE/(sizeof (pd_entry_t)))

sys/amd64/include/stack.h

15

(total) = td->td_kstack_pages * PAGE_SIZE; \

sys/amd64/include/stack.h

17

td->td_kstack_pages * PAGE_SIZE - \

sys/amd64/include/stack.h

25

va + len <= td->td_kstack + td->td_kstack_pages * PAGE_SIZE);

sys/amd64/include/vmparam.h

231

#define SHAREDPAGE_LA57 (VM_MAXUSER_ADDRESS_LA57 - PAGE_SIZE)

sys/amd64/include/vmparam.h

232

#define SHAREDPAGE_LA48 (VM_MAXUSER_ADDRESS_LA48 - PAGE_SIZE)

sys/amd64/include/xen/hypercall.h

146

if (op >= PAGE_SIZE / 32)

sys/amd64/linux/linux_sysvec.c

708

.sv_shared_page_len = PAGE_SIZE,

sys/amd64/linux/linux_sysvec.c

781

linux_vdso_base -= PAGE_SIZE;

sys/amd64/linux/linux_sysvec.c

79

#define LINUX_VDSOPAGE_SIZE PAGE_SIZE * 2

sys/amd64/linux/linux_sysvec.c

82

#define LINUX_SHAREDPAGE_LA48 (LINUX_VDSOPAGE_LA48 - PAGE_SIZE)

sys/amd64/linux32/linux32_sysvec.c

80

#define LINUX32_MAXUSER ((1ul << 32) - PAGE_SIZE)

sys/amd64/linux32/linux32_sysvec.c

808

.sv_shared_page_len = PAGE_SIZE,

sys/amd64/linux32/linux32_sysvec.c

81

#define LINUX32_VDSOPAGE_SIZE PAGE_SIZE * 2

sys/amd64/linux32/linux32_sysvec.c

83

#define LINUX32_SHAREDPAGE (LINUX32_VDSOPAGE - PAGE_SIZE)

sys/amd64/pt/pt.c

196

offset = ((reg & PT_TOPA_PAGE_MASK) >> PT_TOPA_PAGE_SHIFT) * PAGE_SIZE;

sys/amd64/pt/pt.c

212

rec->curpage = offset / PAGE_SIZE;

sys/amd64/pt/pt.c

317

buf->size = vm->npages * PAGE_SIZE;

sys/amd64/pt/pt.c

680

*curpage = offset / PAGE_SIZE;

sys/amd64/sgx/sgx.c

1110

PAGE_SIZE, PAGE_SIZE, M_FIRSTFIT | M_WAITOK);

sys/amd64/sgx/sgx.c

172

if (vmem_alloc(sc->vmem_epc, PAGE_SIZE, M_FIRSTFIT | M_NOWAIT,

sys/amd64/sgx/sgx.c

174

i = (addr - sc->epc_base) / PAGE_SIZE;

sys/amd64/sgx/sgx.c

190

addr = (epc->index * PAGE_SIZE) + sc->epc_base;

sys/amd64/sgx/sgx.c

191

vmem_free(sc->vmem_epc, addr, PAGE_SIZE);

sys/amd64/sgx/sgx.c

370

offs = (pa - epc->phys) / PAGE_SIZE;

sys/amd64/sgx/sgx.c

428

for (i = 0, j = 1; i < PAGE_SIZE; i += 0x100, j <<= 1) {

sys/amd64/sgx/sgx.c

459

if (secs->size < 2 * PAGE_SIZE)

sys/amd64/sgx/sgx.c

516

(tcs->ossa & (PAGE_SIZE - 1)) ||

sys/amd64/sgx/sgx.c

517

(tcs->ofsbasgx & (PAGE_SIZE - 1)) ||

sys/amd64/sgx/sgx.c

518

(tcs->ogsbasgx & (PAGE_SIZE - 1)) ||

sys/amd64/sgx/sgx.c

658

secs = malloc(PAGE_SIZE, M_SGX, M_WAITOK | M_ZERO);

sys/amd64/sgx/sgx.c

830

tmp_vaddr = malloc(PAGE_SIZE, M_SGX, M_WAITOK | M_ZERO);

sys/amd64/sgx/sgx.c

831

ret = copyin((void *)addp->src, tmp_vaddr, PAGE_SIZE);

sys/amd64/sgx/sgx.c

947

tmp_vaddr = malloc(PAGE_SIZE, M_SGX, M_WAITOK | M_ZERO);

sys/amd64/sgx/sgx.c

949

einittoken = (void *)((uint64_t)sigstruct + PAGE_SIZE / 2);

sys/amd64/vmm/amd/amdvi_hw.c

1011

dom->ptp = malloc(PAGE_SIZE, M_AMDVI, M_WAITOK | M_ZERO);

sys/amd64/vmm/amd/amdvi_hw.c

1089

page = malloc(PAGE_SIZE, M_AMDVI, M_WAITOK | M_ZERO);

sys/amd64/vmm/amd/amdvi_hw.c

1138

PAGE_SIZE, create);

sys/amd64/vmm/amd/amdvi_hw.c

117

static struct amdvi_dte amdvi_dte[PCI_NUM_DEV_MAX] __aligned(PAGE_SIZE);

sys/amd64/vmm/amd/amdvi_hw.c

246

ctrl->cmd.base = vtophys(softc->cmd) / PAGE_SIZE;

sys/amd64/vmm/amd/amdvi_hw.c

526

ctrl->event.base = vtophys(softc->event) / PAGE_SIZE;

sys/amd64/vmm/amd/amdvi_hw.c

705

ctrl->dte.base = vtophys(amdvi_dte) / PAGE_SIZE;

sys/amd64/vmm/amd/amdvi_priv.h

255

#define AMDVI_MMIO_V1_SIZE (4 * PAGE_SIZE) /* v1 size */

sys/amd64/vmm/amd/amdvi_priv.h

259

#define AMDVI_MMIO_V2_SIZE (8 * PAGE_SIZE)

sys/amd64/vmm/amd/svm.c

172

kmem_free(hsave, (mp_maxid + 1) * PAGE_SIZE);

sys/amd64/vmm/amd/svm.c

221

wrmsr(MSR_VM_HSAVE_PA, vtophys(&hsave[curcpu * PAGE_SIZE]));

sys/amd64/vmm/amd/svm.c

2598

vlapic->apic_page = malloc_aligned(PAGE_SIZE, PAGE_SIZE, M_SVM_VLAPIC,

sys/amd64/vmm/amd/svm.c

276

hsave = kmem_malloc((mp_maxid + 1) * PAGE_SIZE, M_WAITOK | M_ZERO);

sys/amd64/vmm/amd/svm.c

598

M_WAITOK, 0, ~(vm_paddr_t)0, PAGE_SIZE, 0);

sys/amd64/vmm/amd/svm.c

602

M_WAITOK, 0, ~(vm_paddr_t)0, PAGE_SIZE, 0);

sys/amd64/vmm/amd/svm.c

655

vcpu->vmcb = malloc_aligned(sizeof(struct vmcb), PAGE_SIZE, M_SVM,

sys/amd64/vmm/amd/svm_softc.h

34

#define SVM_IO_BITMAP_SIZE (3 * PAGE_SIZE)

sys/amd64/vmm/amd/svm_softc.h

35

#define SVM_MSR_BITMAP_SIZE (2 * PAGE_SIZE)

sys/amd64/vmm/amd/vmcb.h

352

CTASSERT(sizeof(struct vmcb) == PAGE_SIZE);

sys/amd64/vmm/intel/vmcs.h

39

char _impl_specific[PAGE_SIZE - sizeof(uint32_t) * 2];

sys/amd64/vmm/intel/vmcs.h

41

CTASSERT(sizeof(struct vmcs) == PAGE_SIZE);

sys/amd64/vmm/intel/vmx.c

1077

vmx->msr_bitmap = malloc_aligned(PAGE_SIZE, PAGE_SIZE, M_VMX,

sys/amd64/vmm/intel/vmx.c

1121

error = vm_map_mmio(vm, DEFAULT_APIC_BASE, PAGE_SIZE,

sys/amd64/vmm/intel/vmx.c

1147

vcpu->vmcs = malloc_aligned(sizeof(*vmcs), PAGE_SIZE, M_VMX,

sys/amd64/vmm/intel/vmx.c

1149

vcpu->apic_page = malloc_aligned(PAGE_SIZE, PAGE_SIZE, M_VMX,

sys/amd64/vmm/intel/vmx.c

2249

(gpa >= DEFAULT_APIC_BASE && gpa < DEFAULT_APIC_BASE + PAGE_SIZE))

sys/amd64/vmm/intel/vmx.c

3262

vm_unmap_mmio(vmx->vm, DEFAULT_APIC_BASE, PAGE_SIZE);

sys/amd64/vmm/intel/vmx.c

3977

error = vm_unmap_mmio(vmx->vm, DEFAULT_APIC_BASE, PAGE_SIZE);

sys/amd64/vmm/intel/vmx.c

626

kmem_free(vmxon_region, (mp_maxid + 1) * PAGE_SIZE);

sys/amd64/vmm/intel/vmx.c

647

*(uint32_t *)&vmxon_region[curcpu * PAGE_SIZE] = vmx_revision();

sys/amd64/vmm/intel/vmx.c

648

error = vmxon(&vmxon_region[curcpu * PAGE_SIZE]);

sys/amd64/vmm/intel/vmx.c

989

vmxon_region = kmem_malloc((mp_maxid + 1) * PAGE_SIZE,

sys/amd64/vmm/intel/vmx.h

103

uint32_t reg[PAGE_SIZE / 4];

sys/amd64/vmm/intel/vmx.h

105

CTASSERT(sizeof(struct apic_page) == PAGE_SIZE);

sys/amd64/vmm/intel/vmx_genassym.c

83

ASSYM(PAGE_SIZE, PAGE_SIZE);

sys/amd64/vmm/intel/vmx_msr.c

139

memset(bitmap, 0xff, PAGE_SIZE);

sys/amd64/vmm/intel/vtd.c

122

static uint64_t root_table[PAGE_SIZE / sizeof(uint64_t)] __aligned(4096);

sys/amd64/vmm/intel/vtd.c

123

static uint64_t ctx_tables[256][PAGE_SIZE / sizeof(uint64_t)] __aligned(4096);

sys/amd64/vmm/intel/vtd.c

580

void *nlp = malloc(PAGE_SIZE, M_VTD, M_WAITOK | M_ZERO);

sys/amd64/vmm/intel/vtd.c

702

dom->ptp = malloc(PAGE_SIZE, M_VTD, M_ZERO | M_WAITOK);

sys/amd64/vmm/intel/vtd.c

751

bzero(ptp, PAGE_SIZE);

sys/amd64/vmm/io/ppt.c

522

if (len % PAGE_SIZE != 0 || len == 0 || gpa % PAGE_SIZE != 0 ||

sys/amd64/vmm/io/ppt.c

523

hpa % PAGE_SIZE != 0 || gpa + len < gpa || hpa + len < hpa)

sys/amd64/vmm/io/vlapic.c

1463

KASSERT((offset & 0xf) == 0 && offset < PAGE_SIZE,

sys/amd64/vmm/io/vlapic.c

1861

SNAPSHOT_BUF_OR_LEAVE(lapic, PAGE_SIZE, meta, ret, done);

sys/amd64/vmm/vmm.c

1857

n = min(remaining, PAGE_SIZE - off);

sys/amd64/vmm/vmm.c

1927

vmm_stat_set(vcpu, VMM_MEM_RESIDENT, PAGE_SIZE *

sys/amd64/vmm/vmm.c

1937

vmm_stat_set(vcpu, VMM_MEM_WIRED, PAGE_SIZE *

sys/amd64/vmm/vmm.c

490

for (gpa = mm->gpa; gpa < mm->gpa + mm->len; gpa += PAGE_SIZE) {

sys/amd64/vmm/vmm.c

509

iommu_create_mapping(vm->iommu, gpa, hpa, PAGE_SIZE);

sys/amd64/vmm/vmm.c

538

for (gpa = mm->gpa; gpa < mm->gpa + mm->len; gpa += PAGE_SIZE) {

sys/amd64/vmm/vmm.c

543

iommu_remove_mapping(vm->iommu, gpa, PAGE_SIZE);

sys/amd64/vmm/vmm.c

936

if (gpa >= DEFAULT_APIC_BASE && gpa < DEFAULT_APIC_BASE + PAGE_SIZE) {

sys/amd64/vmm/vmm_dev_machdep.c

392

kernemu->gpa < DEFAULT_APIC_BASE + PAGE_SIZE) {

sys/amd64/vmm/vmm_instruction_emul.c

2108

ptpbase32 = ptp_hold(vcpu, ptpphys, PAGE_SIZE,

sys/amd64/vmm/vmm_instruction_emul.c

2200

ptpbase = ptp_hold(vcpu, ptpphys, PAGE_SIZE, &cookie);

sys/arm/allwinner/aw_mmc.c

77

#define AW_MMC_DMA_SEGS (PAGE_SIZE / sizeof(struct aw_mmc_dma_desc))

sys/arm/arm/busdma_machdep.c

1001

sgsize = MIN(buflen, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/arm/arm/busdma_machdep.c

1132

len = min(PAGE_SIZE - offset, size);

sys/arm/arm/busdma_machdep.c

322

dmat->alignment <= PAGE_SIZE,

sys/arm/arm/busdma_machdep.c

396

newtag->lowaddr = trunc_page((vm_paddr_t)lowaddr) + (PAGE_SIZE - 1);

sys/arm/arm/busdma_machdep.c

398

(PAGE_SIZE - 1);

sys/arm/arm/busdma_machdep.c

443

maxsize = roundup2(maxsize, PAGE_SIZE) + PAGE_SIZE;

sys/arm/arm/busdma_machdep.c

547

pages = atop(roundup2(dmat->maxsize, PAGE_SIZE)) + 1;

sys/arm/arm/busdma_machdep.c

721

howmany(dmat->maxsize, MIN(dmat->maxsegsz, PAGE_SIZE)) &&

sys/arm/arm/busdma_machdep.c

722

dmat->alignment <= PAGE_SIZE &&

sys/arm/arm/busdma_machdep.c

723

(dmat->boundary % PAGE_SIZE) == 0) {

sys/arm/arm/busdma_machdep.c

802

PAGE_SIZE - (curaddr & PAGE_MASK));

sys/arm/arm/busdma_machdep.c

835

(PAGE_SIZE - ((vm_offset_t)vaddr & PAGE_MASK)));

sys/arm/arm/busdma_machdep.c

889

sgsize = MIN(sgsize, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/arm/arm/dump_machdep.c

73

a = pa + i * PAGE_SIZE;

sys/arm/arm/dump_machdep.c

95

phdr.p_align = PAGE_SIZE;

sys/arm/arm/elf_machdep.c

94

.sv_shared_page_len = PAGE_SIZE,

sys/arm/arm/genassym.c

112

ASSYM(PAGE_SIZE, PAGE_SIZE);

sys/arm/arm/gic_acpi.c

290

msi->BaseAddress, msi->BaseAddress + PAGE_SIZE - 1,

sys/arm/arm/gic_acpi.c

291

PAGE_SIZE);

sys/arm/arm/machdep.c

382

thread0.td_kstack_pages * PAGE_SIZE) - 1;

sys/arm/arm/machdep.c

397

irqstack + ((IRQ_STACK_SIZE * PAGE_SIZE) * (cpu + 1)));

sys/arm/arm/machdep.c

399

abtstack + ((ABT_STACK_SIZE * PAGE_SIZE) * (cpu + 1)));

sys/arm/arm/machdep.c

401

undstack + ((UND_STACK_SIZE * PAGE_SIZE) * (cpu + 1)));

sys/arm/arm/machdep.c

539

dpcpu = pmap_preboot_get_vpages(DPCPU_SIZE / PAGE_SIZE);

sys/arm/arm/machdep.c

550

round_page(msgbufsize) / PAGE_SIZE);

sys/arm/arm/mem.c

117

pmap_kenter((vm_offset_t)_tmppt, PAGE_SIZE, v,

sys/arm/arm/mem.c

120

c = (u_int)(PAGE_SIZE - ((int)iov->iov_base & PAGE_MASK));

sys/arm/arm/mem.c

121

c = min(c, (u_int)(PAGE_SIZE - o));

sys/arm/arm/mem.c

139

for (; addr < eaddr; addr += PAGE_SIZE)

sys/arm/arm/minidump_machdep.c

122

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

sys/arm/arm/minidump_machdep.c

147

static char dumpbuf[PAGE_SIZE] __aligned(sizeof(uint64_t));

sys/arm/arm/minidump_machdep.c

181

for (va = KERNBASE; va < kva_end; va += PAGE_SIZE) {

sys/arm/arm/minidump_machdep.c

197

dumpsize += PAGE_SIZE;

sys/arm/arm/minidump_machdep.c

201

dumpsize += PAGE_SIZE;

sys/arm/arm/minidump_machdep.c

231

error = blk_write(di, dumpbuf, 0, PAGE_SIZE);

sys/arm/arm/minidump_machdep.c

249

error = blk_write(di, dumpbuf, 0, PAGE_SIZE);

sys/arm/arm/minidump_machdep.c

261

for (va = KERNBASE; va < kva_end; va += PAGE_SIZE) {

sys/arm/arm/minidump_machdep.c

283

if (pa == (prev_pa + count * PAGE_SIZE))

sys/arm/arm/minidump_machdep.c

287

count * PAGE_SIZE);

sys/arm/arm/minidump_machdep.c

296

error = blk_write(di, NULL, prev_pa, count * PAGE_SIZE);

sys/arm/arm/minidump_machdep.c

83

maxdumpsz = min(di->maxiosize, MAXDUMPPGS * PAGE_SIZE);

sys/arm/arm/minidump_machdep.c

85

maxdumpsz = PAGE_SIZE;

sys/arm/arm/minidump_machdep.c

92

if ((sz % PAGE_SIZE) != 0) {

sys/arm/arm/pmap-v6.c

1009

virtual_avail += num * PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1015

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1035

virtual_avail += num * PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1039

bzero((void *)va, num * PAGE_SIZE);

sys/arm/arm/pmap-v6.c

1074

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1075

pa += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1076

num -= PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1264

pages = kva_alloc(PAGE_SIZE * 3);

sys/arm/arm/pmap-v6.c

1268

pc->pc_cmap2_pte2p = pt2map_entry(pages + PAGE_SIZE);

sys/arm/arm/pmap-v6.c

1269

pc->pc_qmap_pte2p = pt2map_entry(pages + (PAGE_SIZE * 2));

sys/arm/arm/pmap-v6.c

1271

pc->pc_cmap2_addr = (caddr_t)(pages + PAGE_SIZE);

sys/arm/arm/pmap-v6.c

1272

pc->pc_qmap_addr = pages + (PAGE_SIZE * 2);

sys/arm/arm/pmap-v6.c

1322

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1323

pa += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1324

size -= PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1452

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1453

start += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1472

va = (vm_offset_t)crashdumpmap + (i * PAGE_SIZE);

sys/arm/arm/pmap-v6.c

1473

pmap_kenter_noflush(va, PAGE_SIZE, pa, VM_MEMATTR_DEFAULT);

sys/arm/arm/pmap-v6.c

1551

va = (vm_offset_t)base + i * PAGE_SIZE;

sys/arm/arm/pmap-v6.c

1651

bzero(page, PAGE_SIZE);

sys/arm/arm/pmap-v6.c

1682

pte2_sync_range((pt2_entry_t *)pc->pc_cmap2_addr, PAGE_SIZE);

sys/arm/arm/pmap-v6.c

1793

pv_npg = (pte1_trunc(vm_phys_segs[vm_phys_nsegs - 1].end - PAGE_SIZE)

sys/arm/arm/pmap-v6.c

1806

pv_chunkbase = (struct pv_chunk *)kva_alloc(PAGE_SIZE * pv_maxchunks);

sys/arm/arm/pmap-v6.c

1845

tlb_flush_range(sva, count * PAGE_SIZE);

sys/arm/arm/pmap-v6.c

1861

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

3181

va_last = va + PTE1_SIZE - PAGE_SIZE;

sys/arm/arm/pmap-v6.c

3186

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

3218

va_last = va + PTE1_SIZE - PAGE_SIZE;

sys/arm/arm/pmap-v6.c

3221

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

3647

pmap->pm_stats.wired_count -= PTE1_SIZE / PAGE_SIZE;

sys/arm/arm/pmap-v6.c

3648

pmap->pm_stats.resident_count -= PTE1_SIZE / PAGE_SIZE;

sys/arm/arm/pmap-v6.c

3654

va < eva; va += PAGE_SIZE, m++) {

sys/arm/arm/pmap-v6.c

4060

cache_icache_sync_fresh(va, pa, PAGE_SIZE);

sys/arm/arm/pmap-v6.c

4196

if (sva + PAGE_SIZE == eva) {

sys/arm/arm/pmap-v6.c

4256

pte2p++, sva += PAGE_SIZE) {

sys/arm/arm/pmap-v6.c

4367

for (mt = m; mt < &m[PTE1_SIZE / PAGE_SIZE]; mt++)

sys/arm/arm/pmap-v6.c

4371

pmap->pm_stats.resident_count -= PTE1_SIZE / PAGE_SIZE;

sys/arm/arm/pmap-v6.c

4375

for (mt = m; mt < &m[PTE1_SIZE / PAGE_SIZE]; mt++)

sys/arm/arm/pmap-v6.c

4665

cache_icache_sync_fresh(va, pa, PAGE_SIZE);

sys/arm/arm/pmap-v6.c

4751

cur != end; cur += PAGE_SIZE, pte2p++) {

sys/arm/arm/pmap-v6.c

4772

for (mt = m; mt < &m[PTE1_SIZE / PAGE_SIZE]; mt++)

sys/arm/arm/pmap-v6.c

4781

pmap->pm_stats.wired_count += PTE1_SIZE / PAGE_SIZE;

sys/arm/arm/pmap-v6.c

4782

pmap->pm_stats.resident_count += PTE1_SIZE / PAGE_SIZE;

sys/arm/arm/pmap-v6.c

4840

m = vm_radix_iter_jump(&pages, NBPDR / PAGE_SIZE);

sys/arm/arm/pmap-v6.c

4892

for (pa = pte2_pa + PAGE_SIZE; pa < pte2_pa + size;

sys/arm/arm/pmap-v6.c

4893

pa += PAGE_SIZE) {

sys/arm/arm/pmap-v6.c

4917

PAGE_SIZE;

sys/arm/arm/pmap-v6.c

4946

va < eva; va += PAGE_SIZE, m++)

sys/arm/arm/pmap-v6.c

5061

sva += PAGE_SIZE) {

sys/arm/arm/pmap-v6.c

5474

PAGE_SIZE;

sys/arm/arm/pmap-v6.c

5509

sva += PAGE_SIZE) {

sys/arm/arm/pmap-v6.c

560

CTASSERT(PAGE_SIZE == PTE2_SIZE);

sys/arm/arm/pmap-v6.c

5656

sva += PAGE_SIZE) {

sys/arm/arm/pmap-v6.c

575

CTASSERT(PAGE_SIZE == (NPT2_IN_PG * NB_IN_PT2));

sys/arm/arm/pmap-v6.c

5796

dcache_wbinv_poc((vm_offset_t)pc->pc_cmap2_addr, pa, PAGE_SIZE);

sys/arm/arm/pmap-v6.c

5915

if (off == 0 && size == PAGE_SIZE)

sys/arm/arm/pmap-v6.c

5950

bcopy(pc->pc_cmap1_addr, pc->pc_cmap2_addr, PAGE_SIZE);

sys/arm/arm/pmap-v6.c

596

#define NPG_IN_PT2TAB (NB_IN_PT2TAB / PAGE_SIZE)

sys/arm/arm/pmap-v6.c

5984

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/arm/arm/pmap-v6.c

5987

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/arm/arm/pmap-v6.c

605

CTASSERT(NB_IN_PT2TAB == (NPG_IN_PT2TAB * PAGE_SIZE));

sys/arm/arm/pmap-v6.c

6100

PTE1_SIZE / PAGE_SIZE;

sys/arm/arm/pmap-v6.c

6164

addr += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

6302

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

6303

size -= PAGE_SIZE;

sys/arm/arm/pmap-v6.c

6325

KASSERT(((pa & PAGE_MASK) + size) <= PAGE_SIZE,

sys/arm/arm/pmap-v6.c

6354

len = min(PAGE_SIZE - offset, size);

sys/arm/arm/pmap-v6.c

6382

len = min(PAGE_SIZE - offset, size);

sys/arm/arm/pmap-v6.c

6635

end = (uint32_t*)(pc->pc_cmap2_addr + PAGE_SIZE);

sys/arm/arm/pmap-v6.c

6790

for (i = 0; i < NPTE2_IN_PT2; i++, pte2p++, va += PAGE_SIZE) {

sys/arm/arm/pmap-v6.c

6818

(va < ((vm_offset_t)pv_chunkbase + PAGE_SIZE * pv_maxchunks)))

sys/arm/arm/pmap-v6.c

736

last_paddr += num * PAGE_SIZE;

sys/arm/arm/pmap-v6.c

811

size = NKPT2PG * PAGE_SIZE;

sys/arm/arm/pmap-v6.c

900

virtual_avail = (vm_offset_t)kern_pt2tab + NPG_IN_PT2TAB * PAGE_SIZE;

sys/arm/arm/pmap-v6.c

937

bzero((void*)pt2map_pt2pg(va), PAGE_SIZE);

sys/arm/arm/pmap-v6.c

938

pte2_sync_range((pt2_entry_t *)pt2map_pt2pg(va), PAGE_SIZE);

sys/arm/arm/pmap-v6.c

992

va += PAGE_SIZE;

sys/arm/arm/pmap-v6.c

993

pa += PAGE_SIZE;

sys/arm/arm/sys_machdep.c

75

size = PAGE_SIZE - (addr & PAGE_MASK);

sys/arm/arm/uio_machdep.c

91

cnt = min(cnt, PAGE_SIZE - page_offset);

sys/arm/arm/vm_machdep.c

102

(td2->td_kstack + td2->td_kstack_pages * PAGE_SIZE) - 1;

sys/arm/arm/vm_machdep.c

249

PAGE_SIZE) - 1;

sys/arm/broadcom/bcm2835/bcm2835_mbox.c

571

msg.buffer.body.req.alignment = PAGE_SIZE;

sys/arm/broadcom/bcm2835/bcm2835_sdhci.c

78

((((NUM_DMA_SEGS * BCM_SDHCI_BUFFER_SIZE) - 1) / PAGE_SIZE) + 1)

sys/arm/broadcom/bcm2835/raspberrypi_virtgpio.c

268

PAGE_SIZE, /* size */

sys/arm/broadcom/bcm2835/raspberrypi_virtgpio.c

271

PAGE_SIZE, 0); /* alignment, boundary */

sys/arm/broadcom/bcm2835/raspberrypi_virtgpio.c

278

pmap_change_attr((vm_offset_t)sc->vaddr, PAGE_SIZE,

sys/arm/freescale/imx/imx6_sdma.c

185

channel->bd = kmem_alloc_contig(PAGE_SIZE, M_ZERO, 0, ~0,

sys/arm/freescale/imx/imx6_sdma.c

186

PAGE_SIZE, 0, VM_MEMATTR_UNCACHEABLE);

sys/arm/freescale/imx/imx6_sdma.c

202

kmem_free(channel->bd, PAGE_SIZE);

sys/arm/freescale/imx/imx6_sdma.c

396

sc->ccb = kmem_alloc_contig(sz, M_ZERO, 0, ~0, PAGE_SIZE, 0,

sys/arm/freescale/imx/imx6_sdma.c

415

sc->bd0 = kmem_alloc_contig(PAGE_SIZE, M_ZERO, 0, ~0, PAGE_SIZE,

sys/arm/freescale/imx/imx6_sdma.c

60

#define MAX_BD (PAGE_SIZE / sizeof(struct sdma_buffer_descriptor))

sys/arm/freescale/vybrid/vf_dcu4.c

416

M_DEVBUF, M_ZERO, 0, ~0, PAGE_SIZE, 0);

sys/arm/include/cpu.h

357

for (; va < eva; va += PAGE_SIZE)

sys/arm/include/cpu.h

415

for (; va < eva; va += PAGE_SIZE)

sys/arm/include/cpu.h

419

for (; va < eva; va += PAGE_SIZE)

sys/arm/include/param.h

118

#define USPACE_SVC_STACK_TOP (kstack_pages * PAGE_SIZE)

sys/arm/include/param.h

97

#define PAGE_MASK (PAGE_SIZE - 1)

sys/arm/include/pcpu_aux.h

46

_Static_assert(PAGE_SIZE % sizeof(struct pcpu) == 0, "fix pcpu size");

sys/arm/include/pmap_var.h

39

#define NPG_IN_PT1 (NB_IN_PT1 / PAGE_SIZE)

sys/arm/include/pmap_var.h

42

#define NPT2_IN_PG (PAGE_SIZE / NB_IN_PT2)

sys/arm/include/stack.h

71

(total) = td->td_kstack_pages * PAGE_SIZE - sizeof(struct pcb); \

sys/arm/include/stack.h

79

va + len <= td->td_kstack + td->td_kstack_pages * PAGE_SIZE -

sys/arm/include/vmparam.h

137

#define SHAREDPAGE (VM_MAXUSER_ADDRESS - PAGE_SIZE)

sys/arm/mv/armadaxp/armadaxp_mp.c

118

dst = pmap_mapdev(0xffff0000, PAGE_SIZE);

sys/arm/mv/armadaxp/armadaxp_mp.c

123

pmap_unmapdev(dst, PAGE_SIZE);

sys/arm/nvidia/drm2/tegra_bo.c

186

rv = tegra_bo_alloc_contig(bo->npages, PAGE_SIZE,

sys/arm/nvidia/drm2/tegra_dc.c

1229

M_WAITOK | M_ZERO, 0, -1UL, PAGE_SIZE, 0,

sys/arm/nvidia/tegra_pcie.c

1387

sc->msi_page = (uintptr_t)kmem_alloc_contig(PAGE_SIZE, M_WAITOK, 0,

sys/arm/nvidia/tegra_pcie.c

1388

BUS_SPACE_MAXADDR, PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);

sys/arm/nvidia/tegra_pcie.c

1392

PAGE_SIZE, 0);

sys/arm/nvidia/tegra_xhci.c

774

fw_vaddr = kmem_alloc_contig(fw_size, M_WAITOK, 0, -1UL, PAGE_SIZE, 0,

sys/arm/xilinx/zy7_devcfg.c

514

PAGE_SIZE,

sys/arm/xilinx/zy7_devcfg.c

516

PAGE_SIZE,

sys/arm/xilinx/zy7_devcfg.c

559

err = bus_dmamap_load(sc->dma_tag, sc->dma_map, dma_mem, PAGE_SIZE,

sys/arm/xilinx/zy7_devcfg.c

576

segsz = MIN(PAGE_SIZE, uio->uio_resid);

sys/arm64/arm64/busdma_bounce.c

151

maxsize = roundup2(dmat->common.maxsize, PAGE_SIZE) + PAGE_SIZE;

sys/arm64/arm64/busdma_bounce.c

436

pages = atop(roundup2(dmat->common.maxsize, PAGE_SIZE)) + 1;

sys/arm64/arm64/busdma_bounce.c

570

if (dmat->alloc_size <= PAGE_SIZE &&

sys/arm64/arm64/busdma_bounce.c

571

dmat->alloc_alignment <= PAGE_SIZE &&

sys/arm64/arm64/busdma_bounce.c

578

howmany(dmat->alloc_size, MIN(dmat->common.maxsegsz, PAGE_SIZE)) &&

sys/arm64/arm64/busdma_bounce.c

579

dmat->alloc_alignment <= PAGE_SIZE &&

sys/arm64/arm64/busdma_bounce.c

580

(dmat->common.boundary % PAGE_SIZE) == 0) {

sys/arm64/arm64/busdma_bounce.c

651

PAGE_SIZE - (curaddr & PAGE_MASK));

sys/arm64/arm64/busdma_bounce.c

702

PAGE_SIZE - ((vm_offset_t)vaddr & PAGE_MASK));

sys/arm64/arm64/busdma_bounce.c

759

KASSERT(dmat->common.alignment <= PAGE_SIZE,

sys/arm64/arm64/busdma_bounce.c

762

sgsize = MIN(sgsize, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/arm64/arm64/busdma_bounce.c

816

dmat->common.alignment <= PAGE_SIZE,

sys/arm64/arm64/busdma_bounce.c

863

sgsize = MIN(sgsize, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/arm64/arm64/busdma_bounce.c

868

KASSERT(dmat->common.alignment <= PAGE_SIZE,

sys/arm64/arm64/busdma_bounce.c

981

len = min(PAGE_SIZE - offset, size);

sys/arm64/arm64/busdma_machdep.c

82

common->lowaddr = trunc_page((vm_paddr_t)lowaddr) + (PAGE_SIZE - 1);

sys/arm64/arm64/busdma_machdep.c

83

common->highaddr = trunc_page((vm_paddr_t)highaddr) + (PAGE_SIZE - 1);

sys/arm64/arm64/efirt_machdep.c

232

idx += (PAGE_SIZE / EFI_PAGE_SIZE), va += PAGE_SIZE) {

sys/arm64/arm64/elf32_machdep.c

131

.sv_shared_page_len = PAGE_SIZE,

sys/arm64/arm64/elf32_machdep.c

62

#define FREEBSD32_MAXUSER ((1ul << 32) - PAGE_SIZE)

sys/arm64/arm64/elf32_machdep.c

63

#define FREEBSD32_SHAREDPAGE (FREEBSD32_MAXUSER - PAGE_SIZE)

sys/arm64/arm64/elf_machdep.c

108

.sv_shared_page_len = PAGE_SIZE,

sys/arm64/arm64/gicv3_its.c

1080

GITS_TRANSLATER, PAGE_SIZE);

sys/arm64/arm64/gicv3_its.c

1864

error = iommu_map_msi(ctx, PAGE_SIZE, 0,

sys/arm64/arm64/gicv3_its.c

649

npages = howmany(its_tbl_size, PAGE_SIZE);

sys/arm64/arm64/gicv3_its.c

652

table = contigmalloc_domainset(npages * PAGE_SIZE,

sys/arm64/arm64/kexec_support.c

118

to_pa += PAGE_SIZE;

sys/arm64/arm64/kexec_support.c

121

for (size = PAGE_SIZE / sizeof(register_t);

sys/arm64/arm64/locore.S

1124

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/arm64/locore.S

1126

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/arm64/locore.S

585

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/arm64/locore.S

588

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/arm64/locore.S

59

#if PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/arm64/locore.S

65

#elif PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/arm64/locore.S

659

#if PAGE_SIZE != PAGE_SIZE_4K

sys/arm64/arm64/locore.S

679

#if PAGE_SIZE != PAGE_SIZE_4K

sys/arm64/arm64/locore.S

687

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/arm64/locore.S

731

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/arm64/locore.S

749

#if PAGE_SIZE != PAGE_SIZE_4K

sys/arm64/arm64/machdep.c

279

(uintmax_t)size, (uintmax_t)size / PAGE_SIZE);

sys/arm64/arm64/machdep.c

445

thread0.td_kstack_pages * PAGE_SIZE) - 1;

sys/arm64/arm64/mem.c

70

cnt = ulmin(iov->iov_len, PAGE_SIZE - (u_int)off);

sys/arm64/arm64/minidump_machdep.c

100

if ((((uintptr_t)pa) % PAGE_SIZE) != 0) {

sys/arm64/arm64/minidump_machdep.c

177

pmapsize += PAGE_SIZE;

sys/arm64/arm64/minidump_machdep.c

186

i++, pa += PAGE_SIZE)

sys/arm64/arm64/minidump_machdep.c

190

pmapsize += (Ln_ENTRIES - 1) * PAGE_SIZE;

sys/arm64/arm64/minidump_machdep.c

194

for (i = 0; i < Ln_ENTRIES; i++, pa += PAGE_SIZE) {

sys/arm64/arm64/minidump_machdep.c

221

dumpsize += PAGE_SIZE;

sys/arm64/arm64/minidump_machdep.c

225

dumpsize += PAGE_SIZE;

sys/arm64/arm64/minidump_machdep.c

241

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/arm64/minidump_machdep.c

243

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/arm64/minidump_machdep.c

262

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

276

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

291

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

313

j * PAGE_SIZE) | ATTR_AF |

sys/arm64/arm64/minidump_machdep.c

317

PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

332

tmpbuffer[i] = (pa + i * PAGE_SIZE) |

sys/arm64/arm64/minidump_machdep.c

335

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

352

error = blk_write(di, NULL, pa, PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

355

PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

363

error = blk_write(di, 0, pa, PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

88

maxdumpsz = min(di->maxiosize, MAXDUMPPGS * PAGE_SIZE);

sys/arm64/arm64/minidump_machdep.c

90

maxdumpsz = PAGE_SIZE;

sys/arm64/arm64/minidump_machdep.c

92

if ((sz % PAGE_SIZE) != 0) {

sys/arm64/arm64/mp_machdep.c

82

#define MP_BOOTSTACK_SIZE (kstack_pages * PAGE_SIZE)

sys/arm64/arm64/pmap.c

10092

sbuf_new_for_sysctl(sb, NULL, PAGE_SIZE, req);

sys/arm64/arm64/pmap.c

1021

memset_early(state->l1, 0, PAGE_SIZE);

sys/arm64/arm64/pmap.c

1022

state->freemempos += PAGE_SIZE;

sys/arm64/arm64/pmap.c

1069

memset_early(state->l2, 0, PAGE_SIZE);

sys/arm64/arm64/pmap.c

1070

state->freemempos += PAGE_SIZE;

sys/arm64/arm64/pmap.c

1113

memset_early(state->l3, 0, PAGE_SIZE);

sys/arm64/arm64/pmap.c

1114

state->freemempos += PAGE_SIZE;

sys/arm64/arm64/pmap.c

1245

bs_state.freemempos = roundup2(bs_state.freemempos, PAGE_SIZE);

sys/arm64/arm64/pmap.c

1411

bs_state.freemempos += (np * PAGE_SIZE); \

sys/arm64/arm64/pmap.c

1412

memset_early((char *)(var), 0, ((np) * PAGE_SIZE));

sys/arm64/arm64/pmap.c

1415

alloc_pages(dpcpu, DPCPU_SIZE / PAGE_SIZE);

sys/arm64/arm64/pmap.c

1419

alloc_pages(msgbufpv, round_page(msgbufsize) / PAGE_SIZE);

sys/arm64/arm64/pmap.c

1520

static uint8_t kmsan_shad_ptp[PAGE_SIZE * 2] __aligned(PAGE_SIZE);

sys/arm64/arm64/pmap.c

1521

static uint8_t kmsan_orig_ptp[PAGE_SIZE * 2] __aligned(PAGE_SIZE);

sys/arm64/arm64/pmap.c

1532

pmap_early_vtophys((vm_offset_t)kmsan_shad_ptp + PAGE_SIZE)));

sys/arm64/arm64/pmap.c

1540

pmap_early_vtophys((vm_offset_t)kmsan_orig_ptp + PAGE_SIZE)));

sys/arm64/arm64/pmap.c

1590

CTASSERT(PAGE_SIZE % sizeof(*pvd) == 0);

sys/arm64/arm64/pmap.c

1619

for (j = 0; j < s; j += PAGE_SIZE) {

sys/arm64/arm64/pmap.c

165

#define NL0PG (PAGE_SIZE/(sizeof (pd_entry_t)))

sys/arm64/arm64/pmap.c

166

#define NL1PG (PAGE_SIZE/(sizeof (pd_entry_t)))

sys/arm64/arm64/pmap.c

167

#define NL2PG (PAGE_SIZE/(sizeof (pd_entry_t)))

sys/arm64/arm64/pmap.c

168

#define NL3PG (PAGE_SIZE/(sizeof (pt_entry_t)))

sys/arm64/arm64/pmap.c

1946

pmap_stage2_invalidate_range(pmap_to_ttbr0(pmap), va, va + PAGE_SIZE,

sys/arm64/arm64/pmap.c

2386

PAGE_SIZE);

sys/arm64/arm64/pmap.c

2413

va += PAGE_SIZE;

sys/arm64/arm64/pmap.c

2414

pa += PAGE_SIZE;

sys/arm64/arm64/pmap.c

2415

size -= PAGE_SIZE;

sys/arm64/arm64/pmap.c

2510

va += PAGE_SIZE;

sys/arm64/arm64/pmap.c

2511

size -= PAGE_SIZE;

sys/arm64/arm64/pmap.c

2608

va += PAGE_SIZE;

sys/arm64/arm64/pmap.c

372

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/arm64/pmap.c

3778

va_last = va + L2_SIZE - PAGE_SIZE;

sys/arm64/arm64/pmap.c

3787

va += PAGE_SIZE;

sys/arm64/arm64/pmap.c

3969

pmap->pm_stats.wired_count -= L2_SIZE / PAGE_SIZE;

sys/arm64/arm64/pmap.c

3970

pmap_resident_count_dec(pmap, L2_SIZE / PAGE_SIZE);

sys/arm64/arm64/pmap.c

3976

for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++) {

sys/arm64/arm64/pmap.c

4296

pmap_resident_count_dec(pmap, L1_SIZE / PAGE_SIZE);

sys/arm64/arm64/pmap.c

4506

for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)

sys/arm64/arm64/pmap.c

4932

va_last = va + L2_SIZE - PAGE_SIZE;

sys/arm64/arm64/pmap.c

4935

va += PAGE_SIZE;

sys/arm64/arm64/pmap.c

5018

+ L2_SIZE - PAGE_SIZE;

sys/arm64/arm64/pmap.c

5047

pa -= PAGE_SIZE;

sys/arm64/arm64/pmap.c

5159

L3C_SIZE - PAGE_SIZE;

sys/arm64/arm64/pmap.c

5191

pa -= PAGE_SIZE;

sys/arm64/arm64/pmap.c

5336

pmap_resident_count_inc(pmap, pagesizes[psind] / PAGE_SIZE);

sys/arm64/arm64/pmap.c

5338

pmap->pm_stats.wired_count += pagesizes[psind] / PAGE_SIZE;

sys/arm64/arm64/pmap.c

5341

pmap->pm_stats.wired_count -= pagesizes[psind] / PAGE_SIZE;

sys/arm64/arm64/pmap.c

557

memcpy(d, s, PAGE_SIZE);

sys/arm64/arm64/pmap.c

5639

PAGE_SIZE);

sys/arm64/arm64/pmap.c

5642

cpu_dcache_wb_range((void *)PHYS_TO_DMAP(pa), PAGE_SIZE);

sys/arm64/arm64/pmap.c

5932

for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)

sys/arm64/arm64/pmap.c

5940

pmap->pm_stats.wired_count += L2_SIZE / PAGE_SIZE;

sys/arm64/arm64/pmap.c

5941

pmap->pm_stats.resident_count += L2_SIZE / PAGE_SIZE;

sys/arm64/arm64/pmap.c

6230

m = vm_radix_iter_jump(&pages, L2_SIZE / PAGE_SIZE);

sys/arm64/arm64/pmap.c

6404

cpu_icache_sync_range((void *)PHYS_TO_DMAP(pa), PAGE_SIZE);

sys/arm64/arm64/pmap.c

6498

pmap->pm_stats.wired_count -= L1_SIZE / PAGE_SIZE;

sys/arm64/arm64/pmap.c

6522

PAGE_SIZE;

sys/arm64/arm64/pmap.c

6691

pmap_resident_count_inc(dst_pmap, L1_SIZE / PAGE_SIZE);

sys/arm64/arm64/pmap.c

6730

PAGE_SIZE);

sys/arm64/arm64/pmap.c

6746

for (; addr < va_next; addr += PAGE_SIZE, src_pte++) {

sys/arm64/arm64/pmap.c

6771

addr += L3C_SIZE - PAGE_SIZE;

sys/arm64/arm64/pmap.c

6866

if (off == 0 && size == PAGE_SIZE)

sys/arm64/arm64/pmap.c

6906

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/arm64/arm64/pmap.c

6907

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/arm64/arm64/pmap.c

7194

for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)

sys/arm64/arm64/pmap.c

7208

L2_SIZE / PAGE_SIZE);

sys/arm64/arm64/pmap.c

7213

for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)

sys/arm64/arm64/pmap.c

7759

va -= PAGE_SIZE;

sys/arm64/arm64/pmap.c

7809

L3C_SIZE - PAGE_SIZE,

sys/arm64/arm64/pmap.c

7810

va_next - PAGE_SIZE);

sys/arm64/arm64/pmap.c

8168

pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,

sys/arm64/arm64/pmap.c

8298

tmpva += PAGE_SIZE;

sys/arm64/arm64/pmap.c

8359

pte_size = PAGE_SIZE;

sys/arm64/arm64/pmap.c

8385

PAGE_SIZE);

sys/arm64/arm64/pmap.c

8440

tmpl1 = kva_alloc(PAGE_SIZE);

sys/arm64/arm64/pmap.c

8472

pmap_kenter(tmpl1, PAGE_SIZE,

sys/arm64/arm64/pmap.c

8478

pmap_update_entry(pmap, l1, l2phys | L1_TABLE, va, PAGE_SIZE);

sys/arm64/arm64/pmap.c

8484

kva_free(tmpl1, PAGE_SIZE);

sys/arm64/arm64/pmap.c

8509

xl3p++, newl3e += PAGE_SIZE) {

sys/arm64/arm64/pmap.c

8570

tmpl2 = kva_alloc(PAGE_SIZE);

sys/arm64/arm64/pmap.c

8667

pmap_kenter(tmpl2, PAGE_SIZE,

sys/arm64/arm64/pmap.c

8688

pmap_update_entry(pmap, l2, l3phys | L2_TABLE, va, PAGE_SIZE);

sys/arm64/arm64/pmap.c

8703

kva_free(tmpl2, PAGE_SIZE);

sys/arm64/arm64/pmap.c

8741

tmpl3 = kva_alloc(PAGE_SIZE);

sys/arm64/arm64/pmap.c

8744

pmap_kenter(tmpl3, PAGE_SIZE,

sys/arm64/arm64/pmap.c

8805

kva_free(tmpl3, PAGE_SIZE);

sys/arm64/arm64/pmap.c

8830

tmpl3 = kva_alloc(PAGE_SIZE);

sys/arm64/arm64/pmap.c

8833

pmap_kenter(tmpl3, PAGE_SIZE,

sys/arm64/arm64/pmap.c

8894

kva_free(tmpl3, PAGE_SIZE);

sys/arm64/arm64/pmap.c

9314

len = imin(PAGE_SIZE - offset, sz);

sys/arm64/arm64/pmap.c

9327

len = imin(PAGE_SIZE, sz);

sys/arm64/arm64/pmap.c

9583

error = vmem_alloc(kernel_arena, PAGE_SIZE,

sys/arm64/arm64/pmap.c

9802

#define SAN_BOOTSTRAP_SIZE (2 * PAGE_SIZE)

sys/arm64/arm64/pmap.c

9826

static uint8_t bootstrap_data[SAN_BOOTSTRAP_SIZE] __aligned(PAGE_SIZE);

sys/arm64/arm64/pmap.c

9830

if (offset + (npages * PAGE_SIZE) > sizeof(bootstrap_data)) {

sys/arm64/arm64/pmap.c

9836

offset += (npages * PAGE_SIZE);

sys/arm64/arm64/uio_machdep.c

89

cnt = min(cnt, PAGE_SIZE - page_offset);

sys/arm64/arm64/vm_machdep.c

266

td->td_kstack_pages * PAGE_SIZE) - 1;

sys/arm64/arm64/vm_machdep.c

93

td2->td_kstack_pages * PAGE_SIZE) - 1;

sys/arm64/coresight/coresight_acpi.c

176

buf.Length = PAGE_SIZE;

sys/arm64/include/param.h

95

#define PAGE_MASK (PAGE_SIZE - 1)

sys/arm64/include/pcpu_aux.h

50

_Static_assert(PAGE_SIZE % sizeof(struct pcpu) == 0, "fix pcpu size");

sys/arm64/include/pte.h

166

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/include/pte.h

171

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/include/pte.h

216

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/include/pte.h

219

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/include/pte.h

237

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/include/pte.h

240

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/include/pte.h

87

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/include/pte.h

89

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/include/stack.h

46

(total) = td->td_kstack_pages * PAGE_SIZE - sizeof(struct pcb); \

sys/arm64/include/stack.h

54

va + len <= td->td_kstack + td->td_kstack_pages * PAGE_SIZE -

sys/arm64/include/vmparam.h

108

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/include/vmparam.h

110

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/include/vmparam.h

128

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/include/vmparam.h

135

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/include/vmparam.h

286

#define SHAREDPAGE (VM_MAXUSER_ADDRESS - PAGE_SIZE)

sys/arm64/intel/stratix10-svc.c

177

vmem = vmem_create("stratix10 vmem", 0, 0, PAGE_SIZE,

sys/arm64/intel/stratix10-svc.c

178

PAGE_SIZE, M_BESTFIT | M_WAITOK);

sys/arm64/iommu/smmu.c

1639

for (i = 0; i < size; i += PAGE_SIZE) {

sys/arm64/iommu/smmu.c

1647

va += PAGE_SIZE;

sys/arm64/iommu/smmu.c

1673

for (i = 0; size > 0; size -= PAGE_SIZE) {

sys/arm64/iommu/smmu.c

1679

va += PAGE_SIZE;

sys/arm64/linux/linux_sysvec.c

457

.sv_shared_page_len = PAGE_SIZE,

sys/arm64/linux/linux_sysvec.c

72

#define LINUX_VDSOPAGE_SIZE PAGE_SIZE * 2

sys/arm64/linux/linux_sysvec.c

75

#define LINUX_SHAREDPAGE (LINUX_VDSOPAGE - PAGE_SIZE)

sys/arm64/spe/arm_spe_backend.c

181

if (ctx->bufsize < (2 * PAGE_SIZE))

sys/arm64/vmm/vmm_arm64.c

1000

ptep = ptp_hold(hypctx->vcpu, pte_addr, PAGE_SIZE, &cookie);

sys/arm64/vmm/vmm_arm64.c

204

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/vmm/vmm_arm64.c

216

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/vmm/vmm_arm64.c

268

#if PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/vmm/vmm_arm64.c

298

el2_mem_alloc = vmem_create("VMM EL2", 0, 0, PAGE_SIZE, 0,

sys/arm64/vmm/vmm_arm64.c

319

PAGE_SIZE, vtophys(stack[cpu] + ptoa(i)),

sys/arm64/vmm/vmm_arm64.c

331

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/vmm/vmm_arm64.c

333

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/vmm/vmm_arm64.c

384

#if PAGE_SIZE == PAGE_SIZE_4K

sys/arm64/vmm/vmm_arm64.c

386

#elif PAGE_SIZE == PAGE_SIZE_16K

sys/arm64/vmm/vmm_arm64.c

413

if (vmm_base > (L2_SIZE + PAGE_SIZE)) {

sys/arm64/vmm/vmm_arm64.c

419

vmm_base -= L2_SIZE + PAGE_SIZE;

sys/arm64/vmm/vmm_arm64.c

438

if (next_hyp_va < HYP_VM_MAX_ADDRESS - PAGE_SIZE)

sys/arm64/vmm/vmm_arm64.c

459

VMM_STACK_PAGES * PAGE_SIZE, false);

sys/arm64/vmm/vmm_arm64.c

517

hyp = malloc_aligned(size, PAGE_SIZE, M_HYP, M_WAITOK | M_ZERO);

sys/arm64/vmm/vmm_arm64.c

560

hypctx = malloc_aligned(size, PAGE_SIZE, M_HYP, M_WAITOK | M_ZERO);

sys/arm64/vmm/vmm_arm64.c

81

#define VMM_STACK_SIZE (VMM_STACK_PAGES * PAGE_SIZE)

sys/arm64/vmm/vmm_arm64.c

995

while (idx > PAGE_SIZE / sizeof(pte)) {

sys/arm64/vmm/vmm_arm64.c

996

idx -= PAGE_SIZE / sizeof(pte);

sys/arm64/vmm/vmm_arm64.c

997

pte_addr += PAGE_SIZE;

sys/arm64/vmm/vmm_mmu.c

331

size -= PAGE_SIZE;

sys/arm64/vmm/vmm_mmu.c

332

pa += PAGE_SIZE;

sys/arm64/vmm/vmm_mmu.c

333

va += PAGE_SIZE;

sys/cam/ata/ata_da.c

2438

PAGE_SIZE == bp->bio_ma_n,

sys/cam/ctl/ctl_backend_ramdisk.c

1156

be_lun->pblocksize = PAGE_SIZE;

sys/cam/ctl/ctl_backend_ramdisk.c

234

*pp = malloc(PAGE_SIZE, M_RAMDISK,

sys/cam/ctl/ctl_backend_ramdisk.c

82

#define PPP (PAGE_SIZE / sizeof(uint8_t **))

sys/cam/ctl/ctl_backend_ramdisk.c

88

#define SGPP (PAGE_SIZE / sizeof(struct ctl_sg_entry))

sys/cam/nvme/nvme_da.c

1160

PAGE_SIZE == bp->bio_ma_n,

sys/cddl/dev/dtrace/powerpc/dtrace_isa.c

150

osp = PAGE_SIZE;

sys/cddl/dev/dtrace/powerpc/dtrace_isa.c

513

osp = PAGE_SIZE;

sys/cddl/dev/kinst/trampoline.c

38

#define KINST_TRAMPCHUNK_SIZE PAGE_SIZE

sys/compat/ia32/ia32_sysvec.c

136

.sv_shared_page_len = PAGE_SIZE,

sys/compat/lindebugfs/lindebugfs.c

722

if (new_len + 1 > PAGE_SIZE)

sys/compat/linprocfs/linprocfs.c

1386

PAGE_SIZE)

sys/compat/linprocfs/linprocfs.c

161

memtotal = physmem * PAGE_SIZE;

sys/compat/linprocfs/linprocfs.c

162

memfree = (unsigned long)vm_free_count() * PAGE_SIZE;

sys/compat/linprocfs/linprocfs.c

164

swaptotal = (unsigned long long)i * PAGE_SIZE;

sys/compat/linprocfs/linprocfs.c

165

swapused = (unsigned long long)j * PAGE_SIZE;

sys/compat/linprocfs/linprocfs.c

174

PAGE_SIZE;

sys/compat/linprocfs/linprocfs.c

792

total = (uintmax_t)xsw.xsw_nblks * PAGE_SIZE / 1024;

sys/compat/linprocfs/linprocfs.c

793

used = (uintmax_t)xsw.xsw_used * PAGE_SIZE / 1024;

sys/compat/linux/linux_fork.c

435

if (args->usize > PAGE_SIZE)

sys/compat/linux/linux_misc.c

155

sysinfo.totalram = physmem * PAGE_SIZE;

sys/compat/linux/linux_misc.c

156

sysinfo.freeram = (u_long)vm_free_count() * PAGE_SIZE;

sys/compat/linux/linux_misc.c

168

sysinfo.totalswap = i * PAGE_SIZE;

sys/compat/linux/linux_misc.c

169

sysinfo.freeswap = (i - j) * PAGE_SIZE;

sys/compat/linux/linux_misc.c

379

uap->flags, uap->fd, (uint64_t)(uint32_t)uap->pgoff * PAGE_SIZE));

sys/compat/linux/linux_mmap.c

56

#define GUARD_SIZE (4 * PAGE_SIZE)

sys/compat/linux/linux_vdso.c

70

pages = size / PAGE_SIZE;

sys/compat/linux/linux_vdso.c

81

pmap_qenter(addr + n * PAGE_SIZE, &m, 1);

sys/compat/linux/linux_vdso.c

95

pmap_qremove(va, size / PAGE_SIZE);

sys/compat/linuxkpi/common/include/linux/device.h

184

return snprintf(buf, PAGE_SIZE, "%s\n", cs->str);

sys/compat/linuxkpi/common/include/linux/highmem.h

146

KASSERT(offset + len <= PAGE_SIZE,

sys/compat/linuxkpi/common/include/linux/highmem.h

161

KASSERT(offset + len <= PAGE_SIZE,

sys/compat/linuxkpi/common/include/linux/mm.h

266

#define offset_in_page(off) ((unsigned long)(off) & (PAGE_SIZE - 1))

sys/compat/linuxkpi/common/include/linux/mm.h

432

#define PAGE_ALIGNED(p) __is_aligned(p, PAGE_SIZE)

sys/compat/linuxkpi/common/include/linux/mm.h

464

return (PAGE_SIZE);

sys/compat/linuxkpi/common/include/linux/mm.h

48

#define PAGE_ALIGN(x) ALIGN(x, PAGE_SIZE)

sys/compat/linuxkpi/common/include/linux/page.h

100

#define btoc(x) (((vm_offset_t)(x) + PAGE_SIZE - 1) >> PAGE_SHIFT)

sys/compat/linuxkpi/common/include/linux/page.h

102

#define round_page(x) ((((uintptr_t)(x)) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))

sys/compat/linuxkpi/common/include/linux/page.h

104

#define trunc_page(x) ((uintptr_t)(x) & ~(PAGE_SIZE - 1))

sys/compat/linuxkpi/common/include/linux/page.h

82

#define clear_page(page) memset(page, 0, PAGE_SIZE)

sys/compat/linuxkpi/common/include/linux/page.h

93

#define PAGE_MASK (~(PAGE_SIZE-1))

sys/compat/linuxkpi/common/include/linux/pfn.h

36

#define PFN_ALIGN(x) (((unsigned long)(x) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1))

sys/compat/linuxkpi/common/include/linux/pfn.h

37

#define PFN_UP(x) (((x) + PAGE_SIZE - 1) >> PAGE_SHIFT)

sys/compat/linuxkpi/common/include/linux/pfn_t.h

34

#define PFN_FLAGS_MASK (((u64)(PAGE_SIZE - 1)) << (64 - PAGE_SHIFT))

sys/compat/linuxkpi/common/include/linux/scatterlist.h

145

((uintptr_t)buf) & (PAGE_SIZE - 1));

sys/compat/linuxkpi/common/include/linux/scatterlist.h

368

len += PAGE_SIZE;

sys/compat/linuxkpi/common/include/linux/scatterlist.h

397

len += PAGE_SIZE;

sys/compat/linuxkpi/common/include/linux/scatterlist.h

480

pgcount = (sg->offset + sg->length + PAGE_SIZE - 1) >> PAGE_SHIFT;

sys/compat/linuxkpi/common/include/linux/scatterlist.h

489

pgcount = (sg->offset + sg->length + PAGE_SIZE - 1) >> PAGE_SHIFT;

sys/compat/linuxkpi/common/include/linux/scatterlist.h

78

#define SCATTERLIST_MAX_SEGMENT (-1U & ~(PAGE_SIZE - 1))

sys/compat/linuxkpi/common/include/linux/scatterlist.h

80

#define SG_MAX_SINGLE_ALLOC (PAGE_SIZE / sizeof(struct scatterlist))

sys/compat/linuxkpi/common/include/linux/sysfs.h

156

if (len >= PAGE_SIZE)

sys/compat/linuxkpi/common/include/linux/sysfs.h

157

len = PAGE_SIZE - 1;

sys/compat/linuxkpi/common/include/linux/sysfs.h

164

error = sysctl_handle_string(oidp, buf, PAGE_SIZE - 1, req);

sys/compat/linuxkpi/common/include/linux/sysfs.h

167

len = strlcat(buf, "\n", PAGE_SIZE);

sys/compat/linuxkpi/common/include/linux/sysfs.h

168

KASSERT(len < PAGE_SIZE, ("new attribute truncated"));

sys/compat/linuxkpi/common/include/linux/sysfs.h

278

kobj, attr, buf, req->oldidx, PAGE_SIZE);

sys/compat/linuxkpi/common/include/linux/sysfs.h

286

error = sysctl_handle_opaque(oidp, buf, PAGE_SIZE, req);

sys/compat/linuxkpi/common/include/linux/sysfs.h

516

i = vscnprintf(buf, PAGE_SIZE, fmt, args);

sys/compat/linuxkpi/common/include/linux/sysfs.h

528

if (!buf || offset_in_page(buf) || at < 0 || at >= PAGE_SIZE) {

sys/compat/linuxkpi/common/include/linux/sysfs.h

534

i = vscnprintf(buf + at, PAGE_SIZE - at, fmt, args);

sys/compat/linuxkpi/common/src/linux_compat.c

1299

vmap->vm_pgoff = *offset / PAGE_SIZE;

sys/compat/linuxkpi/common/src/linux_page.c

123

PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);

sys/compat/linuxkpi/common/src/linux_page.c

128

npages, 0, pmax, PAGE_SIZE, 0);

sys/compat/linuxkpi/common/src/linux_page.c

158

size_t size = ((size_t)PAGE_SIZE) << order;

sys/compat/linuxkpi/common/src/linux_page.c

215

size_t size = ((size_t)PAGE_SIZE) << order;

sys/compat/linuxkpi/common/src/linux_page.c

220

PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);

sys/compat/linuxkpi/common/src/linux_page.c

276

mp++, va += PAGE_SIZE, count++) {

sys/compat/linuxkpi/common/src/linux_page.c

421

size = count * PAGE_SIZE;

sys/compat/linuxkpi/common/src/linux_page.c

494

pmap_qremove((vm_offset_t)addr, vmmap->vm_size / PAGE_SIZE);

sys/compat/linuxkpi/common/src/linux_page.c

578

addr += PAGE_SIZE) {

sys/compat/linuxkpi/common/src/linux_page.c

721

KASSERT(fragsz <= PAGE_SIZE, ("%s: fragsz %zu > PAGE_SIZE not yet "

sys/compat/linuxkpi/common/src/linux_page.c

724

pages = alloc_pages(gfp, flsl(howmany(fragsz, PAGE_SIZE) - 1));

sys/compat/linuxkpi/common/src/linux_page.c

82

si->mem_unit = PAGE_SIZE;

sys/compat/linuxkpi/common/src/linux_pci.c

1782

align = PAGE_SIZE << get_order(size);

sys/compat/linuxkpi/common/src/linux_shmemfs.c

120

vm_pindex_t start = OFF_TO_IDX(lstart + PAGE_SIZE - 1);

sys/compat/linuxkpi/common/src/linux_skbuff.c

131

linux_check_m_flags(gfp) | M_ZERO, 0, high, PAGE_SIZE, 0);

sys/compat/linuxkpi/common/src/linux_slab.c

217

if (size <= PAGE_SIZE)

sys/compat/linuxkpi/common/src/linux_slab.c

223

0, -1UL, PAGE_SIZE, 0));

sys/compat/linuxkpi/common/src/linux_slab.c

234

if (_s <= PAGE_SIZE)

sys/compat/linuxkpi/common/src/linux_slab.c

238

0, -1UL, PAGE_SIZE, 0));

sys/compat/linuxkpi/common/src/linux_slab.c

264

if (size <= PAGE_SIZE)

sys/compat/x86bios/x86bios.c

125

PAGE_SIZE, 0);

sys/crypto/ccp/ccp_hardware.c

928

} SHA_H __aligned(PAGE_SIZE) = {

sys/crypto/ccp/ccp_hardware.c

988

CTASSERT(PAGE_SIZE - ((uintptr_t)&SHA_H % PAGE_SIZE) >= sizeof(SHA_H));

sys/ddb/db_ps.c

362

(void *)(td->td_kstack + td->td_kstack_pages * PAGE_SIZE - 1));

sys/ddb/db_sym.c

383

if (val < PAGE_SIZE) {

sys/dev/aac/aac.c

1823

if (sc->aac_max_fib_size > PAGE_SIZE)

sys/dev/aac/aac.c

1824

sc->aac_max_fib_size = PAGE_SIZE;

sys/dev/aac/aac.c

1825

sc->aac_max_fibs_alloc = PAGE_SIZE / sc->aac_max_fib_size;

sys/dev/aac/aac_pci.c

442

PAGE_SIZE, /* algnmnt */

sys/dev/aacraid/aacraid.c

1308

u_int32_t min_size = PAGE_SIZE, cur_size;

sys/dev/aacraid/aacraid.c

1337

for (i = min_size / PAGE_SIZE; i >= 1; --i) {

sys/dev/aacraid/aacraid.c

1341

if (sg[j].length % (i*PAGE_SIZE)) {

sys/dev/aacraid/aacraid.c

1345

nseg_new += (sg[j].length / (i*PAGE_SIZE));

sys/dev/aacraid/aacraid.c

1465

for (j = 0; j < raw->sge[i].length / (pages*PAGE_SIZE); ++j) {

sys/dev/aacraid/aacraid.c

1466

addr_low = raw->sge[i].addrLow + j * pages * PAGE_SIZE;

sys/dev/aacraid/aacraid.c

1471

sge[pos].length = pages * PAGE_SIZE;

sys/dev/aacraid/aacraid.c

1483

raw->sgeNominalSize = pages * PAGE_SIZE;

sys/dev/aacraid/aacraid.c

1714

if (maxsize > PAGE_SIZE) {

sys/dev/aacraid/aacraid.c

1715

sc->aac_max_fib_size -= (maxsize - PAGE_SIZE);

sys/dev/aacraid/aacraid.c

1716

maxsize = PAGE_SIZE;

sys/dev/aacraid/aacraid.c

1718

sc->aac_max_fibs_alloc = PAGE_SIZE / maxsize;

sys/dev/aacraid/aacraid_pci.c

230

PAGE_SIZE, 0, /* algnmnt, boundary */

sys/dev/aacraid/aacraid_var.h

476

#define AAC_MAXIO_SIZE(sc) MIN(((sc)->aac_max_sectors << 9) - PAGE_SIZE, \

sys/dev/adlink/adlink.c

179

o = PAGE_SIZE;

sys/dev/adlink/adlink.c

215

if (u % PAGE_SIZE)

sys/dev/adlink/adlink.c

224

if (u % PAGE_SIZE)

sys/dev/adlink/adlink.c

236

sc->p0->chunksize = 4 * PAGE_SIZE;

sys/dev/adlink/adlink.c

244

sizeof *sc->p0 > PAGE_SIZE)

sys/dev/adlink/adlink.c

246

sc->p0->o_ring = PAGE_SIZE;

sys/dev/adlink/adlink.c

260

PAGE_SIZE, 0);

sys/dev/adlink/adlink.c

408

sc->p0 = malloc(PAGE_SIZE, M_DEVBUF, M_WAITOK | M_ZERO);

sys/dev/agp/agp.c

1021

for (i = 0; i < size; i += PAGE_SIZE) {

sys/dev/agp/agp.c

1032

for (j = 0; j < PAGE_SIZE && i + j < size; j += AGP_PAGE_SIZE) {

sys/dev/agp/agp.c

156

M_NOWAIT | M_ZERO, 0, ~0, PAGE_SIZE, 0, VM_MEMATTR_WRITE_COMBINING);

sys/dev/agp/agp.c

563

for (i = 0; i < mem->am_size; i += PAGE_SIZE) {

sys/dev/agp/agp.c

592

for (i = 0; i < mem->am_size; i += PAGE_SIZE) {

sys/dev/agp/agp.c

601

for (j = 0; j < PAGE_SIZE && i + j < mem->am_size;

sys/dev/agp/agp.c

635

for (k = 0; k < mem->am_size; k += PAGE_SIZE) {

sys/dev/agp/agp.c

673

for (i = 0; i < mem->am_size; i += PAGE_SIZE) {

sys/dev/agp/agp_i810.c

1191

M_ZERO, 0, ~0, PAGE_SIZE, 0, VM_MEMATTR_WRITE_COMBINING);

sys/dev/agp/agp_i810.c

1734

0, 0, ~0, PAGE_SIZE, 0);

sys/dev/agp/agp_i810.c

2028

SYS_RES_MEMORY, sc->sc_flush_page_rid, start, end, PAGE_SIZE,

sys/dev/agp/agp_i810.c

2082

temp + PAGE_SIZE - 1);

sys/dev/agp/agp_i810.c

2139

temp + PAGE_SIZE - 1);

sys/dev/agp/agp_i810.c

2219

sg->sg_segs[i].ss_len = PAGE_SIZE;

sys/dev/agp/agp_nvidia.c

213

AGP_GET_APERTURE(dev)) / PAGE_SIZE;

sys/dev/agp/agp_nvidia.c

367

pages = sc->gatt->ag_entries * sizeof(u_int32_t) / PAGE_SIZE;

sys/dev/agp/agp_nvidia.c

369

(void)ag_virtual[i * PAGE_SIZE / sizeof(u_int32_t)];

sys/dev/agp/agp_nvidia.c

371

(void)ag_virtual[i * PAGE_SIZE / sizeof(u_int32_t)];

sys/dev/ahci/ahci.c

1129

AHCI_SG_ENTRIES * PAGE_SIZE, AHCI_SG_ENTRIES, AHCI_PRD_MAX,

sys/dev/aic7xxx/aic79xx.c

5180

while ((sg_list_size + sg_list_increment) <= PAGE_SIZE)

sys/dev/aic7xxx/aic79xx.c

5188

max_list_size = roundup(sg_list_increment, PAGE_SIZE);

sys/dev/aic7xxx/aic79xx.c

5189

if (max_list_size < 4 * PAGE_SIZE)

sys/dev/aic7xxx/aic79xx.c

5190

max_list_size = 4 * PAGE_SIZE;

sys/dev/aic7xxx/aic79xx.c

5194

&& (sg_list_size % PAGE_SIZE) != 0) {

sys/dev/aic7xxx/aic79xx.c

5199

new_mod = sg_list_size % PAGE_SIZE;

sys/dev/aic7xxx/aic79xx.c

5200

best_mod = best_list_size % PAGE_SIZE;

sys/dev/aic7xxx/aic79xx.c

5624

PAGE_SIZE, /*nsegments*/1,

sys/dev/aic7xxx/aic79xx.c

5657

PAGE_SIZE, /*nsegments*/1,

sys/dev/aic7xxx/aic79xx.c

6007

offset = (PAGE_SIZE / sizeof(*hscb)) - scb_data->scbs_left;

sys/dev/aic7xxx/aic79xx.c

6029

hscb_map->vaddr, PAGE_SIZE, ahd_dmamap_cb,

sys/dev/aic7xxx/aic79xx.c

6034

scb_data->scbs_left = PAGE_SIZE / sizeof(*hscb);

sys/dev/aic7xxx/aic79xx.c

6079

offset = PAGE_SIZE - (AHD_SENSE_BUFSIZE * scb_data->sense_left);

sys/dev/aic7xxx/aic79xx.c

6100

sense_map->vaddr, PAGE_SIZE, ahd_dmamap_cb,

sys/dev/aic7xxx/aic79xx.c

6105

scb_data->sense_left = PAGE_SIZE / AHD_SENSE_BUFSIZE;

sys/dev/aic7xxx/aic79xx.c

6292

/*maxsize*/(AHD_NSEG - 1) * PAGE_SIZE,

sys/dev/aic7xxx/aic7xxx.c

4381

PAGE_SIZE, /*nsegments*/1,

sys/dev/aic7xxx/aic7xxx.c

4502

sg_map->sg_vaddr, PAGE_SIZE, ahc_dmamap_cb,

sys/dev/aic7xxx/aic7xxx.c

4508

newcount = (PAGE_SIZE / (AHC_NSEG * sizeof(struct ahc_dma_seg)));

sys/dev/aic7xxx/aic7xxx.c

4857

/*maxsize*/(AHC_NSEG - 1) * PAGE_SIZE,

sys/dev/al_eth/al_eth.c

2333

PAGE_SIZE, /* maxsegsize */

sys/dev/al_eth/al_eth.c

558

uint32_t maxsize = ((size - 1)/PAGE_SIZE + 1) * PAGE_SIZE;

sys/dev/amd_ecc_inject/ecc_inject.c

188

memory = kmem_alloc_attr(PAGE_SIZE, M_WAITOK, 0, ~0,

sys/dev/amd_ecc_inject/ecc_inject.c

192

ecc_ei_inject_one(memory, PAGE_SIZE);

sys/dev/amd_ecc_inject/ecc_inject.c

197

kmem_free(memory, PAGE_SIZE);

sys/dev/aq/aq_main.c

275

.isc_q_align = PAGE_SIZE,

sys/dev/aq/aq_main.c

284

.isc_rx_maxsegsize = PAGE_SIZE,

sys/dev/aq/aq_main.c

299

.isc_nrxd_default = {PAGE_SIZE / sizeof(aq_txc_desc_t) * 4},

sys/dev/aq/aq_main.c

300

.isc_ntxd_default = {PAGE_SIZE / sizeof(aq_txc_desc_t) * 4},

sys/dev/aq/aq_ring.c

112

ring->index, PAGE_SIZE, MCLBYTES, ring->rx_max_frame_size);

sys/dev/arcmsr/arcmsr.c

4928

/*maxsize*/ ARCMSR_MAX_SG_ENTRIES * PAGE_SIZE * ARCMSR_MAX_FREESRB_NUM,

sys/dev/ata/ata-dma.c

100

if (bus_dma_tag_create(ch->dma.dmatag, PAGE_SIZE, 64 * 1024,

sys/dev/ata/ata-dma.c

167

if (bus_dma_tag_create(ch->dma.dmatag, PAGE_SIZE, PAGE_SIZE,

sys/dev/ata/ata-dma.c

169

NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE,

sys/dev/ata/ata-dma.c

56

#define MAXTABSZ PAGE_SIZE

sys/dev/ata/ata-dma.c

57

#define MAXWSPCSZ PAGE_SIZE*2

sys/dev/ata/ata-dma.c

87

ch->dma.max_iosize = (ATA_DMA_ENTRIES - 1) * PAGE_SIZE;

sys/dev/ata/ata-lowlevel.c

837

bio->bio_ma[moff / PAGE_SIZE]);

sys/dev/ata/ata-lowlevel.c

838

moff %= PAGE_SIZE;

sys/dev/ata/ata-lowlevel.c

839

size = min(size, PAGE_SIZE - moff);

sys/dev/ata/ata-lowlevel.c

923

bio->bio_ma[moff / PAGE_SIZE]);

sys/dev/ata/ata-lowlevel.c

924

moff %= PAGE_SIZE;

sys/dev/ata/ata-lowlevel.c

925

size = min(size, PAGE_SIZE - moff);

sys/dev/ath/if_ath_descdma.c

179

PAGE_SIZE, 0, /* alignment, bounds */

sys/dev/axgbe/if_axgbe_pci.c

249

.isc_q_align = PAGE_SIZE,

sys/dev/axgbe/if_axgbe_pci.c

251

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/axgbe/if_axgbe_pci.c

253

.isc_tso_maxsegsize = PAGE_SIZE,

sys/dev/axgbe/if_axgbe_pci.c

692

scctx->isc_tx_tso_segsize_max = PAGE_SIZE;

sys/dev/axgbe/xgbe-drv.c

127

rx_buf_size = min(max(rx_buf_size, XGBE_RX_MIN_BUF_SIZE), PAGE_SIZE);

sys/dev/bce/if_bcereg.h

6057

#define BCM_PAGE_SIZE PAGE_SIZE

sys/dev/bge/if_bge.c

2947

error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_STD_RX_RING_SZ,

sys/dev/bge/if_bge.c

2956

error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_RX_RTN_RING_SZ(sc),

sys/dev/bge/if_bge.c

2965

error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_TX_RING_SZ,

sys/dev/bge/if_bge.c

2985

error = bge_dma_ring_alloc(sc, PAGE_SIZE, sbsz,

sys/dev/bge/if_bge.c

2994

error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_STATS_SZ,

sys/dev/bge/if_bge.c

3004

error = bge_dma_ring_alloc(sc, PAGE_SIZE, BGE_JUMBO_RX_RING_SZ,

sys/dev/bge/if_bge.c

3101

NULL, MJUM9BYTES, BGE_NSEG_JUMBO, PAGE_SIZE,

sys/dev/bnxt/bnxt_en/bnxt_hwrm.c

116

rc = iflib_dma_alloc(softc->ctx, PAGE_SIZE, &softc->hwrm_cmd_resp,

sys/dev/bnxt/bnxt_en/bnxt_hwrm.c

1327

1024, PAGE_SIZE);

sys/dev/bnxt/bnxt_en/bnxt_hwrm.c

156

memset(resp, 0, PAGE_SIZE);

sys/dev/bnxt/bnxt_en/if_bnxt.c

2624

softc->def_cp_ring.ring.ring_size = PAGE_SIZE /

sys/dev/bnxt/bnxt_en/if_bnxt.c

367

.isc_q_align = PAGE_SIZE,

sys/dev/bnxt/bnxt_en/if_bnxt.c

380

.isc_nrxd_default = {PAGE_SIZE / sizeof(struct cmpl_base) * 8,

sys/dev/bnxt/bnxt_en/if_bnxt.c

381

PAGE_SIZE / sizeof(struct rx_prod_pkt_bd),

sys/dev/bnxt/bnxt_en/if_bnxt.c

382

PAGE_SIZE / sizeof(struct rx_prod_pkt_bd)},

sys/dev/bnxt/bnxt_en/if_bnxt.c

385

.isc_ntxd_default = {PAGE_SIZE / sizeof(struct cmpl_base) * 2,

sys/dev/bnxt/bnxt_en/if_bnxt.c

386

PAGE_SIZE / sizeof(struct tx_bd_short),

sys/dev/bnxt/bnxt_en/if_bnxt.c

388

PAGE_SIZE / sizeof(struct cmpl_base) * 16},

sys/dev/bnxt/bnxt_re/ib_verbs.c

1323

srq->qplib_srq.sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

1926

qp->qplib_qp.sq.sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

1936

qp->qplib_qp.rq.sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

2009

rq->sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

2102

sq->sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

3435

wqe->frmr.pbl_pg_sz_log = ilog2(PAGE_SIZE >> PAGE_SHIFT_4K);

sys/dev/bnxt/bnxt_re/ib_verbs.c

3871

qplcq->sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

4150

cq->qplib_cq.sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

4887

mrinfo.sg.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

4889

mrinfo.sg.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

5381

resp.pg_size = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.c

5513

return rdma_user_mmap_io(&uctx->ibucontext, vma, pfn, PAGE_SIZE, vma->vm_page_prot, NULL);

sys/dev/bnxt/bnxt_re/ib_verbs.c

5546

rc = rdma_user_mmap_io(&uctx->ibucontext, vma, pfn, PAGE_SIZE, vma->vm_page_prot, NULL);

sys/dev/bnxt/bnxt_re/ib_verbs.c

5561

rc = rdma_user_mmap_io(&uctx->ibucontext, vma, pfn, PAGE_SIZE, vma->vm_page_prot, NULL);

sys/dev/bnxt/bnxt_re/ib_verbs.c

709

mrinfo.sg.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/ib_verbs.h

122

#define BNXT_RE_LEGACY_FENCE_PBL_SIZE DIV_ROUND_UP(BNXT_RE_LEGACY_FENCE_BYTES, PAGE_SIZE)

sys/dev/bnxt/bnxt_re/main.c

2021

return scnprintf(buf, PAGE_SIZE, "0x%x\n", rdev->en_dev->pdev->vendor);

sys/dev/bnxt/bnxt_re/main.c

2030

return scnprintf(buf, PAGE_SIZE, "%s\n", rdev->ibdev.node_desc);

sys/dev/bnxt/bnxt_re/main.c

2046

return scnprintf(buf, PAGE_SIZE, "%s\n", buffer);

sys/dev/bnxt/bnxt_re/main.c

3336

memset((u8 *)rdev->dbr_page, 0, PAGE_SIZE);

sys/dev/bnxt/bnxt_re/qplib_fp.c

1058

if (!IS_ALIGNED(fpsne, PAGE_SIZE))

sys/dev/bnxt/bnxt_re/qplib_fp.c

1199

BNXT_QPLIB_MAX_ORRQE_ENTRY_SIZE + PAGE_SIZE - 1;

sys/dev/bnxt/bnxt_re/qplib_fp.c

1200

req_size &= ~(PAGE_SIZE - 1);

sys/dev/bnxt/bnxt_re/qplib_fp.c

1220

BNXT_QPLIB_MAX_IRRQE_ENTRY_SIZE + PAGE_SIZE - 1;

sys/dev/bnxt/bnxt_re/qplib_fp.c

1221

req_size &= ~(PAGE_SIZE - 1);

sys/dev/bnxt/bnxt_re/qplib_fp.c

183

len = ALIGN((step * cnt), PAGE_SIZE);

sys/dev/bnxt/bnxt_re/qplib_fp.c

1927

pg_num = (tail + sq_hwq->pad_pgofft) / (PAGE_SIZE / sq_hwq->pad_stride);

sys/dev/bnxt/bnxt_re/qplib_fp.c

1928

pg_indx = (tail + sq_hwq->pad_pgofft) % (PAGE_SIZE / sq_hwq->pad_stride);

sys/dev/bnxt/bnxt_re/qplib_fp.c

600

sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_rcfw.c

1048

sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_rcfw.h

137

PAGE_SIZE) ? \

sys/dev/bnxt/bnxt_re/qplib_rcfw.h

139

PAGE_SIZE) + 1) : \

sys/dev/bnxt/bnxt_re/qplib_rcfw.h

141

PAGE_SIZE))

sys/dev/bnxt/bnxt_re/qplib_rcfw.h

143

PAGE_SIZE)

sys/dev/bnxt/bnxt_re/qplib_res.c

1145

ucreg->len = ucreg->offset + PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

1147

if (!ucreg->len || ((ucreg->len & (PAGE_SIZE - 1)) != 0)) {

sys/dev/bnxt/bnxt_re/qplib_res.c

288

sginfo.pgsize = npde * PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

294

sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

350

sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

437

sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

552

sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

872

dpi->dpi = bit_num + (reg->offset - dpit->ucreg.offset) / PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

874

umaddr = reg->bar_base + reg->offset + bit_num * PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

880

dpit->ucreg.offset + bit_num * PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.c

885

dpi->dbr = ioremap_wc(umaddr, PAGE_SIZE);

sys/dev/bnxt/bnxt_re/qplib_res.c

890

dpi->dbr = ioremap(umaddr, PAGE_SIZE);

sys/dev/bnxt/bnxt_re/qplib_res.c

970

dpit->max = (bar_len - reg->offset) / PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_res.h

174

#define PTR_CNT_PER_PG (PAGE_SIZE / sizeof(void *))

sys/dev/bnxt/bnxt_re/qplib_sp.c

657

hwq_attr.stride = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_sp.c

675

pg_size = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_sp.c

681

pg_size = buf_pg_size ? buf_pg_size : PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_sp.c

686

req.log2_pbl_pg_size = cpu_to_le16(((ilog2(PAGE_SIZE) <<

sys/dev/bnxt/bnxt_re/qplib_sp.c

729

sginfo.pgsize = PAGE_SIZE;

sys/dev/bnxt/bnxt_re/qplib_sp.c

734

hwq_attr.stride = PAGE_SIZE;

sys/dev/bwn/if_bwnreg.h

405

#define BWN_DMA_RINGMEMSIZE PAGE_SIZE

sys/dev/bxe/ecore_fw_defs.h

265

#define NUM_OF_ETH_BDS_IN_PAGE ((PAGE_SIZE)/(STRUCT_SIZE(eth_tx_bd)/8))

sys/dev/bxe/ecore_fw_defs.h

278

(0xFFFF - ((PAGE_SIZE/((STRUCT_SIZE(eth_rx_sge))/8))-1))

sys/dev/bxe/ecore_fw_defs.h

280

#define TU_ETH_CQES_PER_PAGE (PAGE_SIZE/(STRUCT_SIZE(eth_rx_cqe)/8))

sys/dev/bxe/ecore_fw_defs.h

281

#define U_ETH_BDS_PER_PAGE (PAGE_SIZE/(STRUCT_SIZE(eth_rx_bd)/8))

sys/dev/bxe/ecore_fw_defs.h

282

#define U_ETH_SGES_PER_PAGE (PAGE_SIZE/(STRUCT_SIZE(eth_rx_sge)/8))

sys/dev/bxe/ecore_fw_defs.h

409

(PAGE_SIZE / BITS_TO_BYTES(STRUCT_SIZE(event_ring_elem)))

sys/dev/cesa/cesa.c

163

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/cfe/cfe_env.c

34

#define CFE_ENV_SIZE PAGE_SIZE /* default is one page */

sys/dev/ciss/ciss.c

3113

cpi->maxio = (min(CISS_MAX_SG_ELEMENTS, sg_length) - 1) * PAGE_SIZE;

sys/dev/ciss/ciss.c

899

(CISS_MAX_SG_ELEMENTS - 1) * PAGE_SIZE, /* maxsize */

sys/dev/cxgb/cxgb_sge.c

322

((mtod(m, vm_offset_t) & PAGE_MASK) + m->m_len > PAGE_SIZE))

sys/dev/cxgb/cxgb_sge.c

880

if ((err = bus_dma_tag_create(sc->parent_dmat, PAGE_SIZE, 0,

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

1473

(sg[entries].len % PAGE_SIZE) != 0)

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

639

if (offset < PAGE_SIZE - bp->bio_ma_offset) {

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

643

offset -= PAGE_SIZE - bp->bio_ma_offset;

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

644

for (i = 1; offset >= PAGE_SIZE; i++)

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

645

offset -= PAGE_SIZE;

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

662

todo = MIN(len, PAGE_SIZE - page_offset);

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

669

m->m_ext.ext_size += PAGE_SIZE;

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

710

todo = MIN(len, PAGE_SIZE - page_offset);

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

821

if (bio_off < PAGE_SIZE - bp->bio_ma_offset) {

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

825

bio_off -= PAGE_SIZE - bp->bio_ma_offset;

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

826

for (i = 1; bio_off >= PAGE_SIZE; i++)

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

827

bio_off -= PAGE_SIZE;

sys/dev/cxgbe/cxgbei/icl_cxgbei.c

832

todo = MIN(len, PAGE_SIZE - page_offset);

sys/dev/cxgbe/iw_cxgbe/cq.c

1009

mm2->len = PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/cq.c

956

memsize = roundup(memsize, PAGE_SIZE);

sys/dev/cxgbe/iw_cxgbe/cq.c

993

ucontext->key += PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/cq.c

995

ucontext->key += PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/mem.c

447

if (i == PAGE_SIZE / sizeof *pages) {

sys/dev/cxgbe/iw_cxgbe/provider.c

137

uresp.status_page_size = PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/provider.c

141

context->key += PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/provider.c

151

mm->len = PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/provider.c

177

if (vma->vm_start & (PAGE_SIZE-1)) {

sys/dev/cxgbe/iw_cxgbe/qp.c

1772

qhp->wq.sq.memsize = roundup(qhp->wq.sq.memsize, PAGE_SIZE);

sys/dev/cxgbe/iw_cxgbe/qp.c

1773

qhp->wq.rq.memsize = roundup(qhp->wq.rq.memsize, PAGE_SIZE);

sys/dev/cxgbe/iw_cxgbe/qp.c

1847

ucontext->key += PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/qp.c

1849

ucontext->key += PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/qp.c

1851

ucontext->key += PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/qp.c

1853

ucontext->key += PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/qp.c

1874

sq_db_key_mm->len = PAGE_SIZE;

sys/dev/cxgbe/iw_cxgbe/qp.c

1881

rq_db_key_mm->len = PAGE_SIZE;

sys/dev/cxgbe/nvmf/nvmf_che.c

343

if (i != 0 && ds->ds_addr % PAGE_SIZE != 0)

sys/dev/cxgbe/nvmf/nvmf_che.c

346

(ds->ds_addr + ds->ds_len) % PAGE_SIZE != 0)

sys/dev/cxgbe/nvmf/nvmf_che.c

382

return (howmany(che_fbo(cb) + cb->io.io_len, PAGE_SIZE));

sys/dev/cxgbe/nvmf/nvmf_che.c

522

todo = min(PAGE_SIZE - (va % PAGE_SIZE), len);

sys/dev/cxgbe/nvmf/nvmf_che.c

536

todo = min(PAGE_SIZE, len);

sys/dev/cxgbe/nvmf/nvmf_che.c

621

pbl[i] = htobe64(pmap_kextract(va + i * PAGE_SIZE));

sys/dev/cxgbe/nvmf/nvmf_che.c

630

pbl[i] = htobe64(pa + i * PAGE_SIZE);

sys/dev/cxgbe/nvmf/nvmf_che.c

649

if (ds->ds_addr % PAGE_SIZE != 0)

sys/dev/cxgbe/nvmf/nvmf_che.c

650

len += ds->ds_addr % PAGE_SIZE;

sys/dev/cxgbe/nvmf/nvmf_che.c

651

for (k = 0; k < howmany(len, PAGE_SIZE); k++) {

sys/dev/cxgbe/nvmf/nvmf_che.c

653

k * PAGE_SIZE));

sys/dev/cxgbe/nvmf/nvmf_che.c

672

if (ds->ds_addr % PAGE_SIZE != 0)

sys/dev/cxgbe/nvmf/nvmf_che.c

673

len += ds->ds_addr % PAGE_SIZE;

sys/dev/cxgbe/nvmf/nvmf_che.c

674

for (k = 0; k < howmany(len, PAGE_SIZE); k++) {

sys/dev/cxgbe/nvmf/nvmf_che.c

675

pbl[i] = htobe64(pa + k * PAGE_SIZE);

sys/dev/cxgbe/nvmf/nvmf_che.c

725

V_FW_RI_TPTE_PS(PAGE_SIZE) |

sys/dev/cxgbe/t4_main.c

1397

buf = malloc(PAGE_SIZE, M_CXGBE, M_ZERO | M_WAITOK);

sys/dev/cxgbe/t4_main.c

9473

sb = sbuf_new_for_sysctl(NULL, NULL, PAGE_SIZE, req);

sys/dev/cxgbe/t4_main.c

9522

sb = sbuf_new_for_sysctl(NULL, NULL, PAGE_SIZE, req);

sys/dev/cxgbe/t4_main.c

9838

sb = sbuf_new_for_sysctl(NULL, NULL, PAGE_SIZE, req);

sys/dev/cxgbe/t4_main.c

9925

sb = sbuf_new_for_sysctl(NULL, NULL, PAGE_SIZE, req);

sys/dev/cxgbe/t4_netmap.c

477

if (nm_txq->udb_qid >= PAGE_SIZE / UDBS_SEG_SIZE)

sys/dev/cxgbe/t4_sge.c

157

static int safest_rx_cluster = PAGE_SIZE;

sys/dev/cxgbe/t4_sge.c

3716

if (qid < PAGE_SIZE / UDBS_SEG_SIZE) {

sys/dev/cxgbe/t4_sge.c

4639

if (eq->udb_qid >= PAGE_SIZE / UDBS_SEG_SIZE)

sys/dev/cxgbe/t4_sge.c

6501

if (rxb->size1 < PAGE_SIZE &&

sys/dev/cxgbe/tom/t4_cpl_io.c

2479

mlen = imin(len, MBUF_PEXT_MAX_PGS * PAGE_SIZE - pgoff);

sys/dev/cxgbe/tom/t4_cpl_io.c

2493

KASSERT(mlen + pgoff <= PAGE_SIZE,

sys/dev/cxgbe/tom/t4_cpl_io.c

2498

m->m_epg_last_len = mlen - (PAGE_SIZE - pgoff) -

sys/dev/cxgbe/tom/t4_cpl_io.c

2499

(npages - 2) * PAGE_SIZE;

sys/dev/cxgbe/tom/t4_cpl_io.c

2505

m->m_ext.ext_size = npages * PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1398

seglen = PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1400

VM_PAGE_TO_PHYS(pages[i]) + PAGE_SIZE ==

sys/dev/cxgbe/tom/t4_ddp.c

1402

seglen += PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1477

seglen = PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1479

pva += PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1481

seglen += PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1482

pva += PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1554

seglen = PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1556

pva += PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1559

seglen += PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1560

pva += PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1676

idx = i * PPOD_PAGES * (ddp_pgsz / PAGE_SIZE);

sys/dev/cxgbe/tom/t4_ddp.c

1681

idx += ddp_pgsz / PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

1867

idx = i * PPOD_PAGES * (ddp_pgsz / PAGE_SIZE);

sys/dev/cxgbe/tom/t4_ddp.c

1872

idx += ddp_pgsz / PAGE_SIZE;

sys/dev/cxgbe/tom/t4_ddp.c

3001

if (t4_ddp_rcvbuf_len < PAGE_SIZE)

sys/dev/cxgbe/tom/t4_ddp.c

3002

t4_ddp_rcvbuf_len = PAGE_SIZE;

sys/dev/cxgbe/tom/t4_tls.c

425

nextpa = m->m_epg_pa[0] + PAGE_SIZE;

sys/dev/cxgbe/tom/t4_tls.c

429

nextpa = m->m_epg_pa[i] + PAGE_SIZE;

sys/dev/dcons/dcons_os.c

324

for (pa = trunc_page(addr); pa < addr + size; pa += PAGE_SIZE)

sys/dev/dcons/dcons_os.c

360

M_DEVBUF, 0, 0x10000, 0xffffffff, PAGE_SIZE, 0ul);

sys/dev/dpaa/if_dtsec_rm.c

306

CTASSERT(FM_PORT_BUFFER_SIZE < PAGE_SIZE);

sys/dev/dpaa/if_dtsec_rm.c

599

ssize = PAGE_SIZE - (vaddr & PAGE_MASK);

sys/dev/dpaa2/dpaa2_channel.c

456

uint32_t maxsize = ((size - 1) / PAGE_SIZE + 1) * PAGE_SIZE;

sys/dev/dpaa2/dpaa2_channel.c

82

#define RX_SEG_SZ (((MJUM9BYTES - 1) / PAGE_SIZE + 1) * PAGE_SIZE)

sys/dev/dpaa2/dpaa2_channel.c

83

#define RX_SEG_MAXSZ (((MJUM9BYTES - 1) / PAGE_SIZE + 1) * PAGE_SIZE)

sys/dev/dpaa2/dpaa2_channel.c

84

CTASSERT(RX_SEG_SZ % PAGE_SIZE == 0);

sys/dev/dpaa2/dpaa2_channel.c

85

CTASSERT(RX_SEG_MAXSZ % PAGE_SIZE == 0);

sys/dev/dpaa2/dpaa2_channel.c

88

#define TX_SEG_SZ (PAGE_SIZE)

sys/dev/dpaa2/dpaa2_channel.c

90

CTASSERT(TX_SEG_SZ % PAGE_SIZE == 0);

sys/dev/dpaa2/dpaa2_channel.c

91

CTASSERT(TX_SEG_MAXSZ % PAGE_SIZE == 0);

sys/dev/dpaa2/dpaa2_channel.c

94

#define SGT_SEG_SZ (PAGE_SIZE)

sys/dev/dpaa2/dpaa2_channel.c

95

#define SGT_SEG_MAXSZ (PAGE_SIZE)

sys/dev/dpaa2/dpaa2_channel.c

96

CTASSERT(SGT_SEG_SZ % PAGE_SIZE == 0);

sys/dev/dpaa2/dpaa2_channel.c

97

CTASSERT(SGT_SEG_MAXSZ % PAGE_SIZE == 0);

sys/dev/dpaa2/dpaa2_ni.c

162

#define ETH_QOS_KCFG_BUF_SIZE (PAGE_SIZE)

sys/dev/dpaa2/dpaa2_ni.c

165

#define DPAA2_CLASSIFIER_DMA_SIZE (PAGE_SIZE)

sys/dev/dpaa2/dpaa2_ni.c

1794

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/dpaa2/dpaa2_ni.c

1810

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/dpaa2/dpaa2_types.h

44

#define DPAA2_TX_SEG_SZ (PAGE_SIZE)

sys/dev/dpaa2/dpaa2_types.h

46

#define DPAA2_TX_SGT_SZ (PAGE_SIZE) /* in bytes */

sys/dev/drm2/drmP.h

178

#define DRM_MAX_CTXBITMAP (PAGE_SIZE * 8)

sys/dev/drm2/drm_agpsupport.c

214

pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;

sys/dev/drm2/drm_agpsupport.c

330

page = (request->offset + PAGE_SIZE - 1) / PAGE_SIZE;

sys/dev/drm2/drm_agpsupport.c

454

ret = agp_bind_memory(mem, gtt_offset / PAGE_SIZE);

sys/dev/drm2/drm_buffer.c

110

int nr_pages = buf->size / PAGE_SIZE + 1;

sys/dev/drm2/drm_buffer.c

139

if (idx + objsize <= PAGE_SIZE) {

sys/dev/drm2/drm_buffer.c

143

int beginsz = PAGE_SIZE - idx;

sys/dev/drm2/drm_buffer.c

46

int nr_pages = size / PAGE_SIZE + 1;

sys/dev/drm2/drm_buffer.c

57

malloc(min(PAGE_SIZE, size - idx * PAGE_SIZE),

sys/dev/drm2/drm_buffer.c

75

int nr_pages = size / PAGE_SIZE + 1;

sys/dev/drm2/drm_buffer.c

88

(char *)user_data + idx * PAGE_SIZE,

sys/dev/drm2/drm_buffer.c

89

min(PAGE_SIZE, size - idx * PAGE_SIZE))) {

sys/dev/drm2/drm_buffer.h

132

return &buffer->data[iter / PAGE_SIZE][iter & (PAGE_SIZE - 1)];

sys/dev/drm2/drm_buffer.h

146

return &buffer->data[iter / PAGE_SIZE][iter & (PAGE_SIZE - 1)];

sys/dev/drm2/drm_buffer.h

53

return buf->iterator / PAGE_SIZE;

sys/dev/drm2/drm_buffer.h

60

return buf->iterator & (PAGE_SIZE - 1);

sys/dev/drm2/drm_bufs.c

1006

byte_count += PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

1037

dma->byte_count += PAGE_SIZE * (entry->seg_count << page_order);

sys/dev/drm2/drm_bufs.c

1086

total = PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

1169

byte_count += PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

1242

total = PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

1324

byte_count += PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

172

if (shm && (SHMLBA > PAGE_SIZE)) {

sys/dev/drm2/drm_bufs.c

370

(map->offset + map->size <= entry->bound + entry->pages * PAGE_SIZE)) {

sys/dev/drm2/drm_bufs.c

402

align = PAGE_SIZE;

sys/dev/drm2/drm_bufs.c

710

total = PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

730

(agp_offset + total * count <= agp_entry->bound + agp_entry->pages * PAGE_SIZE)) {

sys/dev/drm2/drm_bufs.c

805

byte_count += PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

888

total = PAGE_SIZE << page_order;

sys/dev/drm2/drm_bufs.c

953

dmah = drm_pci_alloc(dev, PAGE_SIZE << page_order, 0x1000, BUS_SPACE_MAXADDR);

sys/dev/drm2/drm_bufs.c

969

(unsigned long)dmah->vaddr + PAGE_SIZE * i);

sys/dev/drm2/drm_bufs.c

971

= (unsigned long)dmah->vaddr + PAGE_SIZE * i;

sys/dev/drm2/drm_context.c

134

dev->ctx_bitmap = malloc(PAGE_SIZE, DRM_MEM_CTXBITMAP,

sys/dev/drm2/drm_gem.c

108

KASSERT((size & (PAGE_SIZE - 1)) == 0,

sys/dev/drm2/drm_gem.c

131

MPASS((size & (PAGE_SIZE - 1)) == 0);

sys/dev/drm2/drm_memory.c

75

return -agp_bind_memory(agpdev, handle, start * PAGE_SIZE);

sys/dev/drm2/drm_os_freebsd.h

375

uaddr += PAGE_SIZE;

sys/dev/drm2/drm_os_freebsd.h

404

uaddr += PAGE_SIZE;

sys/dev/drm2/drm_sysctl.c

311

* (int)PAGE_SIZE / 1024);

sys/dev/drm2/ttm/ttm_agp_backend.c

65

agp_be->offset = node->start * PAGE_SIZE;

sys/dev/drm2/ttm/ttm_bo.c

1241

num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;

sys/dev/drm2/ttm/ttm_bo.c

1498

VM_MAX_ADDRESS, PAGE_SIZE, 0, VM_MEMATTR_UNCACHEABLE);

sys/dev/drm2/ttm/ttm_bo.c

1502

VM_MAX_ADDRESS, PAGE_SIZE, 0) == 0)) {

sys/dev/drm2/ttm/ttm_bo.c

99

return snprintf(buffer, PAGE_SIZE, "%lu\n",

sys/dev/drm2/ttm/ttm_bo_util.c

239

for (i = 0; i < PAGE_SIZE / sizeof(uint32_t); ++i)

sys/dev/drm2/ttm/ttm_bo_util.c

258

dst = pmap_mapdev_attr(VM_PAGE_TO_PHYS(d), PAGE_SIZE, prot);

sys/dev/drm2/ttm/ttm_bo_util.c

262

memcpy(dst, src, PAGE_SIZE);

sys/dev/drm2/ttm/ttm_bo_util.c

264

pmap_unmapdev(dst, PAGE_SIZE);

sys/dev/drm2/ttm/ttm_bo_util.c

280

src = pmap_mapdev_attr(VM_PAGE_TO_PHYS(s), PAGE_SIZE, prot);

sys/dev/drm2/ttm/ttm_bo_util.c

284

memcpy(dst, src, PAGE_SIZE);

sys/dev/drm2/ttm/ttm_bo_util.c

286

pmap_unmapdev(src, PAGE_SIZE);

sys/dev/drm2/ttm/ttm_bo_util.c

513

map->virtual = (void *)kva_alloc(num_pages * PAGE_SIZE);

sys/dev/drm2/ttm/ttm_bo_util.c

576

map->num_pages * PAGE_SIZE);

sys/dev/drm2/ttm/ttm_memory.c

262

mem = physmem * PAGE_SIZE;

sys/dev/drm2/ttm/ttm_memory.c

275

ttm_page_alloc_init(glob, glob->zone_kernel->max_mem/(2*PAGE_SIZE));

sys/dev/drm2/ttm/ttm_memory.c

276

ttm_dma_page_alloc_init(glob, glob->zone_kernel->max_mem/(2*PAGE_SIZE));

sys/dev/drm2/ttm/ttm_memory.c

438

return ttm_mem_global_alloc_zone(glob, zone, PAGE_SIZE, no_wait,

sys/dev/drm2/ttm/ttm_memory.c

448

ttm_mem_global_free_zone(glob, zone, PAGE_SIZE);

sys/dev/drm2/ttm/ttm_memory.c

456

else if (size > PAGE_SIZE)

sys/dev/drm2/ttm/ttm_memory.c

78

return snprintf(buffer, PAGE_SIZE, "%llu\n",

sys/dev/drm2/ttm/ttm_page_alloc.c

164

p = vm_page_alloc_noobj_contig(req, 1, 0, 0xffffffff, PAGE_SIZE,

sys/dev/drm2/ttm/ttm_page_alloc.c

169

PAGE_SIZE, 0);

sys/dev/drm2/ttm/ttm_page_alloc.c

229

val = val / (PAGE_SIZE >> 10);

sys/dev/drm2/ttm/ttm_page_alloc.c

238

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 7),

sys/dev/drm2/ttm/ttm_page_alloc.c

239

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm2/ttm/ttm_page_alloc.c

243

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm2/ttm/ttm_page_alloc.c

263

val = val * (PAGE_SIZE >> 10);

sys/dev/drm2/ttm/ttm_page_alloc.c

265

return snprintf(buffer, PAGE_SIZE, "%u\n", val);

sys/dev/drm2/ttm/ttm_page_alloc.c

48

#define NUM_PAGES_TO_ALLOC (PAGE_SIZE/sizeof(vm_page_t))

sys/dev/drm2/ttm/ttm_page_alloc.c

531

(unsigned)(PAGE_SIZE/sizeof(vm_page_t)));

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

219

val = val / (PAGE_SIZE >> 10);

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

228

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 7),

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

229

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

233

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

255

val = val * (PAGE_SIZE >> 10);

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

257

return snprintf(buffer, PAGE_SIZE, "%u\n", val);

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

57

#define NUM_PAGES_TO_ALLOC (PAGE_SIZE/sizeof(struct page *))

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

605

pool->size = PAGE_SIZE;

sys/dev/drm2/ttm/ttm_page_alloc_dma.c

715

(unsigned)(PAGE_SIZE/sizeof(struct page *)));

sys/dev/drm2/ttm/ttm_tt.c

187

ttm->num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;

sys/dev/drm2/ttm/ttm_tt.c

217

ttm->num_pages = (size + PAGE_SIZE - 1) >> PAGE_SHIFT;

sys/dev/e1000/if_em.c

709

.isc_q_align = PAGE_SIZE,

sys/dev/e1000/if_em.c

711

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/e1000/if_em.c

737

.isc_q_align = PAGE_SIZE,

sys/dev/e1000/if_em.c

739

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/ena/ena.c

215

maxsize = ((size - 1) / PAGE_SIZE + 1) * PAGE_SIZE;

sys/dev/enetc/if_enetc.c

230

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/enic/if_enic.c

194

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/fb/vesa.c

1645

if (offset > adp->va_window_size - PAGE_SIZE)

sys/dev/fb/vga.c

2480

if (offset > adp->va_window_size - PAGE_SIZE)

sys/dev/firewire/fwdev.c

303

xfer->recv.pay_len = PAGE_SIZE;

sys/dev/firewire/fwdev.c

407

PAGE_SIZE/*XXX*/)) == NULL)

sys/dev/firewire/fwdev.c

651

xfer = fw_xfer_alloc_buf(M_FWXFER, pay_len, PAGE_SIZE/*XXX*/);

sys/dev/firewire/fwdev.c

750

PAGE_SIZE, PAGE_SIZE, 5,

sys/dev/firewire/fwdma.c

153

if (esize > PAGE_SIZE) {

sys/dev/firewire/fwdma.c

155

esize = ssize = roundup2(esize, PAGE_SIZE);

sys/dev/firewire/fwdma.c

159

ssize = rounddown(PAGE_SIZE, esize);

sys/dev/firewire/fwohci.c

162

#define DMA_PROG_ALLOC (8 * PAGE_SIZE)

sys/dev/firewire/fwohci.c

635

sc->arrq.xferq.psize = roundup2(FWPMAX_S400, PAGE_SIZE);

sys/dev/firewire/fwohci.c

636

sc->arrs.xferq.psize = roundup2(FWPMAX_S400, PAGE_SIZE);

sys/dev/firewire/fwohci.c

637

sc->atrq.xferq.psize = roundup2(FWPMAX_S400, PAGE_SIZE);

sys/dev/firewire/fwohci.c

638

sc->atrs.xferq.psize = roundup2(FWPMAX_S400, PAGE_SIZE);

sys/dev/firewire/sbp.c

134

#define SBP_SEG_MAX rounddown(0xffff, PAGE_SIZE)

sys/dev/firewire/sbp.c

135

#define SBP_IND_MAX howmany(SBP_MAXPHYS, PAGE_SIZE)

sys/dev/firewire/sbp.c

73

#define SBP_DMA_SIZE PAGE_SIZE

sys/dev/gem/if_gem.c

194

error = bus_dma_tag_create(sc->sc_pdmatag, PAGE_SIZE, 0,

sys/dev/gve/gve.h

65

#define ADMINQ_SIZE PAGE_SIZE

sys/dev/gve/gve.h

70

#define GVE_DEFAULT_RX_BUFFER_OFFSET (PAGE_SIZE / 2)

sys/dev/gve/gve_adminq.c

570

err = gve_dma_alloc_coherent(priv, size, PAGE_SIZE, &dma);

sys/dev/gve/gve_adminq.c

586

.page_size = htobe64(PAGE_SIZE),

sys/dev/gve/gve_adminq.c

668

err = gve_dma_alloc_coherent(priv, sizeof(*ptype_map), PAGE_SIZE, &dma);

sys/dev/gve/gve_dqo.h

335

return (PAGE_SIZE / priv->rx_buf_size_dqo);

sys/dev/gve/gve_dqo.h

71

#define GVE_TX_BUFS_PER_PAGE_DQO (PAGE_SIZE >> GVE_TX_BUF_SHIFT_DQO)

sys/dev/gve/gve_main.c

64

PAGE_SIZE, &driver_info_mem);

sys/dev/gve/gve_main.c

653

PAGE_SIZE, &priv->counter_array_mem);

sys/dev/gve/gve_main.c

675

sizeof(struct gve_irq_db) * (priv->num_queues), PAGE_SIZE,

sys/dev/gve/gve_qpl.c

109

qpl->kva = kva_alloc(PAGE_SIZE * npages);

sys/dev/gve/gve_qpl.c

123

qpl->dmas[i].cpu_addr = (void *)kva_alloc(PAGE_SIZE);

sys/dev/gve/gve_qpl.c

131

qpl->dmas[i].cpu_addr = (void *)(qpl->kva + (PAGE_SIZE * i));

sys/dev/gve/gve_qpl.c

141

err = gve_dmamap_create(priv, /*size=*/PAGE_SIZE, /*align=*/PAGE_SIZE,

sys/dev/gve/gve_qpl.c

256

kva_free(va, PAGE_SIZE);

sys/dev/gve/gve_qpl.c

50

kva_free(qpl->kva, PAGE_SIZE * qpl->num_pages);

sys/dev/gve/gve_qpl.c

63

kva_free((vm_offset_t)qpl->dmas[i].cpu_addr, PAGE_SIZE);

sys/dev/gve/gve_rx.c

165

PAGE_SIZE, &com->q_resources_mem);

sys/dev/gve/gve_rx.c

232

rx->data_ring[i].qpl_offset = htobe64(PAGE_SIZE * i +

sys/dev/gve/gve_rx.c

90

rx->data_ring[i].qpl_offset = htobe64(PAGE_SIZE * i);

sys/dev/gve/gve_tx.c

168

PAGE_SIZE, &com->q_resources_mem);

sys/dev/gve/gve_tx.c

43

fifo->size = qpl->num_pages * PAGE_SIZE;

sys/dev/gve/gve_tx.c

472

uint64_t last_page = (iov_offset + iov_len - 1) / PAGE_SIZE;

sys/dev/gve/gve_tx.c

473

uint64_t first_page = iov_offset / PAGE_SIZE;

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

1091

PAGE_SIZE * (os_max_sg_descriptors-1), /* maxsize */

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

138

return contigmalloc(PAGE_SIZE<<order,

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

139

M_DEVBUF, M_WAITOK, BUS_SPACE_MAXADDR_24BIT, BUS_SPACE_MAXADDR, PAGE_SIZE, 0);

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

174

for (order=0, size=PAGE_SIZE; size<f->size; order++, size<<=1)

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

179

HPT_ASSERT(f->alignment<=PAGE_SIZE);

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

193

HPT_ASSERT(PAGE_SIZE==DMAPOOL_PAGE_SIZE);

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

235

for (order=0, size=PAGE_SIZE; size<f->size; order++, size<<=1) ;

sys/dev/hpt27xx/hpt27xx_osm_bsd.c

242

if (((HPT_UPTR)p & (PAGE_SIZE-1))==0)

sys/dev/hptiop/hptiop.c

1950

PAGE_SIZE * (hba->max_sg_count-1), /* maxsize */

sys/dev/hptmv/entry.c

1282

PAGE_SIZE * (MAX_SG_DESCRIPTORS-1), /* maxsize */

sys/dev/hptmv/entry.c

1389

(PRD_ENTRIES_SIZE*PRD_TABLES_FOR_VBUS + 32), M_DEVBUF, M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0ul);

sys/dev/hptmv/entry.c

2939

return (void *)contigmalloc(0x1000, M_DEVBUF, M_NOWAIT, 0x1000000, 0xffffffff, PAGE_SIZE, 0ul);

sys/dev/hptmv/entry.c

2945

return (void *)contigmalloc(0x1000, M_DEVBUF, M_NOWAIT, 0x1000000, 0xffffffff, PAGE_SIZE, 0ul);

sys/dev/hptmv/entry.c

895

M_DEVBUF, M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0ul);

sys/dev/hptmv/entry.c

921

M_DEVBUF, M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0ul);

sys/dev/hptmv/hptproc.c

311

if (piop->nInBufferSize > PAGE_SIZE ||

sys/dev/hptmv/hptproc.c

312

piop->nOutBufferSize > PAGE_SIZE ||

sys/dev/hptmv/hptproc.c

313

piop->nInBufferSize+piop->nOutBufferSize > PAGE_SIZE) {

sys/dev/hptmv/ioctl.c

640

#define NOTNEIGHBORPAGE(highvaddr, lowvaddr) ((ULONG_PTR)(highvaddr) - (ULONG_PTR)(lowvaddr) != PAGE_SIZE)

sys/dev/hptmv/ioctl.c

651

nextpage = (ADDRESS)trunc_page(((ULONG_PTR)currvaddr + PAGE_SIZE));

sys/dev/hptnr/hptnr_osm_bsd.c

1378

PAGE_SIZE * (os_max_sg_descriptors-1), /* maxsize */

sys/dev/hptnr/hptnr_osm_bsd.c

142

return contigmalloc(PAGE_SIZE<<order,

sys/dev/hptnr/hptnr_osm_bsd.c

143

M_DEVBUF, M_WAITOK, BUS_SPACE_MAXADDR_24BIT, BUS_SPACE_MAXADDR, PAGE_SIZE, 0);

sys/dev/hptnr/hptnr_osm_bsd.c

178

for (order=0, size=PAGE_SIZE; size<f->size; order++, size<<=1)

sys/dev/hptnr/hptnr_osm_bsd.c

183

HPT_ASSERT(f->alignment<=PAGE_SIZE);

sys/dev/hptnr/hptnr_osm_bsd.c

197

HPT_ASSERT(PAGE_SIZE==DMAPOOL_PAGE_SIZE);

sys/dev/hptnr/hptnr_osm_bsd.c

239

for (order=0, size=PAGE_SIZE; size<f->size; order++, size<<=1) ;

sys/dev/hptnr/hptnr_osm_bsd.c

246

if (((HPT_UPTR)p & (PAGE_SIZE-1))==0)

sys/dev/hptrr/hptrr_osm_bsd.c

1022

PAGE_SIZE * (os_max_sg_descriptors-1), /* maxsize */

sys/dev/hptrr/hptrr_osm_bsd.c

143

return contigmalloc(PAGE_SIZE<<order,

sys/dev/hptrr/hptrr_osm_bsd.c

144

M_DEVBUF, M_WAITOK, BUS_SPACE_MAXADDR_24BIT, BUS_SPACE_MAXADDR, PAGE_SIZE, 0);

sys/dev/hptrr/hptrr_osm_bsd.c

180

for (order=0, size=PAGE_SIZE; size<f->size; order++, size<<=1)

sys/dev/hptrr/hptrr_osm_bsd.c

185

HPT_ASSERT(f->alignment<=PAGE_SIZE);

sys/dev/hptrr/hptrr_osm_bsd.c

199

HPT_ASSERT(PAGE_SIZE==DMAPOOL_PAGE_SIZE);

sys/dev/hptrr/hptrr_osm_bsd.c

241

for (order=0, size=PAGE_SIZE; size<f->size; order++, size<<=1) ;

sys/dev/hptrr/hptrr_osm_bsd.c

248

if (((HPT_UPTR)p & (PAGE_SIZE-1))==0)

sys/dev/hwpmc/hwpmc_powerpc.c

77

osp = (uintptr_t *)PAGE_SIZE;

sys/dev/hwt/hwt_config.c

48

#define HWT_MAXCONFIGSIZE PAGE_SIZE

sys/dev/hwt/hwt_ioctl.c

392

if (halloc->bufsize % PAGE_SIZE)

sys/dev/hwt/hwt_vm.c

121

alignment = PAGE_SIZE;

sys/dev/hwt/hwt_vm.c

129

vm->kvaddr = kva_alloc(vm->npages * PAGE_SIZE);

sys/dev/hwt/hwt_vm.c

135

&hwt_vm_pager_ops, vm->npages * PAGE_SIZE, PROT_READ, 0,

sys/dev/hwt/hwt_vm.c

163

cpu_dcache_wb_range((void *)va, PAGE_SIZE);

sys/dev/hwt/hwt_vm.c

174

pmap_qenter(vm->kvaddr + i * PAGE_SIZE, &m, 1);

sys/dev/hwt/hwt_vm.c

364

if (data_size == 0 || data_size > PAGE_SIZE)

sys/dev/hwt/hwt_vm.c

446

kva_free(vm->kvaddr, vm->npages * PAGE_SIZE);

sys/dev/hwt/hwt_vm.c

486

vm->npages = bufsize / PAGE_SIZE;

sys/dev/hyperv/hvsock/hv_sock.c

1068

#define HVS_RINGBUF_RCV_SIZE (PAGE_SIZE * 6)

sys/dev/hyperv/hvsock/hv_sock.c

1069

#define HVS_RINGBUF_SND_SIZE (PAGE_SIZE * 6)

sys/dev/hyperv/hvsock/hv_sock.c

1070

#define HVS_RINGBUF_MAX_SIZE (PAGE_SIZE * 64)

sys/dev/hyperv/hvsock/hv_sock.c

1410

sndbuf = rounddown2(sndbuf, PAGE_SIZE);

sys/dev/hyperv/hvsock/hv_sock.c

1413

rcvbuf = rounddown2(rcvbuf, PAGE_SIZE);

sys/dev/hyperv/hvsock/hv_sock.c

78

#define HVSOCK_SEND_BUF_SZ (PAGE_SIZE - sizeof(struct vmpipe_proto_header))

sys/dev/hyperv/include/hyperv.h

69

} __packed __aligned(PAGE_SIZE);

sys/dev/hyperv/include/hyperv.h

71

CTASSERT(sizeof(struct hyperv_reftsc) == PAGE_SIZE);

sys/dev/hyperv/input/hv_hid.c

54

#define HV_BUFSIZ (4 * PAGE_SIZE)

sys/dev/hyperv/input/hv_hid.c

55

#define HV_HID_RINGBUFF_SEND_SZ (10 * PAGE_SIZE)

sys/dev/hyperv/input/hv_hid.c

56

#define HV_HID_RINGBUFF_RECV_SZ (10 * PAGE_SIZE)

sys/dev/hyperv/input/hv_kbdc.c

66

#define HV_BUFF_SIZE (4*PAGE_SIZE)

sys/dev/hyperv/input/hv_kbdc.c

67

#define HV_KBD_RINGBUFF_SEND_SZ (10*PAGE_SIZE)

sys/dev/hyperv/input/hv_kbdc.c

68

#define HV_KBD_RINGBUFF_RECV_SZ (10*PAGE_SIZE)

sys/dev/hyperv/netvsc/hn_rndis.c

224

int len = PAGE_SIZE;

sys/dev/hyperv/netvsc/if_hn.c

141

#define HN_RNDIS_PKT_BOUNDARY PAGE_SIZE

sys/dev/hyperv/netvsc/if_hn.c

144

#define HN_TX_DATA_BOUNDARY PAGE_SIZE

sys/dev/hyperv/netvsc/if_hn.c

146

#define HN_TX_DATA_SEGSIZE PAGE_SIZE

sys/dev/hyperv/netvsc/if_hn.c

2421

if_sethwtsomaxsegsize(ifp, PAGE_SIZE);

sys/dev/hyperv/netvsc/if_hn.c

4937

0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/netvsc/if_hn.c

4968

M_WAITOK | M_ZERO, 0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/netvsc/if_hn.c

5442

0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/netvsc/if_hnvar.h

39

#define HN_TXBR_SIZE (128 * PAGE_SIZE)

sys/dev/hyperv/netvsc/if_hnvar.h

40

#define HN_RXBR_SIZE (128 * PAGE_SIZE)

sys/dev/hyperv/netvsc/if_hnvar.h

44

#define HN_XACT_REQ_SIZE (HN_XACT_REQ_PGCNT * PAGE_SIZE)

sys/dev/hyperv/netvsc/if_hnvar.h

45

#define HN_XACT_RESP_SIZE (HN_XACT_RESP_PGCNT * PAGE_SIZE)

sys/dev/hyperv/pcib/vmbus_pcib.c

1488

const int pci_ring_size = (4 * PAGE_SIZE);

sys/dev/hyperv/pcib/vmbus_pcib.c

1511

RF_ACTIVE | rman_make_alignment_flags(PAGE_SIZE));

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

104

#define STORVSC_DATA_SEGSZ_MAX PAGE_SIZE

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

1125

tmp_buff = malloc(PAGE_SIZE,

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

146

static u_int hv_storvsc_ringbuffer_size = (64 * PAGE_SIZE);

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

1653

unsigned int buf_len = ((write == WRITE_TYPE) ? 0 : PAGE_SIZE);

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

1839

segs[i].ds_len == PAGE_SIZE,

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

1849

segs[i].ds_len == PAGE_SIZE,

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

2079

PAGE_SIZE - offset);

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

281

20*PAGE_SIZE},

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

284

20*PAGE_SIZE}

sys/dev/hyperv/storvsc/hv_storvsc_drv_freebsd.c

956

PAGE_SIZE, /* boundary */

sys/dev/hyperv/utilities/vmbus_ic.c

40

#define VMBUS_IC_BRSIZE (4 * PAGE_SIZE)

sys/dev/hyperv/vmbus/amd64/hyperv_machdep.c

210

hyperv_ref_tsc.tsc_ref = contigmalloc(PAGE_SIZE, M_DEVBUF,

sys/dev/hyperv/vmbus/amd64/hyperv_machdep.c

211

M_WAITOK | M_ZERO, 0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/hyperv.c

194

kmem_free(hypercall_context.hc_addr, PAGE_SIZE);

sys/dev/hyperv/vmbus/hyperv.c

212

hypercall_context.hc_addr = kmem_malloc(PAGE_SIZE, M_EXEC | M_WAITOK);

sys/dev/hyperv/vmbus/hyperv_mmu.c

209

max_gvas = (PAGE_SIZE - sizeof(*flush)) / sizeof(flush->gva_list[0]);

sys/dev/hyperv/vmbus/hyperv_mmu.c

286

max_gvas = (PAGE_SIZE - sizeof(*flush) - nr_bank *

sys/dev/hyperv/vmbus/vmbus.c

1350

RF_ACTIVE | rman_make_alignment_flags(PAGE_SIZE));

sys/dev/hyperv/vmbus/vmbus.c

1402

*hv_cpu_mem = contigmalloc(PAGE_SIZE, M_DEVBUF,

sys/dev/hyperv/vmbus/vmbus.c

1403

M_NOWAIT | M_ZERO, 0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/vmbus.c

863

ptr = contigmalloc(PAGE_SIZE, M_DEVBUF, M_WAITOK | M_ZERO,

sys/dev/hyperv/vmbus/vmbus.c

864

0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/vmbus.c

869

ptr = contigmalloc(PAGE_SIZE, M_DEVBUF, M_WAITOK | M_ZERO,

sys/dev/hyperv/vmbus/vmbus.c

870

0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/vmbus.c

876

evtflags = contigmalloc(PAGE_SIZE, M_DEVBUF, M_WAITOK | M_ZERO,

sys/dev/hyperv/vmbus/vmbus.c

877

0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/vmbus.c

881

sc->vmbus_tx_evtflags = (u_long *)(evtflags + (PAGE_SIZE / 2));

sys/dev/hyperv/vmbus/vmbus.c

884

sc->vmbus_mnf1 = contigmalloc(PAGE_SIZE, M_DEVBUF, M_WAITOK | M_ZERO,

sys/dev/hyperv/vmbus/vmbus.c

885

0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/vmbus.c

890

M_WAITOK | M_ZERO, 0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/vmbus_chan.c

345

M_WAITOK | M_ZERO, 0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/vmbus_reg.h

177

CTASSERT(sizeof(struct vmbus_bufring) == PAGE_SIZE);

sys/dev/hyperv/vmbus/vmbus_reg.h

99

CTASSERT(sizeof(struct vmbus_mnf) == PAGE_SIZE);

sys/dev/hyperv/vmbus/vmbus_var.h

151

#define HV_TLB_FLUSH_UNIT (4096 * PAGE_SIZE)

sys/dev/hyperv/vmbus/vmbus_xact.c

91

M_WAITOK | M_ZERO, 0ul, ~0ul, PAGE_SIZE, 0);

sys/dev/hyperv/vmbus/x86/vmbus_x86.c

146

pmap_pti_add_kva(VMBUS_ISR_ADDR, VMBUS_ISR_ADDR + PAGE_SIZE, true);

sys/dev/hyperv/vmbus/x86/vmbus_x86.c

157

pmap_pti_remove_kva(VMBUS_ISR_ADDR, VMBUS_ISR_ADDR + PAGE_SIZE);

sys/dev/hyperv/vmbus/x86/vmbus_x86.c

180

pmap_pti_remove_kva(VMBUS_ISR_ADDR, VMBUS_ISR_ADDR + PAGE_SIZE);

sys/dev/iavf/if_iavf_iflib.c

186

.isc_q_align = PAGE_SIZE,

sys/dev/ice/if_ice_iflib.c

262

.isc_q_align = PAGE_SIZE,

sys/dev/ice/if_ice_iflib.c

3560

.isc_q_align = PAGE_SIZE,

sys/dev/igc/if_igc.c

283

.isc_q_align = PAGE_SIZE,

sys/dev/igc/if_igc.c

285

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/ioat/ioat.c

1269

desc = ioat_op_generic(ioat, IOAT_OP_COPY, 2 * PAGE_SIZE, 0, 0,

sys/dev/ioat/ioat.c

1276

src1_len = (src2 != src1 + PAGE_SIZE) ? PAGE_SIZE : 2 * PAGE_SIZE;

sys/dev/ioat/ioat.c

1286

if (src1_len != 2 * PAGE_SIZE) {

sys/dev/ioat/ioat.c

1290

desc->src2_dmamap, src2, PAGE_SIZE, 0, &seg, &nseg);

sys/dev/ioat/ioat.c

1299

dst1_len = (dst2 != dst1 + PAGE_SIZE) ? PAGE_SIZE : 2 * PAGE_SIZE;

sys/dev/ioat/ioat.c

1309

if (dst1_len != 2 * PAGE_SIZE) {

sys/dev/ioat/ioat.c

1313

desc->dst2_dmamap, dst2, PAGE_SIZE, 0, &seg, &nseg);

sys/dev/ioat/ioat_test.c

117

PAGE_SIZE, 0);

sys/dev/ioat/ioat_test.c

302

src2 = vtophys((vm_offset_t)tx->buf[2*i] + PAGE_SIZE);

sys/dev/ioat/ioat_test.c

303

dst2 = vtophys((vm_offset_t)tx->buf[2*i+1] + PAGE_SIZE);

sys/dev/ioat/ioat_test.c

310

src2 = vtophys((vm_offset_t)tx->buf[2*i+1] + PAGE_SIZE);

sys/dev/ioat/ioat_test.c

311

dst2 = vtophys((vm_offset_t)tx->buf[2*i] + PAGE_SIZE);

sys/dev/ioat/ioat_test.c

365

test->buffer_size != 2 * PAGE_SIZE) {

sys/dev/iommu/busdma_iommu.c

1077

ma[i] = vm_page_getfake(entry->start + PAGE_SIZE * i,

sys/dev/iommu/busdma_iommu.c

541

if (tag->common.maxsize < PAGE_SIZE &&

sys/dev/iommu/busdma_iommu.c

799

for (i = 0; i < ma_cnt; i++, pstart += PAGE_SIZE) {

sys/dev/irdma/irdma_hw.c

1459

pg_cnt = DIV_ROUND_UP(aeq->mem.size, PAGE_SIZE);

sys/dev/irdma/irdma_hw.c

657

u32 pg_cnt = DIV_ROUND_UP(aeq->mem.size, PAGE_SIZE);

sys/dev/irdma/irdma_kcompat.c

139

iwmr->len = max_num_sg * PAGE_SIZE;

sys/dev/irdma/irdma_utils.c

2135

pg_dma[i] = dma_map_page(hw_to_dev(hw), vm_page, 0, PAGE_SIZE, DMA_BIDIRECTIONAL);

sys/dev/irdma/irdma_utils.c

2139

addr += PAGE_SIZE;

sys/dev/irdma/irdma_utils.c

2155

dma_unmap_page(hw_to_dev(hw), pg_dma[i], PAGE_SIZE, DMA_BIDIRECTIONAL);

sys/dev/irdma/irdma_utils.c

2194

size = PAGE_SIZE * pg_cnt;

sys/dev/irdma/irdma_utils.c

2348

dma_mem.size = PAGE_SIZE;

sys/dev/irdma/irdma_utils.c

2349

dma_mem.va = irdma_allocate_dma_mem(dev->hw, &dma_mem, dma_mem.size, PAGE_SIZE);

sys/dev/irdma/irdma_verbs.c

101

if (vma->vm_pgoff || vma->vm_end - vma->vm_start != PAGE_SIZE)

sys/dev/irdma/irdma_verbs.c

108

return rdma_user_mmap_io(&ucontext->ibucontext, vma, pfn, PAGE_SIZE,

sys/dev/irdma/irdma_verbs.c

134

&entry->rdma_entry, PAGE_SIZE);

sys/dev/irdma/irdma_verbs.c

182

ret = rdma_user_mmap_io(context, vma, pfn, PAGE_SIZE,

sys/dev/irdma/irdma_verbs.c

187

ret = rdma_user_mmap_io(context, vma, pfn, PAGE_SIZE,

sys/dev/irdma/irdma_verbs.c

1886

info->page_size = PAGE_SIZE;

sys/dev/irdma/irdma_verbs.c

1923

info->page_size = PAGE_SIZE;

sys/dev/irdma/irdma_verbs.c

2306

iwmr->page_size = PAGE_SIZE;

sys/dev/isci/isci.h

286

((SCI_MAX_SCATTER_GATHER_ELEMENTS - 1) * PAGE_SIZE)

sys/dev/isci/isci_controller.c

187

mde->virtual_address = contigmalloc(PAGE_SIZE,

sys/dev/isci/isci_controller.c

193

NULL, mde->virtual_address, PAGE_SIZE,

sys/dev/isci/scil/sci_controller_constants.h

158

#define __MAXPHYS_ELEMENTS ((maxphys / PAGE_SIZE) + 1)

sys/dev/iscsi/icl_soft.c

1127

if (offset < PAGE_SIZE - bp->bio_ma_offset) {

sys/dev/iscsi/icl_soft.c

1131

offset -= PAGE_SIZE - bp->bio_ma_offset;

sys/dev/iscsi/icl_soft.c

1132

for (i = 1; offset >= PAGE_SIZE; i++)

sys/dev/iscsi/icl_soft.c

1133

offset -= PAGE_SIZE;

sys/dev/iscsi/icl_soft.c

1150

todo = MIN(len, PAGE_SIZE - page_offset);

sys/dev/iscsi/icl_soft.c

1157

m->m_ext.ext_size += PAGE_SIZE;

sys/dev/iscsi/icl_soft.c

1198

todo = MIN(len, PAGE_SIZE - page_offset);

sys/dev/iscsi/icl_soft.c

1277

if (bio_off < PAGE_SIZE - bp->bio_ma_offset) {

sys/dev/iscsi/icl_soft.c

1281

bio_off -= PAGE_SIZE - bp->bio_ma_offset;

sys/dev/iscsi/icl_soft.c

1282

for (i = 1; bio_off >= PAGE_SIZE; i++)

sys/dev/iscsi/icl_soft.c

1283

bio_off -= PAGE_SIZE;

sys/dev/iscsi/icl_soft.c

1288

todo = MIN(len, PAGE_SIZE - page_offset);

sys/dev/iser/iser_initiator.c

290

len = min(PAGE_SIZE - offset, tlen);

sys/dev/iser/iser_initiator.c

313

len = min(PAGE_SIZE - offset, tlen);

sys/dev/ismt/ismt.c

611

bus_dma_tag_create(bus_get_dma_tag(dev), 4, PAGE_SIZE,

sys/dev/ismt/ismt.c

616

bus_dma_tag_create(bus_get_dma_tag(dev), 4, PAGE_SIZE,

sys/dev/isp/isp_freebsd.c

2760

cpi->maxio = (ISP_NSEG64_MAX - 1) * PAGE_SIZE;

sys/dev/isp/isp_pci.c

1103

(ISP_NSEG64_MAX - 1) * PAGE_SIZE, ISP_NSEG64_MAX,

sys/dev/isp/isp_pci.c

1104

(ISP_NSEG64_MAX - 1) * PAGE_SIZE, 0,

sys/dev/iwm/if_iwmvar.h

313

#define IWM_CMD_RESP_MAX PAGE_SIZE

sys/dev/iwx/if_iwx.c

10449

KASSERT((sizeof(struct iwx_prph_info) < PAGE_SIZE / 2),

sys/dev/iwx/if_iwx.c

10452

PAGE_SIZE, 1);

sys/dev/iwx/if_iwx.c

1188

htole64(sc->prph_info_dma.paddr + PAGE_SIZE / 2);

sys/dev/iwx/if_iwx.c

1190

htole64(sc->prph_info_dma.paddr + 3 * PAGE_SIZE / 4);

sys/dev/iwx/if_iwxvar.h

308

#define IWX_CMD_RESP_MAX PAGE_SIZE

sys/dev/ixgbe/if_ix.c

1173

scctx->isc_tx_tso_segsize_max = PAGE_SIZE;

sys/dev/ixgbe/if_ix.c

451

.isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */

sys/dev/ixgbe/if_ix.c

453

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/ixgbe/if_ix.c

455

.isc_tso_maxsegsize = PAGE_SIZE,

sys/dev/ixgbe/if_ix.c

456

.isc_rx_maxsize = PAGE_SIZE*4,

sys/dev/ixgbe/if_ix.c

458

.isc_rx_maxsegsize = PAGE_SIZE*4,

sys/dev/ixgbe/if_ixv.c

212

.isc_q_align = PAGE_SIZE,/* max(DBA_ALIGN, PAGE_SIZE) */

sys/dev/ixgbe/if_ixv.c

214

.isc_tx_maxsegsize = PAGE_SIZE,

sys/dev/ixgbe/if_ixv.c

216

.isc_tso_maxsegsize = PAGE_SIZE,

sys/dev/ixgbe/if_ixv.c

508

scctx->isc_tx_tso_segsize_max = PAGE_SIZE;

sys/dev/ixl/if_ixl.c

327

.isc_q_align = PAGE_SIZE,

sys/dev/lge/if_lge.c

499

M_NOWAIT | M_ZERO, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/lge/if_lge.c

731

M_NOWAIT, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/lge/if_lgereg.h

488

#define LGE_JPAGESZ PAGE_SIZE

sys/dev/liquidio/base/lio_request_manager.c

88

PAGE_SIZE, /* maxsegsize */

sys/dev/liquidio/lio_main.c

1339

if_sethwtsomaxsegsize(ifp, PAGE_SIZE);

sys/dev/liquidio/lio_network.h

197

align = PAGE_SIZE << lio_get_order(size);

sys/dev/malo/if_malo.c

447

PAGE_SIZE, 0, /* alignment, bounds */

sys/dev/malo/if_malo.h

53

#define MALO_RXSIZE PAGE_SIZE

sys/dev/malo/if_malohal.c

119

PAGE_SIZE, 0, /* alignment, bounds */

sys/dev/mana/gdma.h

273

#define MINIMUM_SUPPORTED_PAGE_SIZE PAGE_SIZE

sys/dev/mana/gdma_main.c

224

if (length < PAGE_SIZE || !powerof2(length))

sys/dev/mana/gdma_main.c

228

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/mana/gdma_main.c

932

unsigned int num_page = gmi->length / PAGE_SIZE;

sys/dev/mana/gdma_main.c

942

if (length < PAGE_SIZE || !powerof2(length)) {

sys/dev/mana/gdma_main.c

971

req->page_addr_list[i] = gmi->dma_handle + i * PAGE_SIZE;

sys/dev/mana/hw_channel.c

476

buf_size = ALIGN(q_depth * max_msg_size, PAGE_SIZE);

sys/dev/mana/mana.h

124

#define EQ_SIZE (8 * PAGE_SIZE)

sys/dev/mana/mana.h

205

#define MANA_TSO_MAXSEG_SZ PAGE_SIZE

sys/dev/mana/mana_en.c

2099

KASSERT(IS_ALIGNED(txq_size, PAGE_SIZE),

sys/dev/mana/mana_en.c

2103

cq_size = ALIGN(cq_size, PAGE_SIZE);

sys/dev/mana/mana_en.c

2452

rq_size = ALIGN(rq_size, PAGE_SIZE);

sys/dev/mana/mana_en.c

2453

cq_size = ALIGN(cq_size, PAGE_SIZE);

sys/dev/mana/mana_en.c

2980

if_sethwtsomaxsegsize(ndev, PAGE_SIZE);

sys/dev/mana/shm_channel.c

195

if (!IS_ALIGNED(eq_addr, PAGE_SIZE) ||

sys/dev/mana/shm_channel.c

196

!IS_ALIGNED(cq_addr, PAGE_SIZE) ||

sys/dev/mana/shm_channel.c

197

!IS_ALIGNED(rq_addr, PAGE_SIZE) ||

sys/dev/mana/shm_channel.c

198

!IS_ALIGNED(sq_addr, PAGE_SIZE))

sys/dev/md/md.c

1070

offs = bp->bio_offset % PAGE_SIZE;

sys/dev/md/md.c

1071

lastp = (bp->bio_offset + bp->bio_length - 1) / PAGE_SIZE;

sys/dev/md/md.c

1072

lastend = (bp->bio_offset + bp->bio_length - 1) % PAGE_SIZE + 1;

sys/dev/md/md.c

1076

for (i = bp->bio_offset / PAGE_SIZE; i <= lastp; i++) {

sys/dev/md/md.c

1077

len = ((i == lastp) ? lastend : PAGE_SIZE) - offs;

sys/dev/md/md.c

1113

if (len == PAGE_SIZE || vm_page_all_valid(m))

sys/dev/md/md.c

1139

if (len == PAGE_SIZE || vm_page_all_valid(m))

sys/dev/md/md.c

1154

if (len != PAGE_SIZE) {

sys/dev/md/md.c

1179

p += PAGE_SIZE - offs;

sys/dev/md/md.c

1516

sc->s_vnode.kva = kva_alloc(maxphys + PAGE_SIZE);

sys/dev/md/md.c

1571

kva_free(sc->s_vnode.kva, maxphys + PAGE_SIZE);

sys/dev/md/md.c

1610

(mdr->md_mediasize % PAGE_SIZE) != 0)

sys/dev/md/md.c

1665

if (sc->mediasize <= 0 || (sc->mediasize % PAGE_SIZE) != 0)

sys/dev/md/md.c

1676

npage = mdr->md_mediasize / PAGE_SIZE;

sys/dev/md/md.c

1682

PAGE_SIZE * npage, VM_PROT_DEFAULT, 0, td->td_ucred);

sys/dev/md/md.c

1709

if (sc->mediasize <= 0 || (sc->mediasize % PAGE_SIZE) != 0)

sys/dev/md/md.c

236

#define NINDIR (PAGE_SIZE / sizeof(uintptr_t))

sys/dev/md/md.c

534

sz = imin(PAGE_SIZE - *ma_offs, n);

sys/dev/md/md.c

580

*ma_offs %= PAGE_SIZE;

sys/dev/md/md.c

982

KASSERT(npages <= atop(maxphys + PAGE_SIZE),

sys/dev/mfi/mfi.c

1023

sc->mfi_max_io = (sc->mfi_max_sge - 1) * PAGE_SIZE /

sys/dev/mfi/mfi.c

471

sc->mfi_max_sge = min(max_fw_sge, ((MFI_MAXPHYS / PAGE_SIZE) + 1));

sys/dev/mfi/mfi_disk.c

156

(sc->ld_controller->mfi_max_sge - 1) * PAGE_SIZE);

sys/dev/mfi/mfi_syspd.c

130

(sc->pd_controller->mfi_max_sge - 1) * PAGE_SIZE);

sys/dev/mgb/if_mgb.c

286

.isc_q_align = PAGE_SIZE,

sys/dev/mlx4/device.h

1081

(offset & (PAGE_SIZE - 1));

sys/dev/mlx4/device.h

650

MLX4_DB_PER_PAGE = PAGE_SIZE / 4

sys/dev/mlx4/mlx4_core/mlx4_alloc.c

611

buf->nbufs = (size + PAGE_SIZE - 1) / PAGE_SIZE;

sys/dev/mlx4/mlx4_core/mlx4_alloc.c

622

PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_alloc.c

629

memset(buf->page_list[i].buf, 0, PAGE_SIZE);

sys/dev/mlx4/mlx4_core/mlx4_alloc.c

670

PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_alloc.c

690

pgdir->db_page = dma_alloc_coherent(dma_device, PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_alloc.c

780

dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_cmd.c

2477

dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_cmd.c

2512

PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_cmd.c

2605

dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_eq.c

1002

memset(eq->page_list[i].buf, 0, PAGE_SIZE);

sys/dev/mlx4/mlx4_core/mlx4_eq.c

1055

dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_eq.c

1078

int npages = PAGE_ALIGN(dev->caps.eqe_size * eq->nent) / PAGE_SIZE;

sys/dev/mlx4/mlx4_core/mlx4_eq.c

1088

dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,

sys/dev/mlx4/mlx4_core/mlx4_eq.c

118

return eq->page_list[offset / PAGE_SIZE].buf + (offset + (eqe_factor ? MLX4_EQ_ENTRY_SIZE : 0)) % PAGE_SIZE;

sys/dev/mlx4/mlx4_core/mlx4_eq.c

972

npages = PAGE_ALIGN(eq->nent * dev->caps.eqe_size) / PAGE_SIZE;

sys/dev/mlx4/mlx4_core/mlx4_eq.c

994

PAGE_SIZE, &t,

sys/dev/mlx4/mlx4_core/mlx4_fw.c

1713

#if MLX4_ICM_PAGE_SIZE < PAGE_SIZE

sys/dev/mlx4/mlx4_core/mlx4_fw.c

1715

ALIGN(fw->fw_pages, PAGE_SIZE / MLX4_ICM_PAGE_SIZE) >>

sys/dev/mlx4/mlx4_core/mlx4_fw.c

2554

#if MLX4_ICM_PAGE_SIZE < PAGE_SIZE

sys/dev/mlx4/mlx4_core/mlx4_fw.c

2555

*aux_pages = ALIGN(*aux_pages, PAGE_SIZE / MLX4_ICM_PAGE_SIZE) >>

sys/dev/mlx4/mlx4_core/mlx4_fw.c

943

if ((1 << (field & 0x3f)) > (PAGE_SIZE / dev_cap->bf_reg_size))

sys/dev/mlx4/mlx4_core/mlx4_icm.c

110

sg_set_page(mem, page, PAGE_SIZE << order, 0);

sys/dev/mlx4/mlx4_core/mlx4_icm.c

117

void *buf = dma_alloc_coherent(dev, PAGE_SIZE << order,

sys/dev/mlx4/mlx4_core/mlx4_icm.c

122

sg_set_buf(mem, buf, PAGE_SIZE << order);

sys/dev/mlx4/mlx4_core/mlx4_icm.c

124

sg_dma_len(mem) = PAGE_SIZE << order;

sys/dev/mlx4/mlx4_core/mlx4_main.c

2631

priv->kar = ioremap((phys_addr_t) priv->driver_uar.pfn << PAGE_SHIFT, PAGE_SIZE);

sys/dev/mlx4/mlx4_core/mlx4_main.c

357

if (dev_cap->min_page_sz > PAGE_SIZE) {

sys/dev/mlx4/mlx4_core/mlx4_main.c

359

dev_cap->min_page_sz, (long)PAGE_SIZE);

sys/dev/mlx4/mlx4_core/mlx4_main.c

390

dev->caps.uar_page_size = PAGE_SIZE;

sys/dev/mlx4/mlx4_core/mlx4_main.c

391

dev->caps.num_uars = dev_cap->uar_size / PAGE_SIZE;

sys/dev/mlx4/mlx4_core/mlx4_main.c

849

if (page_size > PAGE_SIZE) {

sys/dev/mlx4/mlx4_core/mlx4_main.c

851

page_size, (long)PAGE_SIZE);

sys/dev/mlx4/mlx4_core/mlx4_main.c

872

dev->caps.uar_page_size = PAGE_SIZE;

sys/dev/mlx4/mlx4_core/mlx4_mr.c

1062

if (max_pages * sizeof *fmr->mtts > PAGE_SIZE)

sys/dev/mlx4/mlx4_core/mlx4_mr.c

732

mtts_per_page = PAGE_SIZE / sizeof(u64);

sys/dev/mlx4/mlx4_core/mlx4_pd.c

202

uar->map = ioremap(uar->pfn << PAGE_SHIFT, PAGE_SIZE);

sys/dev/mlx4/mlx4_core/mlx4_pd.c

210

PAGE_SIZE);

sys/dev/mlx4/mlx4_core/mlx4_profile.c

121

profile[i].size = max(profile[i].size, (u64) PAGE_SIZE);

sys/dev/mlx4/mlx4_en/en.h

121

#define MLX4_EN_ALLOC_SIZE PAGE_ALIGN(PAGE_SIZE)

sys/dev/mlx4/mlx4_en/mlx4_en_cq.c

92

cq->buf_size, 2 * PAGE_SIZE);

sys/dev/mlx4/mlx4_en/mlx4_en_main.c

196

PAGE_SIZE);

sys/dev/mlx4/mlx4_en/mlx4_en_netdev.c

2545

data = kmalloc(PAGE_SIZE, GFP_KERNEL);

sys/dev/mlx4/mlx4_en/mlx4_en_rx.c

433

ring->buf_size, 2 * PAGE_SIZE);

sys/dev/mlx4/mlx4_en/mlx4_en_tx.c

127

2 * PAGE_SIZE);

sys/dev/mlx4/mlx4_ib/mlx4_ib_cq.c

107

PAGE_SIZE * 2, &buf->buf, GFP_KERNEL);

sys/dev/mlx4/mlx4_ib/mlx4_ib_doorbell.c

65

PAGE_SIZE, 0, 0);

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1102

PAGE_SIZE,

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1113

PAGE_SIZE, pgprot_writecombine(vma->vm_page_prot),

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

1130

PAGE_SIZE, pgprot_noncached(vma->vm_page_prot),

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

2455

PAGE_SIZE);

sys/dev/mlx4/mlx4_ib/mlx4_ib_main.c

567

resp.hca_core_clock_offset = clock_params.offset % PAGE_SIZE;

sys/dev/mlx4/mlx4_ib/mlx4_ib_mr.c

118

if (i == PAGE_SIZE / sizeof (u64)) {

sys/dev/mlx4/mlx4_ib/mlx4_ib_qp.c

807

PAGE_SIZE * 2, &qp->buf, gfp)) {

sys/dev/mlx4/mlx4_ib/mlx4_ib_srq.c

138

if (mlx4_buf_alloc(dev->dev, buf_size, PAGE_SIZE * 2, &srq->buf,

sys/dev/mlx5/device.h

260

MLX5_UARS_IN_PAGE = PAGE_SIZE / MLX5_ADAPTER_PAGE_SIZE,

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

111

PAGE_SIZE * buf->npages, &mlx5_buf_load_mem_cb,

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

125

memset(buf->direct.buf, 0, PAGE_SIZE * buf->npages);

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

59

KASSERT(segs[x].ds_len == PAGE_SIZE, ("Invalid segment size"));

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

77

buf->npages = howmany(size, PAGE_SIZE);

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

86

PAGE_SIZE, /* alignment */

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

91

PAGE_SIZE * buf->npages, /* maxsize */

sys/dev/mlx5/mlx5_core/mlx5_alloc.c

93

PAGE_SIZE, /* maxsegsize */

sys/dev/mlx5/mlx5_core/mlx5_cmd.c

55

LONG_LIST_SIZE = (2ULL * 1024 * 1024 * 1024 / PAGE_SIZE) * 8 + 16 +

sys/dev/mlx5/mlx5_core/mlx5_eq.c

444

err = mlx5_buf_alloc(dev, eq->nent * MLX5_EQE_SIZE, 2 * PAGE_SIZE,

sys/dev/mlx5/mlx5_core/mlx5_main.c

515

if (MLX5_CAP_GEN_MAX(dev, uar_4k) && PAGE_SIZE > 4096)

sys/dev/mlx5/mlx5_core/mlx5_pagealloc.c

35

CTASSERT((uintptr_t)PAGE_MASK > (uintptr_t)PAGE_SIZE);

sys/dev/mlx5/mlx5_core/mlx5_uar.c

134

up->map = ioremap_wc(pfn << PAGE_SHIFT, PAGE_SIZE);

sys/dev/mlx5/mlx5_core/mlx5_uar.c

140

up->map = ioremap(pfn << PAGE_SHIFT, PAGE_SIZE);

sys/dev/mlx5/mlx5_en/mlx5_en_hw_tls_rx.c

283

CTASSERT(MLX5E_TLS_RX_PROGRESS_BUFFER_SIZE <= PAGE_SIZE);

sys/dev/mlx5/mlx5_en/mlx5_en_iq.c

193

PAGE_SIZE, /* maxsize */

sys/dev/mlx5/mlx5_en/mlx5_en_iq.c

195

PAGE_SIZE, /* maxsegsize */

sys/dev/mlx5/mlx5_ib/mlx5_ib_cq.c

735

2 * PAGE_SIZE, &buf->buf);

sys/dev/mlx5/mlx5_ib/mlx5_ib_doorbell.c

63

PAGE_SIZE, 0, 0);

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1123

if (uars_per_sys_page == 1 && PAGE_SIZE > 4096)

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1390

if (PAGE_SIZE <= 4096) {

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1394

offsetof(struct mlx5_init_seg, internal_timer_h) % PAGE_SIZE;

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1512

if ((vma->vm_end - vma->vm_start != PAGE_SIZE) ||

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1559

if (vma->vm_end - vma->vm_start != PAGE_SIZE)

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1623

err = rdma_user_mmap_io(&context->ibucontext, vma, pfn, PAGE_SIZE,

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1683

entry->npages * PAGE_SIZE,

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1712

if (vma->vm_end - vma->vm_start != PAGE_SIZE)

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1719

if (PAGE_SIZE > 4096)

sys/dev/mlx5/mlx5_ib/mlx5_ib_main.c

1726

PAGE_SIZE,

sys/dev/mlx5/mlx5_ib/mlx5_ib_mr.c

779

size = min_t(int, PAGE_SIZE, size);

sys/dev/mlx5/mlx5_ib/mlx5_ib_qp.c

962

2 * PAGE_SIZE, &qp->buf);

sys/dev/mlx5/mlx5_ib/mlx5_ib_srq.c

169

if (mlx5_buf_alloc(dev->mdev, buf_size, 2 * PAGE_SIZE, &srq->buf)) {

sys/dev/mmc/host/dwmmc.c

132

#define IDMAC_DESC_SEGS (PAGE_SIZE / (sizeof(struct idmac_desc)))

sys/dev/mpi3mr/mpi3mr.c

2549

if (sc->max_sgl_entries > sc->facts.max_data_length / PAGE_SIZE)

sys/dev/mpi3mr/mpi3mr.c

2550

sc->max_sgl_entries = sc->facts.max_data_length / PAGE_SIZE;

sys/dev/mpi3mr/mpi3mr_cam.c

1156

if (csio->dxfer_len > (sc->max_sgl_entries * PAGE_SIZE)) {

sys/dev/mpi3mr/mpi3mr_cam.c

1361

cpi->maxio = PAGE_SIZE * (sc->max_sgl_entries - 1);

sys/dev/mpi3mr/mpi3mr_pci.c

181

sc->max_sgl_entries = maxphys / PAGE_SIZE;

sys/dev/mpr/mpr.c

1515

BD_MAXSEGSIZE(rsize), BD_NSEGMENTS((howmany(rsize, PAGE_SIZE))),

sys/dev/mpr/mpr.c

1563

nsegs = (sc->maxio / PAGE_SIZE) + 1;

sys/dev/mpr/mpr.c

1647

PRPs_required = sc->maxio / PAGE_SIZE;

sys/dev/mpr/mpr.c

1648

PRPs_per_page = (PAGE_SIZE / PRP_ENTRY_SIZE) - 1;

sys/dev/mpr/mpr.c

1651

sc->prp_buffer_size = PAGE_SIZE * pages_required;

sys/dev/mpr/mpr.c

2970

page_mask = PAGE_SIZE - 1;

sys/dev/mpr/mpr.c

3025

entry_len = PAGE_SIZE - offset;

sys/dev/mpr/mpr.c

3048

if (length > PAGE_SIZE)

sys/dev/mpr/mpr.c

3144

page_mask = PAGE_SIZE - 1;

sys/dev/mpr/mpr.c

3167

if (buff_len > (PAGE_SIZE * 5))

sys/dev/mpr/mpr.c

3169

else if ((buff_len > (PAGE_SIZE * 4)) &&

sys/dev/mpr/mpr.c

3170

(buff_len <= (PAGE_SIZE * 5)) )

sys/dev/mpr/mpr.c

3176

first_page_data_size = PAGE_SIZE - first_page_offset;

sys/dev/mpr/mpr.c

3177

end_residual = buff_len % PAGE_SIZE;

sys/dev/mpr/mpr.c

3192

(buff_len - (PAGE_SIZE * 4)))

sys/dev/mpr/mpr.c

3334

entry_len = PAGE_SIZE - offset;

sys/dev/mpr/mpr.c

433

maxio = (sges_per_frame * sc->facts->MaxChainDepth + 1) * PAGE_SIZE;

sys/dev/mpr/mpr.c

440

maxio = min(maxio, sc->max_io_pages * PAGE_SIZE);

sys/dev/mpr/mpr.c

447

sc->num_chains = (maxio / PAGE_SIZE + sges_per_frame - 2) /

sys/dev/mps/mps.c

1455

BD_NSEGMENTS(howmany(rsize, PAGE_SIZE)),

sys/dev/mps/mps.c

1493

nsegs = (sc->maxio / PAGE_SIZE) + 1;

sys/dev/mps/mps.c

412

maxio = (sges_per_frame * sc->facts->MaxChainDepth + 1) * PAGE_SIZE;

sys/dev/mps/mps.c

419

maxio = min(maxio, sc->max_io_pages * PAGE_SIZE);

sys/dev/mps/mps.c

426

sc->num_chains = (maxio / PAGE_SIZE + sges_per_frame - 2) /

sys/dev/mpt/mpt.c

2523

NULL, NULL, (mpt->max_cam_seg_cnt - 1) * PAGE_SIZE,

sys/dev/mpt/mpt.c

2531

if (mpt_dma_tag_create(mpt, mpt->parent_dmat, PAGE_SIZE, 0,

sys/dev/mpt/mpt.c

2897

(pptr + MPT_REPLY_SIZE) < (mpt->reply_phys + PAGE_SIZE);

sys/dev/mpt/mpt_cam.c

3521

cpi->maxio = (mpt->max_cam_seg_cnt - 1) * PAGE_SIZE;

sys/dev/mpt/mpt_pci.c

671

if (mpt_dma_tag_create(mpt, mpt->parent_dmat, PAGE_SIZE, 0,

sys/dev/mpt/mpt_pci.c

673

NULL, NULL, 2 * PAGE_SIZE, 1, BUS_SPACE_MAXSIZE_32BIT, 0,

sys/dev/mpt/mpt_pci.c

683

(u_long) (2 * PAGE_SIZE));

sys/dev/mpt/mpt_pci.c

692

2 * PAGE_SIZE, mpt_map_rquest, &mi, 0);

sys/dev/mthca/mthca_allocator.c

116

#define MTHCA_ARRAY_MASK (PAGE_SIZE / sizeof (void *) - 1)

sys/dev/mthca/mthca_allocator.c

162

int npage = (nent * sizeof (void *) + PAGE_SIZE - 1) / PAGE_SIZE;

sys/dev/mthca/mthca_allocator.c

181

for (i = 0; i < (nent * sizeof (void *) + PAGE_SIZE - 1) / PAGE_SIZE; ++i)

sys/dev/mthca/mthca_allocator.c

231

npages = (size + PAGE_SIZE - 1) / PAGE_SIZE;

sys/dev/mthca/mthca_allocator.c

248

dma_alloc_coherent(&dev->pdev->dev, PAGE_SIZE,

sys/dev/mthca/mthca_allocator.c

294

for (i = 0; i < (size + PAGE_SIZE - 1) / PAGE_SIZE; ++i)

sys/dev/mthca/mthca_allocator.c

295

dma_free_coherent(&dev->pdev->dev, PAGE_SIZE,

sys/dev/mthca/mthca_cmd.c

1597

#if MTHCA_ICM_PAGE_SIZE < PAGE_SIZE

sys/dev/mthca/mthca_cmd.c

1598

*aux_pages = ALIGN(*aux_pages, PAGE_SIZE / MTHCA_ICM_PAGE_SIZE) >>

sys/dev/mthca/mthca_cmd.c

859

#if MTHCA_ICM_PAGE_SIZE < PAGE_SIZE

sys/dev/mthca/mthca_cmd.c

861

ALIGN(dev->fw.arbel.fw_pages, PAGE_SIZE / MTHCA_ICM_PAGE_SIZE) >>

sys/dev/mthca/mthca_cq.c

165

return buf->queue.page_list[entry * MTHCA_CQ_ENTRY_SIZE / PAGE_SIZE].buf

sys/dev/mthca/mthca_cq.c

166

+ (entry * MTHCA_CQ_ENTRY_SIZE) % PAGE_SIZE;

sys/dev/mthca/mthca_cq.c

50

MTHCA_MAX_DIRECT_CQ_SIZE = 4 * PAGE_SIZE

sys/dev/mthca/mthca_eq.c

231

return eq->page_list[off / PAGE_SIZE].buf + off % PAGE_SIZE;

sys/dev/mthca/mthca_eq.c

480

npages = ALIGN(eq->nent * MTHCA_EQ_ENTRY_SIZE, PAGE_SIZE) / PAGE_SIZE;

sys/dev/mthca/mthca_eq.c

501

PAGE_SIZE, &t, GFP_KERNEL);

sys/dev/mthca/mthca_eq.c

520

0, npages * PAGE_SIZE,

sys/dev/mthca/mthca_eq.c

573

dma_free_coherent(&dev->pdev->dev, PAGE_SIZE,

sys/dev/mthca/mthca_eq.c

593

int npages = (eq->nent * MTHCA_EQ_ENTRY_SIZE + PAGE_SIZE - 1) /

sys/dev/mthca/mthca_eq.c

594

PAGE_SIZE;

sys/dev/mthca/mthca_eq.c

620

pci_free_consistent(dev->pdev, PAGE_SIZE,

sys/dev/mthca/mthca_eq.c

743

PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

sys/dev/mthca/mthca_eq.c

751

pci_unmap_page(dev->pdev, dev->eq_table.icm_dma, PAGE_SIZE,

sys/dev/mthca/mthca_eq.c

762

pci_unmap_page(dev->pdev, dev->eq_table.icm_dma, PAGE_SIZE,

sys/dev/mthca/mthca_main.c

176

if (dev_lim->min_page_sz > PAGE_SIZE) {

sys/dev/mthca/mthca_main.c

179

dev_lim->min_page_sz, (long)PAGE_SIZE);

sys/dev/mthca/mthca_main.c

321

profile.num_uar = dev_lim.uar_size / PAGE_SIZE;

sys/dev/mthca/mthca_main.c

611

profile.num_uar = dev_lim.uar_size / PAGE_SIZE;

sys/dev/mthca/mthca_main.c

715

dev->kar = ioremap((phys_addr_t) dev->driver_uar.pfn << PAGE_SHIFT, PAGE_SIZE);

sys/dev/mthca/mthca_memfree.c

118

sg_set_page(mem, page, PAGE_SIZE << order, 0);

sys/dev/mthca/mthca_memfree.c

125

void *buf = dma_alloc_coherent(dev, PAGE_SIZE << order, &sg_dma_address(mem),

sys/dev/mthca/mthca_memfree.c

130

sg_set_buf(mem, buf, PAGE_SIZE << order);

sys/dev/mthca/mthca_memfree.c

132

sg_dma_len(mem) = PAGE_SIZE << order;

sys/dev/mthca/mthca_mr.c

309

return PAGE_SIZE / sizeof (u64) - 2;

sys/dev/mthca/mthca_mr.c

312

return mthca_is_memfree(dev) ? (PAGE_SIZE / sizeof (u64)) : 0x7ffffff;

sys/dev/mthca/mthca_mr.c

339

BUG_ON(s / PAGE_SIZE != (s + list_len * sizeof(u64) - 1) / PAGE_SIZE);

sys/dev/mthca/mthca_mr.c

583

mr->attr.max_pages * sizeof *mr->mem.arbel.mtts > PAGE_SIZE)

sys/dev/mthca/mthca_profile.c

119

profile[i].size = max(profile[i].size, (u64) PAGE_SIZE);

sys/dev/mthca/mthca_provider.c

351

if (vma->vm_end - vma->vm_start != PAGE_SIZE)

sys/dev/mthca/mthca_provider.c

358

PAGE_SIZE, vma->vm_page_prot))

sys/dev/mthca/mthca_provider.c

902

write_mtt_size = min(mthca_write_mtt_size(dev), (int) (PAGE_SIZE / sizeof *pages));

sys/dev/mthca/mthca_qp.c

214

((n << qp->rq.wqe_shift) & (PAGE_SIZE - 1));

sys/dev/mthca/mthca_qp.c

227

(PAGE_SIZE - 1));

sys/dev/mthca/mthca_qp.c

53

MTHCA_MAX_DIRECT_QP_SIZE = 4 * PAGE_SIZE,

sys/dev/mthca/mthca_srq.c

47

MTHCA_MAX_DIRECT_SRQ_SIZE = 4 * PAGE_SIZE

sys/dev/mthca/mthca_srq.c

80

((n << srq->wqe_shift) & (PAGE_SIZE - 1));

sys/dev/mvs/mvs.c

370

MVS_SG_ENTRIES * PAGE_SIZE, MVS_SG_ENTRIES, MVS_EPRD_MAX,

sys/dev/mwl/if_mwl.c

1944

PAGE_SIZE, 0, /* alignment, bounds */

sys/dev/mwl/if_mwl.c

2123

jumbosize = roundup(MWL_AGGR_SIZE, PAGE_SIZE);

sys/dev/mwl/if_mwl.c

2127

PAGE_SIZE, 0, /* alignment, bounds */

sys/dev/mwl/mwlhal.c

300

PAGE_SIZE, 0, /* alignment, bounds */

sys/dev/mxge/if_mxge.c

418

va = pmap_mapdev(trunc_page((vm_paddr_t)off), PAGE_SIZE);

sys/dev/mxge/if_mxge.c

433

pmap_unmapdev(va, PAGE_SIZE);

sys/dev/mxge/if_mxge.c

442

pmap_unmapdev(va, PAGE_SIZE);

sys/dev/mxge/if_mxge.c

446

pmap_unmapdev(va, PAGE_SIZE);

sys/dev/netmap/if_ptnet.c

320

if (sc->num_rings * sizeof(struct nm_csb_atok) > PAGE_SIZE) {

sys/dev/netmap/if_ptnet.c

328

sc->csb_gh = contigmalloc(2*PAGE_SIZE, M_DEVBUF, M_NOWAIT | M_ZERO,

sys/dev/netmap/if_ptnet.c

329

(size_t)0, -1UL, PAGE_SIZE, 0);

sys/dev/netmap/if_ptnet.c

335

sc->csb_hg = (struct nm_csb_ktoa *)(((char *)sc->csb_gh) + PAGE_SIZE);

sys/dev/netmap/netmap.c

3985

na->rx_buf_maxsize = PAGE_SIZE;

sys/dev/netmap/netmap_freebsd.c

664

e->scan += PAGE_SIZE;

sys/dev/netmap/netmap_mem2.c

1380

delta = used % PAGE_SIZE;

sys/dev/netmap/netmap_mem2.c

1457

M_NOWAIT | M_ZERO, (size_t)0, -1UL, PAGE_SIZE, 0);

sys/dev/netmap/netmap_mem2.c

1463

ds, M_NOWAIT | M_ZERO, (size_t)0, -1UL, PAGE_SIZE, 0);

sys/dev/netmap/netmap_mem2.c

1662

nmd->nm_totalsize = (nmd->nm_totalsize + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1);

sys/dev/netmap/netmap_mem2.c

2442

if (noff < PAGE_SIZE) {

sys/dev/netmap/netmap_mem2.c

2447

while (noff >= PAGE_SIZE) {

sys/dev/netmap/netmap_mem2.c

2449

noff -= PAGE_SIZE;

sys/dev/netmap/netmap_mem2.c

2456

old_clust + PAGE_SIZE != clust))

sys/dev/netmap/netmap_mem2.c

522

.size = 5*PAGE_SIZE,

sys/dev/netmap/netmap_mem2.c

550

.objmaxsize = 32*PAGE_SIZE,

sys/dev/netmap/netmap_mem2.c

569

.size = 9*PAGE_SIZE,

sys/dev/netmap/netmap_mem2.c

606

.objmaxsize = 32*PAGE_SIZE,

sys/dev/nvdimm/nvdimm_spa.c

208

n = PAGE_SIZE;

sys/dev/nvdimm/nvdimm_spa.c

302

trunc_page(bp->bio_offset) + PAGE_SIZE * i, mattr);

sys/dev/nvme/nvme_ctrlr.c

882

max = (uint64_t)physmem * PAGE_SIZE / 20;

sys/dev/nvme/nvme_ctrlr.c

953

PAGE_SIZE, 0, BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,

sys/dev/nvme/nvme_ns.c

414

child->bio_bcount, PAGE_SIZE);

sys/dev/nvmf/controller/nvmft_subr.c

41

mps = ffs(PAGE_SIZE) - 1;

sys/dev/oce/oce_queue.c

239

PAGE_SIZE, 0, NULL, NULL, &wq->tag);

sys/dev/ocs_fc/ocs_cam.c

2152

cpi->maxio = PAGE_SIZE *

sys/dev/pci/controller/pci_n1sdp.c

67

_Static_assert(BDF_TABLE_SIZE >= PAGE_SIZE,

sys/dev/pci/controller/pci_n1sdp.c

89

vm_page_t m[BDF_TABLE_SIZE / PAGE_SIZE];

sys/dev/pci/controller/pci_n1sdp.c

99

m[i] = PHYS_TO_VM_PAGE(paddr + i * PAGE_SIZE);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

166

i += careful_write(buf, i, PAGE_SIZE, "%4d: ", pCard->dek_index[table]);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

169

i += careful_write(buf, i, PAGE_SIZE, "%02x", p[j]);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

171

i += careful_write(buf, i, PAGE_SIZE, "\n");

sys/dev/pms/freebsd/driver/common/lxencrypt.c

173

i += careful_write(buf, i, PAGE_SIZE, "Bad DEK index %d; range: 0 - %d\n", pCard->dek_index[table], DEK_MAX_TABLE_ITEMS);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

178

if (i > PAGE_SIZE)

sys/dev/pms/freebsd/driver/common/lxencrypt.c

179

i = PAGE_SIZE;

sys/dev/pms/freebsd/driver/common/lxencrypt.c

232

i += careful_write(buf, i, PAGE_SIZE, " %4d: %08x ", kek_index, pCard->kek_table[kek_index].wrapperIndex);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

235

i += careful_write(buf, i, PAGE_SIZE, "%02x", p[j]);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

237

i += careful_write(buf, i, PAGE_SIZE, "\n");

sys/dev/pms/freebsd/driver/common/lxencrypt.c

239

i += careful_write(buf, i, PAGE_SIZE, "\n");

sys/dev/pms/freebsd/driver/common/lxencrypt.c

243

if (i > PAGE_SIZE)

sys/dev/pms/freebsd/driver/common/lxencrypt.c

244

i = PAGE_SIZE;

sys/dev/pms/freebsd/driver/common/lxencrypt.c

270

i += careful_write(buf, i, PAGE_SIZE, "Table %d\n", table);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

271

i += careful_write(buf, i, PAGE_SIZE, "=======\n");

sys/dev/pms/freebsd/driver/common/lxencrypt.c

273

i += careful_write(buf, i, PAGE_SIZE, " %4d: %08x\n", dek_index, pCard->dek_kek_map[table][dek_index].kekIndex);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

279

if (i > PAGE_SIZE)

sys/dev/pms/freebsd/driver/common/lxencrypt.c

280

i = PAGE_SIZE;

sys/dev/pms/freebsd/driver/common/lxencrypt.c

344

i += careful_write(buf, i, PAGE_SIZE, " %u:%u:%u: %x %8x %8x %16lx %16lx %08x:%08x %1x\n", chan, device, lun, p->dekTable, p->dekIndex, p->kekIndex, p->lbaMin, p->lbaMax, p->keyTag[1], p->keyTag[0], p->keyTagCheck);

sys/dev/pms/freebsd/driver/common/lxencrypt.c

353

if (i > PAGE_SIZE)

sys/dev/pms/freebsd/driver/common/lxencrypt.c

354

i = PAGE_SIZE;

sys/dev/pms/freebsd/driver/common/lxencrypt.c

56

static char s[PAGE_SIZE]; /* Assumes serialization */

sys/dev/pms/freebsd/driver/common/lxencrypt.c

62

s[PAGE_SIZE - 1] = '\0';

sys/dev/pms/freebsd/driver/common/lxencrypt.c

65

i = vsnprintf(s, PAGE_SIZE - 1, fmt, args);

sys/dev/pms/freebsd/driver/ini/src/agtiapi.c

1598

maxphys, PAGE_SIZE );

sys/dev/pst/pst-iop.c

246

PAGE_SIZE, 0))) {

sys/dev/pst/pst-iop.c

260

msg->host_pagesize = PAGE_SIZE;

sys/dev/pst/pst-iop.c

297

#define ALLOCSIZE (PAGE_SIZE + (256 * sizeof(struct i2o_lct_entry)))

sys/dev/pst/pst-iop.c

300

0x00010000, 0xFFFFFFFF, PAGE_SIZE, 0)))

sys/dev/pst/pst-iop.c

343

if (!(param = contigmalloc(PAGE_SIZE, M_PSTIOP, M_NOWAIT | M_ZERO,

sys/dev/pst/pst-iop.c

344

0x00010000, 0xFFFFFFFF, PAGE_SIZE, 0)))

sys/dev/pst/pst-iop.c

347

if (!(reply = contigmalloc(PAGE_SIZE, M_PSTIOP, M_NOWAIT | M_ZERO,

sys/dev/pst/pst-iop.c

348

0x00010000, 0xFFFFFFFF, PAGE_SIZE, 0)))

sys/dev/pst/pst-iop.c

372

msg->sgl[1].count = PAGE_SIZE;

sys/dev/pst/pst-iop.c

481

sgl_count = min(count, (PAGE_SIZE - ((uintptr_t)data & PAGE_MASK)));

sys/dev/pst/pst-iop.c

491

data += min(count, PAGE_SIZE);

sys/dev/pst/pst-iop.c

492

count -= min(count, PAGE_SIZE);

sys/dev/qat/qat_common/adf_freebsd_admin.c

477

PAGE_SIZE,

sys/dev/qat/qat_common/adf_freebsd_admin.c

487

bzero(admin->virt_addr, PAGE_SIZE);

sys/dev/qat/qat_common/adf_freebsd_admin.c

550

PAGE_SIZE,

sys/dev/qat/qat_common/adf_freebsd_admin.c

564

bzero(admin->virt_hb_addr, PAGE_SIZE);

sys/dev/qat/qat_hw/qat_c4xxx/adf_c4xxx_misc_error_stats.c

83

misc_counter = kmalloc(PAGE_SIZE, GFP_KERNEL);

sys/dev/qat/qat_hw/qat_c4xxx/adf_c4xxx_misc_error_stats.c

87

memset(misc_counter, 0, PAGE_SIZE);

sys/dev/qat_c2xxx/qat_ae.c

2455

error = qat_alloc_dmamem(sc, dma, 1, mapsize, PAGE_SIZE);

sys/dev/qat_c2xxx/qat_hw15.c

196

error = qat_alloc_dmamem(sc, &qadr->qadr_dma, 1, PAGE_SIZE, PAGE_SIZE);

sys/dev/qat_c2xxx/qat_hw15.c

203

sizeof(struct fw_init_ring_table) <= PAGE_SIZE);

sys/dev/qcom_ess_edma/qcom_ess_edma_desc.c

106

hw_ring_size = ((hw_ring_size + PAGE_SIZE) / PAGE_SIZE) * PAGE_SIZE;

sys/dev/qcom_ess_edma/qcom_ess_edma_reg.h

53

#define EDMA_DESC_RING_ALIGN PAGE_SIZE

sys/dev/qlnx/qlnxe/bcm_osal.h

217

#define OSAL_DPC_ALLOC(hwfn) malloc(PAGE_SIZE, M_QLNXBUF, M_NOWAIT)

sys/dev/qlnx/qlnxe/bcm_osal.h

422

#define OSAL_PAGE_SIZE PAGE_SIZE

sys/dev/qlnx/qlnxe/qlnx_os.c

4882

size = (size + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);

sys/dev/qlnx/qlnxe/qlnx_os.c

4886

dma_buf.size = size + PAGE_SIZE;

sys/dev/qlnx/qlnxe/qlnx_os.c

4918

size = (size + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);

sys/dev/qlnx/qlnxr/qlnxr_os.c

688

if(page_size > PAGE_SIZE) {

sys/dev/qlnx/qlnxr/qlnxr_os.c

691

PAGE_SIZE, page_size);

sys/dev/qlnx/qlnxr/qlnxr_verbs.c

1045

if ((vma->vm_start & (PAGE_SIZE - 1)) || (len & (PAGE_SIZE - 1))) {

sys/dev/qlnx/qlnxr/qlnxr_verbs.c

1642

aligned_size = ALIGN(size, PAGE_SIZE);

sys/dev/qlnx/qlnxr/qlnxr_verbs.c

892

mm->key.len = roundup(len, PAGE_SIZE);

sys/dev/qlxgb/qla_hw.c

239

size = QL_ALIGN(size, PAGE_SIZE);

sys/dev/qlxgb/qla_os.c

1153

PAGE_SIZE, /* maxsegsize */

sys/dev/qlxgbe/ql_hw.c

1274

hw->dma_buf.tx_ring.size = size + PAGE_SIZE;

sys/dev/qlxgbe/ql_os.c

1693

PAGE_SIZE, /* maxsegsize */

sys/dev/qlxge/qls_dbg.c

281

(PAGE_SIZE >> 2));

sys/dev/qlxge/qls_dbg.c

293

(PAGE_SIZE >> 2));

sys/dev/qlxge/qls_def.h

145

((QLA_LBQ_SIZE + PAGE_SIZE + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1))

sys/dev/qlxge/qls_def.h

153

((QLA_SBQ_SIZE + PAGE_SIZE + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1))

sys/dev/qlxge/qls_def.h

76

PAGE_SIZE + \

sys/dev/qlxge/qls_def.h

77

(PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1))

sys/dev/qlxge/qls_hw.c

1413

(uint32_t *)(v_addr + (PAGE_SIZE >> 1));

sys/dev/qlxge/qls_hw.c

1414

ha->tx_ring[ridx].txr_cons_paddr = p_addr + (PAGE_SIZE >> 1);

sys/dev/qlxge/qls_hw.c

1416

v_addr = v_addr + (PAGE_SIZE >> 1);

sys/dev/qlxge/qls_hw.c

1417

p_addr = p_addr + (PAGE_SIZE >> 1);

sys/dev/qlxge/qls_hw.c

1447

PAGE_SIZE, /* maxsegsize */

sys/dev/qlxge/qls_hw.c

1499

ha->rss_dma.size = PAGE_SIZE;

sys/dev/qlxge/qls_hw.c

1588

(NUM_CQ_ENTRIES * (sizeof (q81_cq_e_t))) + PAGE_SIZE;

sys/dev/qlxge/qls_hw.c

1649

v_addr = v_addr + (PAGE_SIZE >> 2);

sys/dev/qlxge/qls_hw.c

1650

p_addr = p_addr + (PAGE_SIZE >> 2);

sys/dev/qlxge/qls_hw.c

1664

ha->rx_ring[ridx].lbq_vaddr = v_addr + PAGE_SIZE;

sys/dev/qlxge/qls_hw.c

1665

ha->rx_ring[ridx].lbq_paddr = p_addr + PAGE_SIZE;

sys/dev/qlxge/qls_hw.c

1675

ha->rx_ring[ridx].sbq_vaddr = v_addr + PAGE_SIZE;

sys/dev/qlxge/qls_hw.c

1676

ha->rx_ring[ridx].sbq_paddr = p_addr + PAGE_SIZE;

sys/dev/random/fortuna.c

584

chunk_size = PAGE_SIZE;

sys/dev/random/randomdev.c

162

CTASSERT(SIGCHK_PERIOD % PAGE_SIZE == 0);

sys/dev/random/randomdev.c

201

bufsize = PAGE_SIZE;

sys/dev/random/randomdev.c

332

random_buf = malloc(PAGE_SIZE, M_ENTROPY, M_WAITOK);

sys/dev/random/randomdev.c

335

c = MIN(uio->uio_resid, PAGE_SIZE);

sys/dev/rtwn/pci/rtwn_pci_attach.c

272

error = bus_dma_tag_create(bus_get_dma_tag(sc->sc_dev), PAGE_SIZE, 0,

sys/dev/safexcel/safexcel.c

838

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/sec/sec.c

853

size = PAGE_SIZE - crp->crp_buf.cb_vm_page_offset;

sys/dev/sfxge/sfxge.c

598

if_sethwtsomaxsegsize(ifp, PAGE_SIZE);

sys/dev/sfxge/sfxge_dma.c

145

if (bus_dma_tag_create(sc->parent_dma_tag, PAGE_SIZE, 0,

sys/dev/sfxge/sfxge_tx.c

1013

rc = sfxge_dma_alloc(sc, PAGE_SIZE, &txq->tsoh_buffer[i]);

sys/dev/sfxge/sfxge_tx.c

998

#define TSOH_PER_PAGE (PAGE_SIZE / TSOH_STD_SIZE)

sys/dev/siis/siis.c

690

SIIS_SG_ENTRIES * PAGE_SIZE, SIIS_SG_ENTRIES, 0xFFFFFFFF,

sys/dev/smartpqi/smartpqi_cam.c

53

cpi->maxio = (softs->pqi_cap.max_sg_elem - 1) * PAGE_SIZE;

sys/dev/smartpqi/smartpqi_main.c

330

PAGE_SIZE, 0, /* algnmnt, boundary */

sys/dev/smartpqi/smartpqi_main.c

377

(bus_size_t)softs->pqi_cap.max_sg_elem*PAGE_SIZE,/* maxsize */

sys/dev/sound/macio/aoa.c

130

dma->blksz = PAGE_SIZE; /* initial blocksize */

sys/dev/spibus/spigen.c

287

pmap_qremove(mmap->kvaddr, mmap->bufsize / PAGE_SIZE);

sys/dev/spibus/spigen.c

308

size = roundup2(size, PAGE_SIZE);

sys/dev/spibus/spigen.c

309

pages = size / PAGE_SIZE;

sys/dev/sym/sym_conf.h

99

#define SYM_CONF_MAX_SG (MIN(33, (128 * 1024 / PAGE_SIZE) + 1))

sys/dev/sym/sym_hipd.c

285

#if SYM_CONF_MAX_QUEUE > PAGE_SIZE/8

sys/dev/sym/sym_hipd.c

287

#define SYM_CONF_MAX_QUEUE PAGE_SIZE/8

sys/dev/sym/sym_hipd.c

8050

cpi->maxio = SYM_CONF_MAX_SG * PAGE_SIZE;

sys/dev/ti/if_ti.c

1146

BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE * 4, 4,

sys/dev/ti/if_ti.c

1147

PAGE_SIZE, 0, NULL, NULL, &sc->ti_cdata.ti_rx_jumbo_tag);

sys/dev/ti/if_ti.c

1554

#if (PAGE_SIZE == 4096)

sys/dev/ti/if_ti.c

1639

m[i]->m_len = PAGE_SIZE;

sys/dev/ti/if_ti.c

1640

MEXTADD(m[i], sf_buf_kva(sf[i]), PAGE_SIZE,

sys/dev/ti/if_ti.c

1652

m_new->m_pkthdr.len = NPAYLOAD * PAGE_SIZE + m_new->m_len;

sys/dev/ti/if_ti.c

1668

r->ti_len1 = PAGE_SIZE;

sys/dev/ti/if_ti.c

1673

if (PAGE_SIZE == 4096) {

sys/dev/ti/if_ti.c

2243

rcb->ti_max_len = PAGE_SIZE;

sys/dev/ti/if_tireg.h

705

#define TI_PAGE_SIZE PAGE_SIZE

sys/dev/tsec/if_tsec.c

1105

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/ufshci/ufshci_ctrlr.c

372

ctrlr->page_size = PAGE_SIZE;

sys/dev/usb/usb_busdma.h

40

#define USB_PAGE_SIZE PAGE_SIZE /* use system PAGE_SIZE */

sys/dev/usb/video/udl.c

191

CTASSERT(sizeof(struct udl_buffer) < PAGE_SIZE);

sys/dev/usb/video/udl.c

842

size = PAGE_SIZE;

sys/dev/virtio/balloon/virtio_balloon.c

130

CTASSERT(VTBALLOON_PAGES_PER_REQUEST * sizeof(uint32_t) <= PAGE_SIZE);

sys/dev/virtio/block/virtio_blk.c

389

(sc->vtblk_flags & VTBLK_FLAG_BUSDMA_ALIGN) ? PAGE_SIZE : 1,

sys/dev/virtio/block/virtio_blk.c

408

(sc->vtblk_flags & VTBLK_FLAG_BUSDMA_ALIGN) ? PAGE_SIZE :

sys/dev/virtio/block/virtio_blk.c

428

(sc->vtblk_flags & VTBLK_FLAG_BUSDMA_ALIGN) ? PAGE_SIZE :

sys/dev/virtio/block/virtio_blk.c

749

nsegs += MIN(blkcfg->seg_max, maxphys / PAGE_SIZE + 1);

sys/dev/virtio/block/virtio_blk.c

857

PAGE_SIZE;

sys/dev/virtio/block/virtio_blk.c

859

dp->d_maxsize -= PAGE_SIZE;

sys/dev/virtio/console/virtio_console.c

67

CTASSERT(VTCON_BULK_BUFSZ <= PAGE_SIZE);

sys/dev/virtio/console/virtio_console.c

68

CTASSERT(VTCON_CTRL_BUFSZ <= PAGE_SIZE);

sys/dev/virtio/network/if_vtnet.c

1152

if_sethwtsomaxsegsize(ifp, PAGE_SIZE);

sys/dev/virtio/network/if_vtnetvar.h

307

CTASSERT(sizeof(struct vtnet_mac_filter) <= PAGE_SIZE);

sys/dev/virtio/scsi/virtio_scsi.c

476

nsegs += MIN(seg_max, maxphys / PAGE_SIZE + 1);

sys/dev/virtio/scsi/virtio_scsi.c

984

PAGE_SIZE;

sys/dev/virtio/virtio.h

51

#define VIRTIO_MAX_INDIRECT ((int) (PAGE_SIZE / 16))

sys/dev/vmm/vmm_dev.c

228

c = min(uio->uio_resid, PAGE_SIZE - off);

sys/dev/vmm/vmm_mem.c

436

if (len > PAGE_SIZE - pageoff)

sys/dev/vmm/vmm_mem.c

445

PAGE_SIZE, reqprot, &m, 1);

sys/dev/vmware/pvscsi/pvscsi.c

1424

cpi->maxio = (PVSCSI_MAX_SG_ENTRIES_PER_SEGMENT / 2) * PAGE_SIZE;

sys/dev/vmware/pvscsi/pvscsi.c

1639

PVSCSI_MAX_SG_ENTRIES_PER_SEGMENT * PAGE_SIZE,

sys/dev/vmware/pvscsi/pvscsi.c

1640

PVSCSI_MAX_SG_ENTRIES_PER_SEGMENT, PAGE_SIZE, BUS_DMA_ALLOCNOW,

sys/dev/vmware/pvscsi/pvscsi.c

1679

adapter_queue_size = (sc->req_ring_num_pages * PAGE_SIZE) /

sys/dev/vmware/pvscsi/pvscsi.c

508

error = pvscsi_dma_alloc(sc, dma, num_pages * PAGE_SIZE, PAGE_SIZE);

sys/dev/vmware/pvscsi/pvscsi.h

172

(PAGE_SIZE / sizeof(struct pvscsi_ring_req_desc))

sys/dev/vmware/pvscsi/pvscsi.h

174

(PAGE_SIZE / sizeof(struct pvscs_ring_cmp_desc))

sys/dev/vmware/pvscsi/pvscsi.h

176

(PAGE_SIZE / sizeof(struct pvscsi_ring_msg_desc))

sys/dev/vmware/vmci/vmci.c

409

error = vmci_dma_malloc(PAGE_SIZE, 1,

sys/dev/vmware/vmci/vmci.c

416

PAGE_SIZE);

sys/dev/vmware/vmci/vmci_doorbell.c

301

if (max_notify_idx < PAGE_SIZE || notify_idx_count < PAGE_SIZE) {

sys/dev/vmware/vmci/vmci_doorbell.c

305

last_notify_idx_released = PAGE_SIZE;

sys/dev/vmware/vmci/vmci_doorbell.c

327

new_notify_idx = (last_notify_idx_reserved + 1) % PAGE_SIZE;

sys/dev/vmware/vmci/vmci_doorbell.c

66

static uint32_t last_notify_idx_released = PAGE_SIZE;

sys/dev/vmware/vmci/vmci_driver.c

240

current_dg_in_buffer_size = PAGE_SIZE;

sys/dev/vmware/vmci/vmci_driver.c

242

ASSERT(dg_in_buffer_size >= PAGE_SIZE);

sys/dev/vmware/vmci/vmci_driver.c

250

remaining_bytes > PAGE_SIZE) {

sys/dev/vmware/vmci/vmci_driver.c

259

ASSERT(remaining_bytes > PAGE_SIZE);

sys/dev/vmware/vmci/vmci_driver.c

261

PAGE_SIZE);

sys/dev/vmware/vmci/vmci_kernel_if.c

515

const size_t num_pages = CEILING(size, PAGE_SIZE) + 1;

sys/dev/vmware/vmci/vmci_kernel_if.c

537

vmci_dma_malloc(PAGE_SIZE, 1, &queue->kernel_if->dmas[i]);

sys/dev/vmware/vmci/vmci_kernel_if.c

540

vmci_free_queue(queue, i * PAGE_SIZE);

sys/dev/vmware/vmci/vmci_kernel_if.c

574

const size_t num_pages = CEILING(size, PAGE_SIZE) + 1;

sys/dev/vmware/vmci/vmci_kernel_if.c

825

(queue_offset + bytes_copied) / PAGE_SIZE;

sys/dev/vmware/vmci/vmci_kernel_if.c

827

(queue_offset + bytes_copied) & (PAGE_SIZE - 1);

sys/dev/vmware/vmci/vmci_kernel_if.c

839

to_copy = MIN(PAGE_SIZE - page_offset, size - bytes_copied);

sys/dev/vmware/vmci/vmci_kernel_if.c

882

(queue_offset + bytes_copied) / PAGE_SIZE;

sys/dev/vmware/vmci/vmci_kernel_if.c

884

(queue_offset + bytes_copied) & (PAGE_SIZE - 1);

sys/dev/vmware/vmci/vmci_kernel_if.c

896

to_copy = MIN(PAGE_SIZE - page_offset, size - bytes_copied);

sys/dev/vmware/vmci/vmci_queue_pair.c

416

const uint64_t num_ppns = CEILING(produce_size, PAGE_SIZE) +

sys/dev/vmware/vmci/vmci_queue_pair.c

417

CEILING(consume_size, PAGE_SIZE) +

sys/dev/vmware/vmci/vmci_queue_pair.c

45

((uint32_t)(CEILING(_QPE.produce_size, PAGE_SIZE) + \

sys/dev/vmware/vmci/vmci_queue_pair.c

46

CEILING(_QPE.consume_size, PAGE_SIZE) + 2))

sys/dev/vmware/vmci/vmci_queue_pair.c

584

const uint64_t num_consume_pages = CEILING(consume_size, PAGE_SIZE) + 1;

sys/dev/vmware/vmci/vmci_queue_pair.c

585

const uint64_t num_produce_pages = CEILING(produce_size, PAGE_SIZE) + 1;

sys/dev/xdma/controller/pl330.c

389

chan->ibuf = (void *)kmem_alloc_contig(PAGE_SIZE * 8,

sys/dev/xdma/controller/pl330.c

390

M_ZERO, 0, ~0, PAGE_SIZE, 0,

sys/dev/xdma/xdma.c

418

vmem = vmem_create("xDMA vmem", 0, 0, PAGE_SIZE,

sys/dev/xdma/xdma.c

419

PAGE_SIZE, M_BESTFIT | M_WAITOK);

sys/dev/xdma/xdma_iommu.c

106

size = roundup2(size, PAGE_SIZE);

sys/dev/xdma/xdma_iommu.c

114

addr |= pa & (PAGE_SIZE - 1);

sys/dev/xdma/xdma_iommu.c

142

xio->vmem = vmem_create("xDMA vmem", 0, 0, PAGE_SIZE,

sys/dev/xdma/xdma_iommu.c

143

PAGE_SIZE, M_FIRSTFIT | M_WAITOK);

sys/dev/xdma/xdma_iommu.c

68

va &= ~(PAGE_SIZE - 1);

sys/dev/xdma/xdma_iommu.c

69

pmap_remove(&xio->p, va, va + PAGE_SIZE);

sys/dev/xdma/xdma_iommu.c

73

vmem_free(xio->vmem, va, PAGE_SIZE);

sys/dev/xdma/xdma_iommu.c

88

for (; size > 0; size -= PAGE_SIZE) {

sys/dev/xdma/xdma_iommu.c

94

va += PAGE_SIZE;

sys/dev/xdma/xdma_iommu.c

95

pa += PAGE_SIZE;

sys/dev/xen/balloon/balloon.c

57

static xen_pfn_t frame_list[PAGE_SIZE / sizeof(xen_pfn_t)];

sys/dev/xen/blkback/blkback.c

100

__CONST_RING_SIZE(blkif, PAGE_SIZE * XBB_MAX_RING_PAGES)

sys/dev/xen/blkback/blkback.c

126

MIN(128 * 1024, BLKIF_MAX_SEGMENTS_PER_REQUEST * PAGE_SIZE)

sys/dev/xen/blkback/blkback.c

136

(XBB_MAX_REQUEST_SIZE / PAGE_SIZE) + 1)))

sys/dev/xen/blkback/blkback.c

1597

if ((sg->last_sect >= (PAGE_SIZE >> 9))

sys/dev/xen/blkback/blkback.c

1606

KASSERT(map->host_addr + PAGE_SIZE <=

sys/dev/xen/blkback/blkback.c

1610

(uintmax_t)map->host_addr, PAGE_SIZE,

sys/dev/xen/blkback/blkback.c

2074

if (xbb_sg->last_sect != (PAGE_SIZE - 512) >> 9) {

sys/dev/xen/blkback/blkback.c

2213

if (xbb_sg->last_sect != (PAGE_SIZE - 512) >> 9)

sys/dev/xen/blkback/blkback.c

2646

+ (ring_idx * PAGE_SIZE);

sys/dev/xen/blkback/blkback.c

2709

- (xbb->ring_config.ring_pages * PAGE_SIZE));

sys/dev/xen/blkback/blkback.c

2712

- (xbb->ring_config.ring_pages * PAGE_SIZE));

sys/dev/xen/blkback/blkback.c

2718

+ (ring_idx * PAGE_SIZE);

sys/dev/xen/blkback/blkback.c

2771

xbb->ring_config.ring_pages * PAGE_SIZE);

sys/dev/xen/blkback/blkback.c

2779

xbb->ring_config.ring_pages * PAGE_SIZE);

sys/dev/xen/blkback/blkback.c

2787

xbb->ring_config.ring_pages * PAGE_SIZE);

sys/dev/xen/blkback/blkback.c

2828

xbb->reqlist_kva_size = xbb->reqlist_kva_pages * PAGE_SIZE;

sys/dev/xen/blkback/blkback.c

2830

(xbb->ring_config.ring_pages * PAGE_SIZE);

sys/dev/xen/blkback/blkback.c

2883

xbb->max_request_size = xbb->max_request_segments * PAGE_SIZE;

sys/dev/xen/blkback/blkback.c

2919

ring_size = PAGE_SIZE * xbb->ring_config.ring_pages;

sys/dev/xen/blkback/blkback.c

3162

xbb->max_reqlist_size = xbb->max_reqlist_segments * PAGE_SIZE;

sys/dev/xen/blkback/blkback.c

838

return (reqlist->kva + (PAGE_SIZE * pagenr) + (sector << 9));

sys/dev/xen/blkback/blkback.c

889

(PAGE_SIZE * pagenr) + (sector << 9)));

sys/dev/xen/blkback/blkback.c

959

(uint8_t *)((intptr_t)first_clear * PAGE_SIZE);

sys/dev/xen/blkback/blkback.c

962

free_kva + (nr_pages * PAGE_SIZE) <=

sys/dev/xen/blkback/blkback.c

966

nr_pages * PAGE_SIZE, (uintmax_t)xbb->kva,

sys/dev/xen/blkfront/blkfront.c

1170

BLKIF_MAX_RING_REQUESTS(sc->xbd_ring_pages * PAGE_SIZE);

sys/dev/xen/blkfront/blkfront.c

1330

sector_size, PAGE_SIZE, /* algnmnt, boundary */

sys/dev/xen/blkfront/blkfront.c

1336

PAGE_SIZE, /* maxsegsize */

sys/dev/xen/blkfront/blkfront.c

1374

PAGE_SIZE * sc->xbd_max_request_indirectpages,

sys/dev/xen/blkfront/blkfront.c

1376

PAGE_SIZE, 0);

sys/dev/xen/blkfront/blkfront.c

757

sring = malloc(sc->xbd_ring_pages * PAGE_SIZE, M_XENBLOCKFRONT,

sys/dev/xen/blkfront/blkfront.c

764

FRONT_RING_INIT(&sc->xbd_ring, sring, sc->xbd_ring_pages * PAGE_SIZE);

sys/dev/xen/blkfront/blkfront.c

768

i++, sring_page_addr += PAGE_SIZE) {

sys/dev/xen/blkfront/block.h

46

(((segs) - 1) * PAGE_SIZE)

sys/dev/xen/blkfront/block.h

59

((size / PAGE_SIZE) + 1)

sys/dev/xen/blkfront/block.h

73

__CONST_RING_SIZE(blkif, PAGE_SIZE * XBD_MAX_RING_PAGES)

sys/dev/xen/blkfront/block.h

80

(PAGE_SIZE / sizeof(struct blkif_request_segment))

sys/dev/xen/console/xen_console.c

276

cons->intf = pmap_mapdev_attr(ptoa(xen_get_console_mfn()), PAGE_SIZE,

sys/dev/xen/evtchn/evtchn_dev.c

188

u->ring = malloc(PAGE_SIZE, M_EVTCHN, M_WAITOK | M_ZERO);

sys/dev/xen/evtchn/evtchn_dev.c

253

if (count > PAGE_SIZE)

sys/dev/xen/evtchn/evtchn_dev.c

254

count = PAGE_SIZE;

sys/dev/xen/evtchn/evtchn_dev.c

322

kbuf = malloc(PAGE_SIZE, M_EVTCHN, M_WAITOK);

sys/dev/xen/evtchn/evtchn_dev.c

332

if (count > PAGE_SIZE)

sys/dev/xen/evtchn/evtchn_dev.c

333

count = PAGE_SIZE;

sys/dev/xen/evtchn/evtchn_dev.c

77

#define EVTCHN_RING_SIZE (PAGE_SIZE / sizeof(evtchn_port_t))

sys/dev/xen/gntdev/gntdev.c

1132

gmap_start->map->phys_base_addr + i * PAGE_SIZE;

sys/dev/xen/gntdev/gntdev.c

139

PAGE_SIZE;

sys/dev/xen/gntdev/gntdev.c

170

PAGE_SIZE) {

sys/dev/xen/gntdev/gntdev.c

178

PAGE_SIZE) {

sys/dev/xen/gntdev/gntdev.c

321

index += PAGE_SIZE;

sys/dev/xen/gntdev/gntdev.c

365

grefs[i].file_index = file_offset + i * PAGE_SIZE;

sys/dev/xen/gntdev/gntdev.c

753

(entry->end - entry->start) != (gmap->count * PAGE_SIZE)) {

sys/dev/xen/gntdev/gntdev.c

909

arg->index < gmap->file_index + gmap->count * PAGE_SIZE) {

sys/dev/xen/grant_table/grant_table.c

38

#define GREFS_PER_GRANT_FRAME (PAGE_SIZE / sizeof(grant_entry_v1_t))

sys/dev/xen/grant_table/grant_table.c

425

malloc(PAGE_SIZE, M_DEVBUF, M_NOWAIT);

sys/dev/xen/grant_table/grant_table.c

536

&gnttab_pseudo_phys_res_id, PAGE_SIZE * max_nr_gframes);

sys/dev/xen/grant_table/grant_table.c

62

#define RPP (PAGE_SIZE / sizeof(grant_ref_t))

sys/dev/xen/grant_table/grant_table.c

625

malloc(PAGE_SIZE, M_DEVBUF, M_NOWAIT);

sys/dev/xen/netback/netback.c

115

#define NET_TX_RING_SIZE __RING_SIZE((netif_tx_sring_t *)0, PAGE_SIZE)

sys/dev/xen/netback/netback.c

116

#define NET_RX_RING_SIZE __RING_SIZE((netif_rx_sring_t *)0, PAGE_SIZE)

sys/dev/xen/netback/netback.c

130

#define virt_to_offset(x) ((x) & (PAGE_SIZE - 1))

sys/dev/xen/netback/netback.c

1920

pkt->list_len = howmany(pkt->size, PAGE_SIZE);

sys/dev/xen/netback/netback.c

1969

const size_t req_size = PAGE_SIZE;

sys/dev/xen/netback/netback.c

706

ring->va = xnb->kva + ring_type * PAGE_SIZE;

sys/dev/xen/netback/netback.c

707

ring->gnt_addr = xnb->gnt_base_addr + ring_type * PAGE_SIZE;

sys/dev/xen/netback/netback.c

731

ring->ring_pages * PAGE_SIZE);

sys/dev/xen/netback/netback.c

735

ring->ring_pages * PAGE_SIZE);

sys/dev/xen/netback/netback.c

807

xnb->kva_size += xnb->ring_configs[i].ring_pages * PAGE_SIZE;

sys/dev/xen/netback/netback_unit_tests.c

1730

XNB_ASSERT(end_offset <= PAGE_SIZE);

sys/dev/xen/netback/netback_unit_tests.c

1889

size_t size = PAGE_SIZE + 100;

sys/dev/xen/netback/netback_unit_tests.c

1937

XNB_ASSERT(rsp->status == PAGE_SIZE);

sys/dev/xen/netback/netback_unit_tests.c

1944

XNB_ASSERT(rsp->status == size - PAGE_SIZE);

sys/dev/xen/netback/netback_unit_tests.c

347

xnb_unit_pvt.txs = malloc(PAGE_SIZE, M_XENNETBACK, M_WAITOK|M_ZERO);

sys/dev/xen/netback/netback_unit_tests.c

350

BACK_RING_INIT(&xnb_unit_pvt.txb, xnb_unit_pvt.txs, PAGE_SIZE);

sys/dev/xen/netback/netback_unit_tests.c

351

FRONT_RING_INIT(&xnb_unit_pvt.txf, xnb_unit_pvt.txs, PAGE_SIZE);

sys/dev/xen/netback/netback_unit_tests.c

361

xnb_unit_pvt.rxs = malloc(PAGE_SIZE, M_XENNETBACK, M_WAITOK|M_ZERO);

sys/dev/xen/netback/netback_unit_tests.c

364

BACK_RING_INIT(&xnb_unit_pvt.rxb, xnb_unit_pvt.rxs, PAGE_SIZE);

sys/dev/xen/netback/netback_unit_tests.c

365

FRONT_RING_INIT(&xnb_unit_pvt.rxf, xnb_unit_pvt.rxs, PAGE_SIZE);

sys/dev/xen/netfront/netfront.c

107

#define MAX_TX_REQ_FRAGS (65536 / PAGE_SIZE + 2)

sys/dev/xen/netfront/netfront.c

1515

rx->offset + rx->status > PAGE_SIZE)) {

sys/dev/xen/netfront/netfront.c

1706

KASSERT(tx->offset + segs[i].ds_len <= PAGE_SIZE,

sys/dev/xen/netfront/netfront.c

2324

if_sethwtsomaxsegsize(ifp, PAGE_SIZE);

sys/dev/xen/netfront/netfront.c

2331

1, PAGE_SIZE, /* algnmnt, boundary */

sys/dev/xen/netfront/netfront.c

2335

PAGE_SIZE * MAX_TX_REQ_FRAGS, /* max request size */

sys/dev/xen/netfront/netfront.c

2337

PAGE_SIZE, /* maxsegsize */

sys/dev/xen/netfront/netfront.c

79

#define NET_TX_RING_SIZE __CONST_RING_SIZE(netif_tx, PAGE_SIZE)

sys/dev/xen/netfront/netfront.c

80

#define NET_RX_RING_SIZE __CONST_RING_SIZE(netif_rx, PAGE_SIZE)

sys/dev/xen/netfront/netfront.c

802

rxs = (netif_rx_sring_t *)malloc(PAGE_SIZE, M_DEVBUF,

sys/dev/xen/netfront/netfront.c

805

FRONT_RING_INIT(&rxq->ring, rxs, PAGE_SIZE);

sys/dev/xen/netfront/netfront.c

938

txs = (netif_tx_sring_t *)malloc(PAGE_SIZE, M_DEVBUF,

sys/dev/xen/netfront/netfront.c

941

FRONT_RING_INIT(&txq->ring, txs, PAGE_SIZE);

sys/dev/xen/pcifront/pcifront.c

136

pdev->sh_info = (struct xen_pci_sharedinfo *)malloc(PAGE_SIZE, M_DEVBUF, M_NOWAIT);

sys/dev/xen/privcmd/privcmd.c

232

(entry->end != addr + (num * PAGE_SIZE)))

sys/dev/xen/privcmd/privcmd.c

353

(i + index) * PAGE_SIZE);

sys/dev/xen/xenstore/xenstore.c

1121

xen_store = malloc(PAGE_SIZE, M_XENSTORE, M_WAITOK | M_ZERO);

sys/dev/xen/xenstore/xenstore.c

1125

xen_store = pmap_mapdev_attr(ptoa(xs.gpfn), PAGE_SIZE,

sys/dev/xen/xenstore/xenstore_dev.c

78

char buffer[PAGE_SIZE];

sys/dev/xen/xenstore/xenstore_dev.c

82

#define MASK_READ_IDX(idx) ((idx)&(PAGE_SIZE-1))

sys/dev/xen/xenstore/xenstore_dev.c

83

char read_buffer[PAGE_SIZE];

sys/dev/xilinx/if_xae.c

960

sc->rxbuf_align = PAGE_SIZE;

sys/dev/xilinx/if_xae.c

961

sc->txbuf_align = PAGE_SIZE;

sys/dev/xilinx/xlnx_pcib.c

303

sc->msi_page = kmem_alloc_contig(PAGE_SIZE, M_WAITOK, 0,

sys/dev/xilinx/xlnx_pcib.c

304

BUS_SPACE_MAXADDR, PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);

sys/fs/cuse/cuse.c

1406

if ((size % PAGE_SIZE) != 0 || (size < PAGE_SIZE))

sys/fs/cuse/cuse.c

1418

max_off = min_off + (PAGE_SIZE * mem->page_count);

sys/fs/cuse/cuse.c

469

object = vm_pager_allocate(OBJT_SWAP, NULL, PAGE_SIZE * page_count,

sys/fs/cuse/cuse.c

71

(CUSE_ALLOC_BYTES_MAX / PAGE_SIZE)

sys/fs/ext2fs/ext2_vfsops.c

861

if (PAGE_SIZE != SBLOCKBLKSIZE) {

sys/fs/ext2fs/ext2_vfsops.c

862

printf("WARNING: Unsupported page size %d\n", PAGE_SIZE);

sys/fs/ext2fs/ext2_vfsops.c

866

if (cp->provider->sectorsize > PAGE_SIZE) {

sys/fs/ext2fs/ext2_vfsops.c

868

cp->provider->sectorsize, PAGE_SIZE);

sys/fs/ext2fs/ext2_vnops.c

1707

*ap->a_retval = PAGE_SIZE;

sys/fs/fuse/fuse_internal.c

346

vp_cache_at->va_blocksize = PAGE_SIZE;

sys/fs/fuse/fuse_ipc.c

709

err = (PAGE_SIZE >= blen) ? 0 : EINVAL;

sys/fs/fuse/fuse_kernel.h

1003

(PAGE_SIZE / sizeof(struct fuse_removemapping_one))

sys/fs/msdosfs/msdosfs_vfsops.c

738

pmp->pm_fatblocksize = PAGE_SIZE;

sys/fs/nfs/nfs_commonsubs.c

5052

mreq = mb_alloc_ext_plus_pages(PAGE_SIZE, M_WAITOK);

sys/fs/nfs/nfs_commonsubs.c

5057

nd->nd_bextpgsiz = PAGE_SIZE;

sys/fs/nfs/nfs_commonsubs.c

5545

nd->nd_bextpgsiz = PAGE_SIZE - m->m_epg_1st_off;

sys/fs/nfs/nfs_commonsubs.c

5547

nd->nd_bextpgsiz = PAGE_SIZE;

sys/fs/nfs/nfs_commonsubs.c

5562

if ((m->m_epg_npgs + 1) * PAGE_SIZE > maxextsiz) {

sys/fs/nfs/nfs_commonsubs.c

5563

mp = mb_alloc_ext_plus_pages(PAGE_SIZE, M_WAITOK);

sys/fs/nfs/nfs_commonsubs.c

918

nd->nd_bextpgsiz = left = PAGE_SIZE;

sys/fs/nfs/nfsm_subs.h

74

mb2 = mb_alloc_ext_plus_pages(PAGE_SIZE, M_WAITOK);

sys/fs/nfs/nfsm_subs.h

78

nd->nd_bextpgsiz = PAGE_SIZE - siz;

sys/fs/nfsclient/nfs_clbio.c

219

nextoff = toff + PAGE_SIZE;

sys/fs/nfsclient/nfs_clbio.c

339

np->n_size - offset, npages * PAGE_SIZE);

sys/fs/nfsclient/nfs_clcomsubs.c

142

nd->nd_bextpgsiz = PAGE_SIZE;

sys/fs/nfsclient/nfs_clcomsubs.c

174

mp = mb_alloc_ext_plus_pages(PAGE_SIZE, M_WAITOK);

sys/fs/nfsclient/nfs_clcomsubs.c

177

extpgsiz = PAGE_SIZE;

sys/fs/nfsclient/nfs_clcomsubs.c

207

mlen = extpgsiz = PAGE_SIZE;

sys/fs/nfsclient/nfs_clcomsubs.c

91

nd->nd_bextpgsiz = mlen = PAGE_SIZE;

sys/fs/nfsclient/nfs_clrpcops.c

9845

cp2 += PAGE_SIZE - trim;

sys/fs/nfsclient/nfs_clrpcops.c

9846

m2->m_epg_1st_off = PAGE_SIZE - trim;

sys/fs/nfsclient/nfs_clvfsops.c

228

iosize = imax(iosize, PAGE_SIZE);

sys/fs/nfsclient/nfs_clvnops.c

4786

*ap->a_retval = PAGE_SIZE;

sys/fs/nfsserver/nfs_nfsdport.c

1013

siz = min(PAGE_SIZE, left);

sys/fs/nfsserver/nfs_nfsdport.c

7362

PHYS_TO_DMAP(mb->m_epg_pa[bextpg]) + PAGE_SIZE - bextpgsiz,

sys/fs/nfsserver/nfs_nfsdport.c

7373

fullpgsiz = PAGE_SIZE - mb->m_epg_1st_off;

sys/fs/nfsserver/nfs_nfsdport.c

7375

fullpgsiz = PAGE_SIZE;

sys/fs/nfsserver/nfs_nfsdserv.c

1075

nd->nd_bextpgsiz = PAGE_SIZE - m2->m_epg_last_len -

sys/fs/nfsserver/nfs_nfsdserv.c

6439

nd->nd_bextpgsiz = PAGE_SIZE -

sys/fs/nfsserver/nfs_nfsdserv.c

869

nd->nd_bextpgsiz = PAGE_SIZE - mpend->m_epg_last_len -

sys/fs/p9fs/p9fs_vfsops.c

435

mp->mnt_iosize_max = PAGE_SIZE;

sys/fs/p9fs/p9fs_vfsops.c

571

if (statfs.bsize > PAGE_SIZE)

sys/fs/p9fs/p9fs_vfsops.c

572

buf->f_bsize = PAGE_SIZE;

sys/fs/p9fs/p9fs_vfsops.c

585

buf->f_bsize = PAGE_SIZE;

sys/fs/p9fs/p9fs_vnops.c

1963

uiov->uio_offset = ((off_t)bp->b_blkno) * PAGE_SIZE + bp->b_dirtyoff;

sys/fs/p9fs/p9fs_vnops.c

2234

np->inode.i_size - offset, npages * PAGE_SIZE);

sys/fs/pseudofs/pseudofs.c

418

sbp->f_bsize = PAGE_SIZE;

sys/fs/pseudofs/pseudofs.c

419

sbp->f_iosize = PAGE_SIZE;

sys/fs/pseudofs/pseudofs_vnops.c

229

vap->va_blocksize = PAGE_SIZE;

sys/fs/pseudofs/pseudofs_vnops.c

726

buflim = PAGE_SIZE;

sys/fs/smbfs/smbfs_io.c

501

nextoff = toff + PAGE_SIZE;

sys/fs/smbfs/smbfs_io.c

617

npages * PAGE_SIZE, npages * PAGE_SIZE);

sys/fs/tarfs/tarfs_io.c

372

bsize = roundup(ZSTD_CStreamOutSize(), PAGE_SIZE);

sys/fs/tmpfs/tmpfs.h

554

#define TMPFS_PAGES_MINRESERVED (4 * 1024 * 1024 / PAGE_SIZE)

sys/fs/tmpfs/tmpfs_subr.c

1897

PAGE_SIZE, ignerr);

sys/fs/tmpfs/tmpfs_subr.c

1962

end = pistart != piend ? PAGE_SIZE : endofs;

sys/fs/tmpfs/tmpfs_subr.c

399

bytes = pages * PAGE_SIZE;

sys/fs/tmpfs/tmpfs_subr.c

405

pages = bytes / PAGE_SIZE;

sys/fs/tmpfs/tmpfs_subr.c

475

PAGE_SIZE);

sys/fs/tmpfs/tmpfs_vfsops.c

324

const size_t nodes_per_page = howmany(PAGE_SIZE,

sys/fs/tmpfs/tmpfs_vfsops.c

423

if (size_max == 0 || size_max > OFF_MAX - PAGE_SIZE ||

sys/fs/tmpfs/tmpfs_vfsops.c

424

(SIZE_MAX < OFF_MAX && size_max / PAGE_SIZE >= SIZE_MAX))

sys/fs/tmpfs/tmpfs_vfsops.c

427

size_max = roundup(size_max, PAGE_SIZE);

sys/fs/tmpfs/tmpfs_vfsops.c

428

pages = howmany(size_max, PAGE_SIZE);

sys/fs/tmpfs/tmpfs_vfsops.c

630

sbp->f_iosize = PAGE_SIZE;

sys/fs/tmpfs/tmpfs_vfsops.c

631

sbp->f_bsize = PAGE_SIZE;

sys/fs/tmpfs/tmpfs_vnops.c

1698

*retval = PAGE_SIZE;

sys/fs/tmpfs/tmpfs_vnops.c

1902

!tmpfs_pages_check_avail(tmp, howmany(size, PAGE_SIZE))) {

sys/fs/tmpfs/tmpfs_vnops.c

474

sb->st_blksize = PAGE_SIZE;

sys/fs/tmpfs/tmpfs_vnops.c

515

vap->va_blocksize = PAGE_SIZE;

sys/geom/concat/g_concat.c

412

cbp->bio_ma += cbp->bio_ma_offset / PAGE_SIZE;

sys/geom/concat/g_concat.c

413

cbp->bio_ma_offset %= PAGE_SIZE;

sys/geom/concat/g_concat.c

415

cbp->bio_length) / PAGE_SIZE;

sys/geom/eli/g_eli.c

893

g_eli_alloc_sz = roundup2((PAGE_SIZE + sizeof(int) +

sys/geom/eli/g_eli.c

895

sizeof(uintptr_t), PAGE_SIZE);

sys/geom/eli/g_eli_ctl.c

372

if (*sectorsize > PAGE_SIZE) {

sys/geom/geom_disk.c

301

return ((g_disk_maxsize(dp, bp) / PAGE_SIZE) + 1);

sys/geom/geom_disk.c

327

bp->bio_ma += off / PAGE_SIZE;

sys/geom/geom_disk.c

329

bp->bio_ma_offset %= PAGE_SIZE;

sys/geom/geom_disk.c

330

bp->bio_ma_n -= off / PAGE_SIZE;

sys/geom/geom_disk.c

423

howmany(bp->bio_ma_offset + bp->bio_length, PAGE_SIZE);

sys/geom/geom_io.c

460

bp->bio_length) / PAGE_SIZE == bp->bio_ma_n,

sys/geom/geom_io.c

466

bp->bio_length) / PAGE_SIZE;

sys/geom/geom_io.c

758

KASSERT(size / PAGE_SIZE == bp->bio_ma_n, ("Bio too short %p", bp));

sys/geom/geom_kern.c

164

sb = sbuf_new(NULL, NULL, PAGE_SIZE, SBUF_FIXEDLEN |

sys/geom/geom_kern.c

183

static size_t hint = PAGE_SIZE;

sys/geom/geom_kern.c

191

static size_t hint = PAGE_SIZE;

sys/geom/geom_kern.c

199

static size_t hint = PAGE_SIZE;

sys/geom/label/g_label_swaplinux.c

39

uint8_t reserved[PAGE_SIZE - SWAP_SIGNATURE_SZ];

sys/geom/label/g_label_swaplinux.c

59

if ((PAGE_SIZE % pp->sectorsize) != 0)

sys/geom/label/g_label_swaplinux.c

62

hdr = (swhdr_t *)g_read_data(cp, 0, PAGE_SIZE, NULL);

sys/geom/raid/tr_concat.c

256

cbp->bio_ma += cbp->bio_ma_offset / PAGE_SIZE;

sys/geom/raid/tr_concat.c

257

cbp->bio_ma_offset %= PAGE_SIZE;

sys/geom/raid/tr_concat.c

259

cbp->bio_length) / PAGE_SIZE;

sys/geom/raid/tr_raid0.c

236

cbp->bio_ma += cbp->bio_ma_offset / PAGE_SIZE;

sys/geom/raid/tr_raid0.c

237

cbp->bio_ma_offset %= PAGE_SIZE;

sys/geom/raid/tr_raid0.c

239

cbp->bio_length) / PAGE_SIZE;

sys/geom/raid/tr_raid1e.c

723

cbp->bio_ma += cbp->bio_ma_offset / PAGE_SIZE;

sys/geom/raid/tr_raid1e.c

724

cbp->bio_ma_offset %= PAGE_SIZE;

sys/geom/raid/tr_raid1e.c

726

cbp->bio_length) / PAGE_SIZE;

sys/geom/raid/tr_raid1e.c

799

cbp->bio_ma += cbp->bio_ma_offset / PAGE_SIZE;

sys/geom/raid/tr_raid1e.c

800

cbp->bio_ma_offset %= PAGE_SIZE;

sys/geom/raid/tr_raid1e.c

802

cbp->bio_length) / PAGE_SIZE;

sys/geom/stripe/g_stripe.c

492

cbp->bio_ma += cbp->bio_ma_offset / PAGE_SIZE;

sys/geom/stripe/g_stripe.c

493

cbp->bio_ma_offset %= PAGE_SIZE;

sys/geom/stripe/g_stripe.c

495

cbp->bio_length) / PAGE_SIZE;

sys/geom/zero/g_zero.c

104

length = MIN(PAGE_SIZE - offset, bp->bio_resid);

sys/geom/zero/g_zero.c

55

static uint8_t g_zero_buffer[PAGE_SIZE];

sys/geom/zero/g_zero.c

74

memset(g_zero_buffer, g_zero_byte, PAGE_SIZE);

sys/geom/zero/g_zero.c

87

aiovec.iov_len = PAGE_SIZE;

sys/i386/acpica/acpi_wakeup.c

330

wakepages[i] = contigmalloc(PAGE_SIZE, M_DEVBUF,

sys/i386/acpica/acpi_wakeup.c

331

M_NOWAIT | M_EXEC, 0x500, 0xa0000, PAGE_SIZE, 0ul);

sys/i386/acpica/acpi_wakeup.c

74

CTASSERT(sizeof(wakecode) < PAGE_SIZE - 1024);

sys/i386/i386/bios.c

337

stack = (caddr_t)PAGE_SIZE - 32;

sys/i386/i386/copyout.c

100

plen = howmany(uva - trunc_page(uva) + len, PAGE_SIZE);

sys/i386/i386/copyout.c

171

ca.len = PAGE_SIZE;

sys/i386/i386/copyout.c

218

ca.len = PAGE_SIZE;

sys/i386/i386/copyout.c

253

ca.len = PAGE_SIZE;

sys/i386/i386/elf_machdep.c

83

.sv_shared_page_len = PAGE_SIZE,

sys/i386/i386/genassym.c

97

ASSYM(PAGE_SIZE, PAGE_SIZE);

sys/i386/i386/machdep.c

1104

physmap[0] = PAGE_SIZE; /* mask off page 0 */

sys/i386/i386/machdep.c

1128

for (pa = round_page(physmap[i]); pa < end; pa += PAGE_SIZE) {

sys/i386/i386/machdep.c

1205

phys_avail[pa_indx] += PAGE_SIZE;

sys/i386/i386/machdep.c

1216

phys_avail[pa_indx] = pa + PAGE_SIZE; /* end */

sys/i386/i386/machdep.c

1221

dump_avail[da_indx] += PAGE_SIZE;

sys/i386/i386/machdep.c

1229

dump_avail[da_indx] = pa + PAGE_SIZE; /* end */

sys/i386/i386/machdep.c

1244

while (phys_avail[pa_indx - 1] + PAGE_SIZE +

sys/i386/i386/machdep.c

1257

for (off = 0; off < round_page(msgbufsize); off += PAGE_SIZE)

sys/i386/i386/machdep.c

1423

first = roundup2(first + ucode_len, PAGE_SIZE);

sys/i386/i386/machdep.c

1460

for (pa = first; pa < first + DPCPU_SIZE; pa += PAGE_SIZE)

sys/i386/i386/machdep.c

1503

PAGE_SIZE - VM86_STACK_SPACE;

sys/i386/i386/machdep.c

1659

dblfault_stack = pmap_trm_alloc(PAGE_SIZE, M_NOWAIT);

sys/i386/i386/machdep.c

1662

(int)dblfault_stack + PAGE_SIZE;

sys/i386/i386/machdep.c

1810

tmp = (vm_offset_t)pmap_trm_alloc(PAGE_SIZE * 3, M_NOWAIT | M_ZERO);

sys/i386/i386/machdep.c

1817

(tmp + PAGE_SIZE - 7 * sizeof(struct gate_descriptor));

sys/i386/i386/machdep.c

1824

pmap_protect(kernel_pmap, tmp, tmp + PAGE_SIZE, VM_PROT_READ);

sys/i386/i386/machdep.c

281

(uintmax_t)size, (uintmax_t)size / PAGE_SIZE);

sys/i386/i386/mem.c

142

c = PAGE_SIZE - o;

sys/i386/i386/minidump_machdep_base.c

116

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

sys/i386/i386/minidump_machdep_base.c

180

ptesize += PAGE_SIZE;

sys/i386/i386/minidump_machdep_base.c

190

pa += PAGE_SIZE;

sys/i386/i386/minidump_machdep_base.c

220

dumpsize += PAGE_SIZE;

sys/i386/i386/minidump_machdep_base.c

225

dumpsize += PAGE_SIZE;

sys/i386/i386/minidump_machdep_base.c

253

error = blk_write(di, (char *)&fakept, 0, PAGE_SIZE);

sys/i386/i386/minidump_machdep_base.c

268

error = blk_write(di, (char *)&fakept, 0, PAGE_SIZE);

sys/i386/i386/minidump_machdep_base.c

287

fakept[k] = (pa + (k * PAGE_SIZE)) | PG_V | PG_RW | PG_A | PG_M;

sys/i386/i386/minidump_machdep_base.c

289

error = blk_write(di, (char *)&fakept, 0, PAGE_SIZE);

sys/i386/i386/minidump_machdep_base.c

300

error = blk_write(di, 0, pa, PAGE_SIZE);

sys/i386/i386/minidump_machdep_base.c

305

error = blk_write(di, (char *)&fakept, 0, PAGE_SIZE);

sys/i386/i386/minidump_machdep_base.c

317

error = blk_write(di, 0, pa, PAGE_SIZE);

sys/i386/i386/minidump_machdep_base.c

79

maxdumpsz = min(di->maxiosize, MAXDUMPPGS * PAGE_SIZE);

sys/i386/i386/minidump_machdep_base.c

81

maxdumpsz = PAGE_SIZE;

sys/i386/i386/minidump_machdep_base.c

83

if ((sz % PAGE_SIZE) != 0) {

sys/i386/i386/minidump_machdep_base.c

91

if (pa != 0 && (((uintptr_t)ptr) % PAGE_SIZE) != 0) {

sys/i386/i386/mp_machdep.c

389

bootstacks[cpu] = kmem_malloc(kstack_pages * PAGE_SIZE,

sys/i386/i386/mp_machdep.c

399

PAGE_SIZE - 4;

sys/i386/i386/mp_machdep.c

457

KASSERT (size <= PAGE_SIZE,

sys/i386/i386/mp_machdep.c

635

ipi_range_size += (addr2 - addr1) / PAGE_SIZE;

sys/i386/i386/mp_machdep.c

711

addr += PAGE_SIZE;

sys/i386/i386/pmap.c

1029

PAGE_SIZE) / NBPDR + 1;

sys/i386/i386/pmap.c

1041

pv_chunkbase = (struct pv_chunk *)kva_alloc(PAGE_SIZE * pv_maxchunks);

sys/i386/i386/pmap.c

1237

#define PMAP_INVLPG_THRESHOLD (4 * 1024 * PAGE_SIZE)

sys/i386/i386/pmap.c

1253

for (addr = sva; addr < eva; addr += PAGE_SIZE)

sys/i386/i386/pmap.c

1406

for (addr = sva; addr < eva; addr += PAGE_SIZE)

sys/i386/i386/pmap.c

174

#define PTD ((pd_entry_t *)((PTDPTDI << PDRSHIFT) + (PTDPTDI * PAGE_SIZE)))

sys/i386/i386/pmap.c

175

#define PTDpde ((pd_entry_t *)((PTDPTDI << PDRSHIFT) + (PTDPTDI * PAGE_SIZE) + \

sys/i386/i386/pmap.c

1829

va += PAGE_SIZE;

sys/i386/i386/pmap.c

1830

start += PAGE_SIZE;

sys/i386/i386/pmap.c

1868

PAGE_SIZE);

sys/i386/i386/pmap.c

1884

va += PAGE_SIZE;

sys/i386/i386/pmap.c

2609

va_last = va + NBPDR - PAGE_SIZE;

sys/i386/i386/pmap.c

2614

va += PAGE_SIZE;

sys/i386/i386/pmap.c

2646

va_last = va + NBPDR - PAGE_SIZE;

sys/i386/i386/pmap.c

2649

va += PAGE_SIZE;

sys/i386/i386/pmap.c

2745

newpte += PAGE_SIZE;

sys/i386/i386/pmap.c

2955

pmap->pm_stats.wired_count -= NBPDR / PAGE_SIZE;

sys/i386/i386/pmap.c

2964

pmap->pm_stats.resident_count -= NBPDR / PAGE_SIZE;

sys/i386/i386/pmap.c

2970

va < eva; va += PAGE_SIZE, m++) {

sys/i386/i386/pmap.c

3063

sva += PAGE_SIZE) {

sys/i386/i386/pmap.c

3112

if ((sva + PAGE_SIZE == eva) &&

sys/i386/i386/pmap.c

3279

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/i386/i386/pmap.c

3405

sva += PAGE_SIZE) {

sys/i386/i386/pmap.c

3538

pa = (newpde & (PG_PS_FRAME | PG_V)) + NBPDR - PAGE_SIZE;

sys/i386/i386/pmap.c

3571

pa -= PAGE_SIZE;

sys/i386/i386/pmap.c

387

*physfree += PAGE_SIZE * cnt;

sys/i386/i386/pmap.c

388

bzero((void *)res, PAGE_SIZE * cnt);

sys/i386/i386/pmap.c

398

cnt--, pt++, va += PAGE_SIZE, pa += PAGE_SIZE)

sys/i386/i386/pmap.c

4062

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/i386/i386/pmap.c

4071

pmap->pm_stats.wired_count += NBPDR / PAGE_SIZE;

sys/i386/i386/pmap.c

4072

pmap->pm_stats.resident_count += NBPDR / PAGE_SIZE;

sys/i386/i386/pmap.c

4121

m = vm_radix_iter_jump(&pages, NBPDR / PAGE_SIZE);

sys/i386/i386/pmap.c

4278

va = (vm_offset_t)crashdumpmap + (i * PAGE_SIZE);

sys/i386/i386/pmap.c

4325

for (pa = ptepa + PAGE_SIZE; pa < ptepa + size;

sys/i386/i386/pmap.c

4326

pa += PAGE_SIZE) {

sys/i386/i386/pmap.c

4348

PAGE_SIZE;

sys/i386/i386/pmap.c

4408

PAGE_SIZE;

sys/i386/i386/pmap.c

4427

sva += PAGE_SIZE) {

sys/i386/i386/pmap.c

4511

NBPDR / PAGE_SIZE;

sys/i386/i386/pmap.c

4554

addr += PAGE_SIZE;

sys/i386/i386/pmap.c

4579

bzero(page, PAGE_SIZE);

sys/i386/i386/pmap.c

4631

if (off == 0 && size == PAGE_SIZE)

sys/i386/i386/pmap.c

4664

bcopy(pc->pc_cmap_addr1, pc->pc_cmap_addr2, PAGE_SIZE);

sys/i386/i386/pmap.c

4694

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/i386/i386/pmap.c

4697

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/i386/i386/pmap.c

4914

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/i386/i386/pmap.c

4926

pmap->pm_stats.resident_count -= NBPDR / PAGE_SIZE;

sys/i386/i386/pmap.c

4930

for (mt = m; mt < &m[NBPDR / PAGE_SIZE]; mt++)

sys/i386/i386/pmap.c

5344

va -= PAGE_SIZE;

sys/i386/i386/pmap.c

5358

sva += PAGE_SIZE) {

sys/i386/i386/pmap.c

5567

for (tmpsize = 0; tmpsize < size; tmpsize += PAGE_SIZE) {

sys/i386/i386/pmap.c

5671

eva = sva + PAGE_SIZE;

sys/i386/i386/pmap.c

5777

tmpva += PAGE_SIZE;

sys/i386/i386/pmap.c

5799

tmpva += PAGE_SIZE;

sys/i386/i386/pmap.c

5968

static int trm_guard = PAGE_SIZE;

sys/i386/i386/pmap.c

5990

for (af = prev_addr; af < addr; af += PAGE_SIZE) {

sys/i386/i386/pmap.c

6009

vmem_set_import(pmap_trm_arena, pmap_trm_import, NULL, NULL, PAGE_SIZE);

sys/i386/i386/pmap.c

6186

h->pte = (pt_entry_t *)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);

sys/i386/i386/pmap.c

6347

sbuf_new_for_sysctl(sb, NULL, PAGE_SIZE, req);

sys/i386/i386/pmap.c

6384

sva += PAGE_SIZE) {

sys/i386/i386/pmap.c

653

v = (c)va; va += ((n)*PAGE_SIZE); p = pte; pte += (n);

sys/i386/i386/pmap.c

760

pages = kva_alloc(PAGE_SIZE * 3);

sys/i386/i386/pmap.c

764

pc->pc_cmap_pte2 = vtopte(pages + PAGE_SIZE);

sys/i386/i386/pmap.c

766

pc->pc_cmap_addr2 = (caddr_t)(pages + PAGE_SIZE);

sys/i386/i386/pmap.c

941

va = (vm_offset_t)base + i * PAGE_SIZE;

sys/i386/i386/pmap_base.c

396

if (count >= PMAP_CLFLUSH_THRESHOLD / PAGE_SIZE ||

sys/i386/i386/sys_machdep.c

303

offset = PAGE_SIZE - 16;

sys/i386/i386/sys_machdep.c

356

uap->start + uap->length > IOPAGES * PAGE_SIZE * NBBY)

sys/i386/i386/sys_machdep.c

374

if (uap->start >= IOPAGES * PAGE_SIZE * NBBY)

sys/i386/i386/sys_machdep.c

389

for (i = uap->start + 1; i < IOPAGES * PAGE_SIZE * NBBY; i++) {

sys/i386/i386/uio_machdep.c

90

cnt = min(cnt, PAGE_SIZE - page_offset);

sys/i386/i386/vm86.c

389

#define PGTABLE_SIZE ((1024 + 64) * 1024 / PAGE_SIZE)

sys/i386/i386/vm86.c

623

kva = (vm_offset_t)malloc(PAGE_SIZE, M_TEMP, M_WAITOK);

sys/i386/i386/vm86.c

800

kva < vmc->pmap[i].kva + PAGE_SIZE) {

sys/i386/i386/vm_machdep.c

113

p = td->td_kstack + td->td_kstack_pages * PAGE_SIZE -

sys/i386/i386/vm_machdep.c

626

pmap_invalidate_cache_range(sf->kva, sf->kva + PAGE_SIZE);

sys/i386/i386/vm_machdep.c

92

p = td->td_kstack + td->td_kstack_pages * PAGE_SIZE -

sys/i386/include/param.h

85

#define PAGE_MASK (PAGE_SIZE - 1)

sys/i386/include/param.h

86

#define NPTEPG (PAGE_SIZE / sizeof(pt_entry_t))

sys/i386/include/param.h

93

#define NPDEPG (PAGE_SIZE / sizeof(pd_entry_t))

sys/i386/include/vmparam.h

166

#define SHAREDPAGE (VM_MAXUSER_ADDRESS - PAGE_SIZE)

sys/i386/include/xen/hypercall.h

125

if (op >= PAGE_SIZE / 32)

sys/i386/linux/linux_machdep.c

696

error = vm_mmap(exec_map, (vm_offset_t *)&a_out, PAGE_SIZE,

sys/i386/linux/linux_machdep.c

855

kmap_free_wakeup(exec_map, (vm_offset_t)a_out, PAGE_SIZE);

sys/i386/linux/linux_sysvec.c

649

.sv_shared_page_len = PAGE_SIZE,

sys/i386/linux/linux_sysvec.c

77

#define LINUX_VDSOPAGE_SIZE PAGE_SIZE * 2

sys/i386/linux/linux_sysvec.c

79

#define LINUX_SHAREDPAGE (LINUX_VDSOPAGE - PAGE_SIZE)

sys/i386/pci/pci_cfgreg.c

495

va = kva_alloc(PCIE_CACHE * PAGE_SIZE);

sys/i386/pci/pci_cfgreg.c

509

elem->vapage = va + (i * PAGE_SIZE);

sys/kern/imgact_aout.c

206

file_offset = PAGE_SIZE;

sys/kern/imgact_aout.c

213

virtual_offset = PAGE_SIZE;

sys/kern/imgact_aout.c

224

virtual_offset = PAGE_SIZE;

sys/kern/imgact_aout.c

232

bss_size = roundup(a_out->a_bss, PAGE_SIZE);

sys/kern/imgact_elf.c

1028

if (phdr->p_offset > PAGE_SIZE ||

sys/kern/imgact_elf.c

1029

interp_name_len > PAGE_SIZE - phdr->p_offset) {

sys/kern/imgact_elf.c

1163

maxalign = PAGE_SIZE;

sys/kern/imgact_elf.c

1164

maxsalign = PAGE_SIZE * 1024;

sys/kern/imgact_elf.c

1395

maxv1, PAGE_SIZE, &addr);

sys/kern/imgact_elf.c

1424

elf_auxargs->pagesz = PAGE_SIZE;

sys/kern/imgact_elf.c

1736

phdr->p_align = PAGE_SIZE;

sys/kern/imgact_elf.c

1857

sbuf_end_section(sb, -1, PAGE_SIZE, 0);

sys/kern/imgact_elf.c

2799

if (pnote == NULL || pnote->p_filesz > PAGE_SIZE)

sys/kern/imgact_elf.c

2802

if (pnote->p_offset > PAGE_SIZE ||

sys/kern/imgact_elf.c

2803

pnote->p_filesz > PAGE_SIZE - pnote->p_offset) {

sys/kern/imgact_elf.c

488

return (hdr->e_phoff <= PAGE_SIZE &&

sys/kern/imgact_elf.c

489

(u_int)hdr->e_phentsize * hdr->e_phnum <= PAGE_SIZE - hdr->e_phoff);

sys/kern/imgact_elf.c

597

if (sz > PAGE_SIZE - off)

sys/kern/imgact_elf.c

598

sz = PAGE_SIZE - off;

sys/kern/imgact_shell.c

50

#if MAXSHELLCMDLEN > PAGE_SIZE

sys/kern/kern_dump.c

186

pgs = mdp->pa_size / PAGE_SIZE;

sys/kern/kern_dump.c

188

maxdumppgs = min(di->maxiosize / PAGE_SIZE, MAXDUMPPGS);

sys/kern/kern_dump.c

269

phdr.p_align = PAGE_SIZE;

sys/kern/kern_dump.c

53

#define MD_ALIGN(x) roundup2((off_t)(x), PAGE_SIZE)

sys/kern/kern_exec.c

1178

sv_minuser = MAX(sv->sv_minuser, PAGE_SIZE);

sys/kern/kern_exec.c

1297

sv->sv_maxuser - PAGE_SIZE, PAGE_SIZE,

sys/kern/kern_exec.c

144

u_long ps_arg_cache_limit = PAGE_SIZE / 16;

sys/kern/kern_exec.c

2025

KASSERT((uintptr_t)base % PAGE_SIZE == 0,

sys/kern/kern_exec.c

2040

for (runlen = 0; runlen < len; runlen += PAGE_SIZE) {

sys/kern/kern_exec.c

2070

runlen = PAGE_SIZE;

sys/kern/kern_kcov.c

373

info->bufsize = roundup2(entries * KCOV_ELEMENT_SIZE, PAGE_SIZE);

sys/kern/kern_kcov.c

374

pages = info->bufsize / PAGE_SIZE;

sys/kern/kern_kcov.c

388

pmap_qenter(info->kvaddr + n * PAGE_SIZE, &m, 1);

sys/kern/kern_kcov.c

404

pmap_qremove(info->kvaddr, info->bufsize / PAGE_SIZE);

sys/kern/kern_kcov.c

409

info->bufsize / PAGE_SIZE);

sys/kern/kern_ktrace.c

141

u_int ktr_geniosize = PAGE_SIZE;

sys/kern/kern_malloc.c

1208

kmem_zmax = PAGE_SIZE;

sys/kern/kern_malloc.c

1219

vm_kmem_size = vm_kmem_size * PAGE_SIZE < vm_kmem_size ?

sys/kern/kern_malloc.c

1220

vm_kmem_size_max : vm_kmem_size * PAGE_SIZE;

sys/kern/kern_malloc.c

1236

if (vm_kmem_size / 2 / PAGE_SIZE > mem_size)

sys/kern/kern_malloc.c

1237

vm_kmem_size = 2 * mem_size * PAGE_SIZE;

sys/kern/kern_malloc.c

1283

if (kmem_zmax < PAGE_SIZE || kmem_zmax > KMEM_ZMAX)

sys/kern/kern_malloc.c

1294

align = MIN(size, PAGE_SIZE) - 1;

sys/kern/kern_malloc.c

619

size = roundup(size, PAGE_SIZE);

sys/kern/kern_malloc.c

832

KASSERT(align <= PAGE_SIZE,

sys/kern/kern_mbuf.c

1022

m_extadd(m_new, (char *)sf_buf_kva(sf), PAGE_SIZE,

sys/kern/kern_mbuf.c

163

realmem = qmin((quad_t)physmem * PAGE_SIZE, vm_kmem_size);

sys/kern/kern_mbuf.c

1730

npgs = howmany(len, PAGE_SIZE);

sys/kern/kern_mbuf.c

1771

pglen = PAGE_SIZE;

sys/kern/kern_mbuf.c

1777

m->m_epg_last_len = PAGE_SIZE;

sys/kern/kern_mbuf.c

1789

pglen = PAGE_SIZE;

sys/kern/kern_mbuf.c

1811

m->m_epg_last_len = PAGE_SIZE - pglen;

sys/kern/kern_mib.c

178

SYSCTL_NULL_INT_PTR, PAGE_SIZE, "System memory page size");

sys/kern/kern_mib.c

255

u_long __read_mostly pagesizes[MAXPAGESIZES] = { PAGE_SIZE };

sys/kern/kern_physio.c

59

if (dev->si_iosize_max < PAGE_SIZE) {

sys/kern/kern_proc.c

2448

addr += PAGE_SIZE;

sys/kern/kern_prot.c

2906

if (nbytes < PAGE_SIZE) {

sys/kern/kern_prot.c

2911

nbytes = roundup2(nbytes, PAGE_SIZE);

sys/kern/kern_resource.c

845

*res = vm->vm_dsize * PAGE_SIZE;

sys/kern/kern_resource.c

851

*res = vm->vm_ssize * PAGE_SIZE;

sys/kern/kern_resource.c

860

*res = vmspace_resident_count(vm) * PAGE_SIZE;

sys/kern/kern_resource.c

866

*res = pmap_wired_count(vmspace_pmap(vm)) * PAGE_SIZE;

sys/kern/kern_sendfile.c

1003

mtail->m_ext.ext_size += PAGE_SIZE;

sys/kern/kern_sendfile.c

1034

m0->m_ext.ext_size = PAGE_SIZE;

sys/kern/kern_sendfile.c

175

return (omin(PAGE_SIZE - (off & PAGE_MASK), len));

sys/kern/kern_sendfile.c

180

return (PAGE_SIZE);

sys/kern/kern_sendfile.c

193

return (trunc_page(off + i * PAGE_SIZE));

sys/kern/kern_sendfile.c

222

*space -= (old - new) * PAGE_SIZE;

sys/kern/kern_sendfile.c

653

if (so->so_snd.sb_lowat < PAGE_SIZE &&

sys/kern/kern_sendfile.c

654

so->so_snd.sb_hiwat >= PAGE_SIZE)

sys/kern/kern_sendfile.c

655

so->so_snd.sb_lowat = PAGE_SIZE;

sys/kern/kern_sendfile.c

852

else if (space > PAGE_SIZE) {

sys/kern/kern_sendfile.c

858

space -= (PAGE_SIZE - (off & PAGE_MASK));

sys/kern/kern_sendfile.c

861

space += (PAGE_SIZE - (off & PAGE_MASK));

sys/kern/kern_sendfile.c

864

npages = howmany(space + (off & PAGE_MASK), PAGE_SIZE);

sys/kern/kern_sendfile.c

878

rhpages = howmany(rem + (off & PAGE_MASK), PAGE_SIZE) -

sys/kern/kern_sendfile.c

882

rhpages = min(howmany(maxphys, PAGE_SIZE), rhpages);

sys/kern/kern_sendfile.c

883

rhpages = min(howmany(obj_size - trunc_page(off), PAGE_SIZE) -

sys/kern/kern_sharedpage.c

121

shared_page_obj = vm_pager_allocate(OBJT_PHYS, 0, PAGE_SIZE,

sys/kern/kern_sharedpage.c

128

addr = kva_alloc(PAGE_SIZE);

sys/kern/kern_sysctl.c

2576

if (req.oldptr != NULL && req.oldlen > 4 * PAGE_SIZE &&

sys/kern/kern_umtx.c

4527

error = shm_dotruncate(reg->ushm_obj, PAGE_SIZE);

sys/kern/kern_vnodedumper.c

109

di.blocksize = PAGE_SIZE; /* Arbitrary. */

sys/kern/kern_vnodedumper.c

110

di.maxiosize = MAXDUMPPGS * PAGE_SIZE;

sys/kern/link_elf.c

1045

firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);

sys/kern/link_elf.c

1047

error = vn_rdwr(UIO_READ, nd.ni_vp, firstpage, PAGE_SIZE, 0,

sys/kern/link_elf.c

1050

nbytes = PAGE_SIZE - resid;

sys/kern/link_elf.c

1088

(hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) &&

sys/kern/p1003_1b.c

378

p31b_setcfg(CTL_P1003_1B_PAGESIZE, PAGE_SIZE);

sys/kern/posix4_mib.c

171

p31b_setcfg(CTL_P1003_1B_PAGESIZE, PAGE_SIZE);

sys/kern/subr_asan.c

117

sva = rounddown(sva, PAGE_SIZE);

sys/kern/subr_asan.c

118

eva = roundup(eva, PAGE_SIZE);

sys/kern/subr_asan.c

120

npages = (eva - sva) / PAGE_SIZE;

sys/kern/subr_bus_dma.c

268

len = min(PAGE_SIZE - ma_offs, tlen);

sys/kern/subr_busdma_bounce.c

194

bz->alignment = MAX(dmat_alignment(dmat), PAGE_SIZE);

sys/kern/subr_busdma_bounce.c

285

bpage->vaddr = (vm_offset_t)contigmalloc_domainset(PAGE_SIZE,

sys/kern/subr_busdma_bounce.c

287

0ul, bz->lowaddr, PAGE_SIZE, 0);

sys/kern/subr_busdma_bounce.c

289

bpage->vaddr = (vm_offset_t)contigmalloc(PAGE_SIZE, M_BOUNCE,

sys/kern/subr_busdma_bounce.c

290

M_NOWAIT, 0ul, bz->lowaddr, PAGE_SIZE, 0);

sys/kern/subr_busdma_bufalloc.c

54

#define MAX_ZONE_BUFSIZE PAGE_SIZE

sys/kern/subr_busdma_bufalloc.c

63

#if PAGE_SIZE > 65536

sys/kern/subr_compressor.c

109

s = gz_alloc(NULL, 1, roundup2(sizeof(*s), PAGE_SIZE));

sys/kern/subr_devstat.c

504

#define statsperpage (PAGE_SIZE / sizeof(struct devstat))

sys/kern/subr_devstat.c

535

*(off_t *)data = pagelist_pages * PAGE_SIZE;

sys/kern/subr_devstat.c

557

offset -= PAGE_SIZE;

sys/kern/subr_devstat.c

589

spp2->stat = malloc(PAGE_SIZE, M_DEVSTAT, M_ZERO | M_WAITOK);

sys/kern/subr_memdesc.c

206

todo = min(PAGE_SIZE - page_off, size);

sys/kern/subr_memdesc.c

369

return (last_len == PAGE_SIZE);

sys/kern/subr_memdesc.c

387

m->m_epg_last_len = PAGE_SIZE - m->m_epg_1st_off;

sys/kern/subr_memdesc.c

399

while (len >= PAGE_SIZE && m->m_epg_npgs < MBUF_PEXT_MAX_PGS) {

sys/kern/subr_memdesc.c

402

m->m_epg_last_len = PAGE_SIZE;

sys/kern/subr_memdesc.c

403

m->m_len += PAGE_SIZE;

sys/kern/subr_memdesc.c

404

pa += PAGE_SIZE;

sys/kern/subr_memdesc.c

405

len -= PAGE_SIZE;

sys/kern/subr_memdesc.c

406

appended += PAGE_SIZE;

sys/kern/subr_memdesc.c

411

KASSERT(len < PAGE_SIZE, ("final page is full page"));

sys/kern/subr_memdesc.c

58

todo = min(PAGE_SIZE - page_off, size);

sys/kern/subr_memdesc.c

608

while (offset >= PAGE_SIZE) {

sys/kern/subr_memdesc.c

610

offset -= PAGE_SIZE;

sys/kern/subr_memdesc.c

635

m->m_epg_last_len = PAGE_SIZE - offset;

sys/kern/subr_memdesc.c

642

while (len >= PAGE_SIZE) {

sys/kern/subr_memdesc.c

654

tail->m_epg_last_len = PAGE_SIZE;

sys/kern/subr_memdesc.c

655

tail->m_len += PAGE_SIZE;

sys/kern/subr_memdesc.c

656

len -= PAGE_SIZE;

sys/kern/subr_msan.c

107

static uint8_t msan_dummy_shad[PAGE_SIZE] __aligned(PAGE_SIZE);

sys/kern/subr_msan.c

108

static uint8_t msan_dummy_write_shad[PAGE_SIZE] __aligned(PAGE_SIZE);

sys/kern/subr_msan.c

109

static uint8_t msan_dummy_orig[PAGE_SIZE] __aligned(PAGE_SIZE);

sys/kern/subr_msan.c

526

MPASS(addr % PAGE_SIZE == 0);

sys/kern/subr_msan.c

527

MPASS(size % PAGE_SIZE == 0);

sys/kern/subr_param.c

348

if (maxphys < PAGE_SIZE)

sys/kern/subr_physmem.c

133

addr + size - 1, size / mbyte, size / PAGE_SIZE);

sys/kern/subr_physmem.c

142

addr, addr + size - 1, size / mbyte, size / PAGE_SIZE,

sys/kern/subr_physmem.c

446

if (sz <= PAGE_SIZE)

sys/kern/subr_physmem.c

448

pa = PAGE_SIZE;

sys/kern/subr_physmem.c

449

sz -= PAGE_SIZE;

sys/kern/subr_sbuf.c

90

#ifdef PAGE_SIZE

sys/kern/subr_sbuf.c

91

#define SBUF_MAXEXTENDSIZE PAGE_SIZE

sys/kern/subr_sbuf.c

92

#define SBUF_MAXEXTENDINCR PAGE_SIZE

sys/kern/subr_sfbuf.c

100

sf_bufs[i].kva = sf_base + i * PAGE_SIZE;

sys/kern/subr_sfbuf.c

96

sf_base = kva_alloc(nsfbufs * PAGE_SIZE);

sys/kern/subr_sglist.c

129

seglen = MIN(len, PAGE_SIZE - offset);

sys/kern/subr_sglist.c

147

seglen = MIN(len, PAGE_SIZE);

sys/kern/subr_sglist.c

182

vaddr += PAGE_SIZE;

sys/kern/subr_sglist.c

185

if (lastaddr + PAGE_SIZE != paddr)

sys/kern/subr_sglist.c

188

vaddr += PAGE_SIZE;

sys/kern/subr_sglist.c

209

for (i = 1; len > PAGE_SIZE; len -= PAGE_SIZE, i++) {

sys/kern/subr_sglist.c

211

if (lastaddr + PAGE_SIZE != paddr)

sys/kern/subr_sglist.c

504

seglen = min(PAGE_SIZE - pgoff, len);

sys/kern/subr_sglist.c

514

seglen = min(PAGE_SIZE - pgoff, len);

sys/kern/subr_uio.c

109

for (i = 0; i < PHYS_PAGE_COUNT(len); i++, dst += PAGE_SIZE)

sys/kern/subr_uio.c

130

for (i = 0; i < PHYS_PAGE_COUNT(len); i++, src += PAGE_SIZE)

sys/kern/subr_uio.c

91

#define PHYS_PAGE_COUNT(len) (howmany(len, PAGE_SIZE) + 1)

sys/kern/sys_pipe.c

1602

ub->st_blksize = PAGE_SIZE;

sys/kern/sys_process.c

391

len = MIN(PAGE_SIZE - page_offset, uio->uio_resid);

sys/kern/sys_process.c

414

PAGE_SIZE, VM_PROT_EXECUTE))

sys/kern/sys_timerfd.c

326

sb->st_blksize = PAGE_SIZE;

sys/kern/sysv_shm.c

156

#define SHMMAX (SHMMAXPGS*PAGE_SIZE)

sys/kern/sysv_shm.c

967

for (i = PAGE_SIZE; i != 0; i--) {

sys/kern/uipc_ktls.c

3277

atop(ktls_maxlen), 0, ~0ul, PAGE_SIZE, 0,

sys/kern/uipc_ktls.c

448

atop(ktls_maxlen), 0, ~0ul, PAGE_SIZE, 0,

sys/kern/uipc_ktls.c

496

roundup2(ktls_maxlen, PAGE_SIZE), NULL, NULL, NULL, NULL,

sys/kern/uipc_mbuf.c

1881

maxseg = MBUF_PEXT_MAX_PGS * PAGE_SIZE;

sys/kern/uipc_mbuf.c

1912

for (i = 0; needed > 0; i++, needed -= PAGE_SIZE) {

sys/kern/uipc_mbuf.c

1926

mb->m_epg_last_len = length - PAGE_SIZE * (mb->m_epg_npgs - 1);

sys/kern/uipc_mbuf.c

1933

mb->m_ext.ext_size += PAGE_SIZE * mb->m_epg_npgs;

sys/kern/uipc_mqueue.c

1213

vap->va_blocksize = PAGE_SIZE;

sys/kern/uipc_mqueue.c

608

sbp->f_bsize = PAGE_SIZE;

sys/kern/uipc_mqueue.c

609

sbp->f_iosize = PAGE_SIZE;

sys/kern/uipc_shm.c

2047

end = pistart != piend ? PAGE_SIZE : endofs;

sys/kern/uipc_shm.c

207

tlen = MIN(PAGE_SIZE - offset, len);

sys/kern/uipc_shm.c

290

*first = rounddown2(pidx, pagesizes[psind] / PAGE_SIZE);

sys/kern/uipc_shm.c

316

PAGE_SIZE);

sys/kern/uipc_shm.c

319

*after = roundup2(pindex, pagesizes[psind] / PAGE_SIZE) -

sys/kern/uipc_shm.c

339

object->size / (pagesizes[psind] / PAGE_SIZE));

sys/kern/uipc_shm.c

630

sb->st_blksize = PAGE_SIZE;

sys/kern/uipc_shm.c

750

OFF_TO_IDX(length), base, PAGE_SIZE);

sys/kern/uipc_shm.c

833

pagesizes[psind] / PAGE_SIZE, 0, ~0,

sys/kern/uipc_shm.c

847

pagesizes[psind] / PAGE_SIZE, 0, ~0,

sys/kern/uipc_shm.c

860

for (i = 0; i < pagesizes[psind] / PAGE_SIZE; i++) {

sys/kern/vfs_bio.c

1099

physmem_est = physmem_est * (PAGE_SIZE / 1024);

sys/kern/vfs_bio.c

2985

resid = ((foff + PAGE_SIZE) & ~(off_t)PAGE_MASK) - foff;

sys/kern/vfs_bio.c

3015

foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;

sys/kern/vfs_bio.c

3065

presid = resid > (PAGE_SIZE - poffset) ?

sys/kern/vfs_bio.c

3066

(PAGE_SIZE - poffset) : resid;

sys/kern/vfs_bio.c

3184

tinc = PAGE_SIZE - ((bp->b_offset + toff) & PAGE_MASK);

sys/kern/vfs_bio.c

3194

tinc = PAGE_SIZE;

sys/kern/vfs_bio.c

3739

size = PAGE_SIZE;

sys/kern/vfs_bio.c

3751

if (tinc > PAGE_SIZE - ((toff + off) & PAGE_MASK))

sys/kern/vfs_bio.c

3752

tinc = PAGE_SIZE - ((toff + off) & PAGE_MASK);

sys/kern/vfs_bio.c

3799

noff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;

sys/kern/vfs_bio.c

4367

if (bp->b_bufsize == 0 && newbsize <= PAGE_SIZE/2 &&

sys/kern/vfs_bio.c

4719

eoff = (off + PAGE_SIZE) & ~(vm_ooffset_t)PAGE_MASK;

sys/kern/vfs_bio.c

4749

eoff = (off + PAGE_SIZE) & ~(off_t)PAGE_MASK;

sys/kern/vfs_bio.c

4849

foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;

sys/kern/vfs_bio.c

4881

n = PAGE_SIZE - (base & PAGE_MASK);

sys/kern/vfs_bio.c

4890

for (i = base / PAGE_SIZE; size > 0 && i < bp->b_npages; ++i) {

sys/kern/vfs_bio.c

4897

n = PAGE_SIZE;

sys/kern/vfs_bio.c

4930

slide = imin(slide + PAGE_SIZE, bp->b_offset + bp->b_bufsize);

sys/kern/vfs_bio.c

4933

ea = PAGE_SIZE;

sys/kern/vfs_bio.c

4970

n = PAGE_SIZE - (base & PAGE_MASK);

sys/kern/vfs_bio.c

4971

for (i = base / PAGE_SIZE; size > 0 && i < bp->b_npages; ++i) {

sys/kern/vfs_bio.c

4978

n = PAGE_SIZE;

sys/kern/vfs_bio.c

5046

for (pg = from; pg < to; pg += PAGE_SIZE, index++) {

sys/kern/vfs_bio.c

5270

PAGE_SIZE == bp->b_npages,

sys/kern/vfs_bio.c

5343

la += PAGE_SIZE;

sys/kern/vfs_bio.c

5362

PAGE_SIZE) - la);

sys/kern/vfs_bio.c

5397

poffe = MIN(poff + PAGE_SIZE, object->un_pager.vnp.vnp_size);

sys/kern/vfs_cluster.c

414

if ((bp->b_npages * PAGE_SIZE) +

sys/kern/vfs_cluster.c

452

if (toff + tinc > PAGE_SIZE)

sys/kern/vfs_cluster.c

453

tinc = PAGE_SIZE - toff;

sys/kern/vfs_cluster.c

952

(vp->v_mount->mnt_iosize_max / PAGE_SIZE))) {

sys/kern/vfs_default.c

1610

sb->st_blksize = max(PAGE_SIZE, vap->va_blocksize);

sys/kern/vfs_subr.c

2650

vn_pages_remove(vp, OFF_TO_IDX(start), OFF_TO_IDX(end + PAGE_SIZE - 1));

sys/kern/vfs_vnops.c

1151

resid -= PAGE_SIZE;

sys/kern/vfs_vnops.c

1152

off += PAGE_SIZE;

sys/kern/vfs_vnops.c

1169

resid = PAGE_SIZE - (uio->uio_offset & PAGE_MASK) + ptoa(i - 1);

sys/kern/vfs_vnops.c

1452

if (len < PAGE_SIZE) {

sys/kern/vfs_vnops.c

1465

len -= PAGE_SIZE;

sys/kern/vfs_vnops.c

1466

base += PAGE_SIZE;

sys/kern/vfs_vnops.c

1467

resid -= PAGE_SIZE;

sys/net/bpf_zerocopy.c

161

if (vm_fault_quick_hold_pages(map, uaddr, PAGE_SIZE, VM_PROT_READ |

sys/net/bpf_zerocopy.c

201

if ((len / PAGE_SIZE) > BPF_MAX_PAGES)

sys/net/bpf_zerocopy.c

211

zb->zb_numpages = len / PAGE_SIZE;

sys/net/bpf_zerocopy.c

217

uaddr + (i * PAGE_SIZE));

sys/net/bpf_zerocopy.c

261

page = offset / PAGE_SIZE;

sys/net/bpf_zerocopy.c

262

poffset = offset % PAGE_SIZE;

sys/net/bpf_zerocopy.c

267

count = min(len, PAGE_SIZE - poffset);

sys/net/bpf_zerocopy.c

271

if (poffset == PAGE_SIZE) {

sys/net/bpf_zerocopy.c

275

KASSERT(poffset < PAGE_SIZE,

sys/net/bpf_zerocopy.c

316

page = offset / PAGE_SIZE;

sys/net/bpf_zerocopy.c

317

poffset = offset % PAGE_SIZE;

sys/net/bpf_zerocopy.c

327

count = min(count, PAGE_SIZE - poffset);

sys/net/bpf_zerocopy.c

332

if (poffset == PAGE_SIZE) {

sys/net/bpf_zerocopy.c

336

KASSERT(poffset < PAGE_SIZE,

sys/net/bpf_zerocopy.c

495

*i = BPF_MAX_PAGES * PAGE_SIZE;

sys/net/if_vxlan.c

738

size = PAGE_SIZE; /* Calculate later. */

sys/net/vnet.c

171

#define VNET_MODMIN (8 * PAGE_SIZE)

sys/net/vnet.c

172

#define VNET_SIZE roundup2(VNET_BYTES, PAGE_SIZE)

sys/netinet/ip_output.c

916

if (len > PAGE_SIZE) {

sys/netinet/netdump/netdump_client.c

102

static unsigned char nd_buf[MAXDUMPPGS * PAGE_SIZE];

sys/netinet/netdump/netdump_client.c

583

dumper.maxiosize = MAXDUMPPGS * PAGE_SIZE;

sys/netinet/netdump/netdump_client.c

744

u.di.maxiosize = MAXDUMPPGS * PAGE_SIZE;

sys/netinet/tcp_output.c

2042

fragsize = min(segsize, PAGE_SIZE);

sys/netinet/tcp_stacks/rack.c

18073

fragsize = min(segsize, PAGE_SIZE);

sys/netipsec/ipsec_pcb.c

445

if (optlen < sizeof(struct sadb_x_policy) || optlen > PAGE_SIZE)

sys/ofed/drivers/infiniband/core/ib_core_uverbs.c

198

if (entry->npages * PAGE_SIZE != vma->vm_end - vma->vm_start) {

sys/ofed/drivers/infiniband/core/ib_core_uverbs.c

314

npages = (u32)DIV_ROUND_UP(length, PAGE_SIZE);

sys/ofed/drivers/infiniband/core/ib_device.c

154

if (i < 0 || i >= PAGE_SIZE * 8)

sys/ofed/drivers/infiniband/core/ib_device.c

161

i = find_first_zero_bit(inuse, PAGE_SIZE * 8);

sys/ofed/drivers/infiniband/core/ib_sysfs.c

1270

ib_get_device_fw_str(dev, buf, PAGE_SIZE);

sys/ofed/drivers/infiniband/core/ib_sysfs.c

1271

strlcat(buf, "\n", PAGE_SIZE);

sys/ofed/drivers/infiniband/core/ib_umem.c

125

umem->page_size = PAGE_SIZE;

sys/ofed/drivers/infiniband/core/ib_umem.c

183

PAGE_SIZE / sizeof (struct page *)),

sys/ofed/drivers/infiniband/core/ib_umem.c

190

cur_base += ret * PAGE_SIZE;

sys/ofed/drivers/infiniband/core/ib_umem.c

194

sg_set_page(sg, page_list[i], PAGE_SIZE, 0);

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

162

item->context->invalidate_range(item, start, start + PAGE_SIZE);

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

179

address + PAGE_SIZE,

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

459

0, PAGE_SIZE,

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

486

base_virt_addr + (page_index * PAGE_SIZE),

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

487

base_virt_addr + ((page_index+1)*PAGE_SIZE),

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

566

min_t(size_t, ALIGN(bcnt, PAGE_SIZE) / PAGE_SIZE,

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

567

PAGE_SIZE / sizeof(struct page *));

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

638

idx = (addr - ib_umem_start(umem)) / PAGE_SIZE;

sys/ofed/drivers/infiniband/core/ib_umem_odp.c

646

ib_dma_unmap_page(dev, dma_addr, PAGE_SIZE,

sys/ofed/drivers/infiniband/core/ib_uverbs_ioctl.c

596

if (hdr.length > PAGE_SIZE ||

sys/ofed/drivers/infiniband/core/ib_uverbs_ioctl.c

91

WARN_ON_ONCE(method_elm->bundle_size > PAGE_SIZE);

sys/ofed/drivers/infiniband/ulp/sdp/sdp.h

111

#define SDP_MIN_ZCOPY_THRESH PAGE_SIZE

sys/ofed/drivers/infiniband/ulp/sdp/sdp.h

90

#define SDP_FMR_SIZE (MIN(0x1000, PAGE_SIZE) / sizeof(u64))

sys/ofed/drivers/infiniband/ulp/sdp/sdp.h

94

#define SDP_MAX_RDMA_READ_LEN (PAGE_SIZE * (SDP_FMR_SIZE - 2))

sys/ofed/drivers/infiniband/ulp/sdp/sdp_zcopy.c

738

offset = (unsigned long)iov->iov_base & (PAGE_SIZE - 1);

sys/ofed/include/rdma/rdmavt_mr.h

67

#define RVT_SEGSZ (PAGE_SIZE / sizeof(struct rvt_seg))

sys/ofed/include/rdma/rdmavt_qp.h

392

#define RVT_QPNMAP_ENTRIES (RVT_QPN_MAX / PAGE_SIZE / BITS_PER_BYTE)

sys/ofed/include/rdma/rdmavt_qp.h

393

#define RVT_BITS_PER_PAGE (PAGE_SIZE * BITS_PER_BYTE)

sys/ofed/include/rdma/uverbs_ioctl.h

517

PAGE_SIZE / sizeof(void *) || \

sys/opencrypto/criov.c

166

count = min(PAGE_SIZE - off, len);

sys/opencrypto/criov.c

181

if ((skip + len - 1) / PAGE_SIZE > skip / PAGE_SIZE)

sys/opencrypto/criov.c

184

pages += (skip / PAGE_SIZE);

sys/opencrypto/criov.c

185

skip -= rounddown(skip, PAGE_SIZE);

sys/opencrypto/criov.c

202

count = min(PAGE_SIZE - off, len);

sys/opencrypto/criov.c

227

count = min(PAGE_SIZE - off, len);

sys/opencrypto/criov.c

252

if (m->m_epg_pa[i - 1] + PAGE_SIZE != m->m_epg_pa[i])

sys/opencrypto/criov.c

366

remain = MIN(PAGE_SIZE - cc->cc_offset, cc->cc_buf_len);

sys/opencrypto/criov.c

441

*len = PAGE_SIZE - cc->cc_offset;

sys/opencrypto/criov.c

499

remain = MIN(PAGE_SIZE - cc->cc_offset, cc->cc_buf_len);

sys/opencrypto/criov.c

588

remain = MIN(PAGE_SIZE - cc->cc_offset, cc->cc_buf_len);

sys/opencrypto/criov.c

73

if (off < PAGE_SIZE) \

sys/opencrypto/criov.c

75

processed += PAGE_SIZE - off; \

sys/opencrypto/criov.c

76

off -= PAGE_SIZE - off; \

sys/opencrypto/crypto.c

1245

KASSERT(cb->cb_vm_page_offset < PAGE_SIZE,

sys/powerpc/aim/mmu_oea.c

1060

bcopy((void *)src, (void *)dst, PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

1073

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/powerpc/aim/mmu_oea.c

1077

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/powerpc/aim/mmu_oea.c

1095

bzero((void *)pa, PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

1217

moea_syncicache(VM_PAGE_TO_PHYS(m), PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

1569

moea_remove(kernel_pmap, va, va + PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

1653

for (; pa_start < pa_end; pa_start += PAGE_SIZE, va += PAGE_SIZE)

sys/powerpc/aim/mmu_oea.c

1856

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

1873

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

2703

size = roundup(offset + size, PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

2722

size -= PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

2723

tmpva += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

2724

ppa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

2743

size = roundup(offset + size, PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

2823

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

2827

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

2838

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

798

(kernelend & ~PAGE_MASK) + PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

816

phys_avail[j] = (kernelend & ~PAGE_MASK) + PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

849

PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

933

off += PAGE_SIZE)

sys/powerpc/aim/mmu_oea.c

961

pa = moea_bootstrap_alloc(kstack_pages * PAGE_SIZE, PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

962

va = virtual_avail + KSTACK_GUARD_PAGES * PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

963

virtual_avail = va + kstack_pages * PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

969

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

970

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

976

pa = msgbuf_phys = moea_bootstrap_alloc(msgbufsize, PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

982

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

983

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

989

pa = moea_bootstrap_alloc(DPCPU_SIZE, PAGE_SIZE);

sys/powerpc/aim/mmu_oea.c

995

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea.c

996

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1046

(PAGE_SIZE * PAGE_SIZE)) * BPVO_POOL_EXPANSION_FACTOR;

sys/powerpc/aim/mmu_oea64.c

1058

moea64_bpvo_pool_size*sizeof(struct pvo_entry), PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1175

virtual_end += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1183

pa = moea64_bootstrap_alloc(kstack_pages * PAGE_SIZE, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1184

va = virtual_avail + KSTACK_GUARD_PAGES * PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1185

virtual_avail = va + kstack_pages * PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1191

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1192

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1198

pa = msgbuf_phys = moea64_bootstrap_alloc(msgbufsize, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1204

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1205

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1211

pa = moea64_bootstrap_alloc(DPCPU_SIZE, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1217

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1218

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1223

virtual_avail += MAXDUMPPGS * PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1236

moea64_scratchpage_va[i] = (virtual_end+1) - PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1237

virtual_end -= PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

1262

pc->pc_qmap_addr = kva_alloc(PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1438

(void *)moea64_scratchpage_va[1], PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1453

PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1466

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/powerpc/aim/mmu_oea64.c

1471

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/powerpc/aim/mmu_oea64.c

1493

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/powerpc/aim/mmu_oea64.c

1498

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/powerpc/aim/mmu_oea64.c

1515

if (size + off > PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

1542

bzero((void *)va, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1554

bzero((void *)va, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1717

moea64_syncicache(pmap, va, pa, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

1817

m = vm_radix_iter_jump(&pages, HPT_SP_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

2216

moea64_remove(kernel_pmap, va, va + PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

2330

for (va = pa_start; va < pa_end; va += PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

2339

for (; pa_start < pa_end; pa_start += PAGE_SIZE, va += PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

2546

PVO_PADDR(pvo), PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

2610

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

2624

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3131

ppa < pa + size; ppa += PAGE_SIZE,

sys/powerpc/aim/mmu_oea64.c

3156

size = roundup2(offset + size, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

3165

size -= PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3166

tmpva += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3167

ppa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3188

size = roundup2(offset + size, PAGE_SIZE);

sys/powerpc/aim/mmu_oea64.c

3271

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3275

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3284

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3334

for (; pa < pa_end; pa += PAGE_SIZE) {

sys/powerpc/aim/mmu_oea64.c

3355

dump_ctx.blksz = blkpgs * PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3393

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3394

va += PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

3707

i++, va += PAGE_SIZE, pa += PAGE_SIZE, m++) {

sys/powerpc/aim/mmu_oea64.c

3804

pa < pa_end; pa += PAGE_SIZE, va += PAGE_SIZE) {

sys/powerpc/aim/mmu_oea64.c

3921

va += PAGE_SIZE, pa += PAGE_SIZE) {

sys/powerpc/aim/mmu_oea64.c

693

if (pa_base % PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

695

if (translations[i].om_va % PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

704

for (off = 0; off < translations[i].om_len; off += PAGE_SIZE) {

sys/powerpc/aim/mmu_oea64.c

846

pa += PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

852

pa += PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

859

for (pa = off; pa < off + size; pa += PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

863

for (pa = EXC_RSVD; pa < EXC_LAST; pa += PAGE_SIZE)

sys/powerpc/aim/mmu_oea64.c

975

(kernelphysend & ~PAGE_MASK) + PAGE_SIZE;

sys/powerpc/aim/mmu_oea64.c

994

PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1116

start += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1121

start += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1315

va_last = va + L3_PAGE_SIZE - PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1325

va += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1701

va_last = va + L3_PAGE_SIZE - PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1704

va += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1815

start += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1854

for (int i = 0; i < RADIX_PGD_SIZE/PAGE_SIZE; i++)

sys/powerpc/aim/mmu_radix.c

1855

pagezero(PHYS_TO_DMAP(l1phys + i * PAGE_SIZE));

sys/powerpc/aim/mmu_radix.c

1866

pages += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1869

pages += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

1883

for (int i = 0; i < nkpt; i++, pte++, pages += PAGE_SIZE)

sys/powerpc/aim/mmu_radix.c

1944

if (regions[i].mr_size < PAGE_SIZE)

sys/powerpc/aim/mmu_radix.c

1987

(kpend & ~PAGE_MASK) + PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2006

PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2037

for (int i = 0; i < PARTTAB_SIZE/PAGE_SIZE; i++)

sys/powerpc/aim/mmu_radix.c

2038

pagezero(PHYS_TO_DMAP(parttab_phys + i * PAGE_SIZE));

sys/powerpc/aim/mmu_radix.c

2044

for (int i = 0; i < proctab_size/PAGE_SIZE; i++)

sys/powerpc/aim/mmu_radix.c

2045

pagezero(PHYS_TO_DMAP(proctab0pa + i * PAGE_SIZE));

sys/powerpc/aim/mmu_radix.c

2083

va = virtual_avail + KSTACK_GUARD_PAGES * PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2084

virtual_avail = va + kstack_pages * PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2089

pa += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2090

va += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2108

virtual_avail += MAXDUMPPGS * PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2282

va -= PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2299

pte++, sva += PAGE_SIZE) {

sys/powerpc/aim/mmu_radix.c

2588

L3_PAGE_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

2655

addr += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2681

bcopy((void *)src, (void *)dst, PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

2697

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/powerpc/aim/mmu_radix.c

2702

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/powerpc/aim/mmu_radix.c

2759

pa = (newpde & (PG_PS_FRAME | PG_A | PG_V)) + L3_PAGE_SIZE - PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

2785

pa -= PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

3307

for (mt = m; mt < &m[L3_PAGE_SIZE / PAGE_SIZE]; mt++)

sys/powerpc/aim/mmu_radix.c

3316

pmap->pm_stats.wired_count += L3_PAGE_SIZE / PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

3317

pmap_resident_count_inc(pmap, L3_PAGE_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

3358

m = vm_radix_iter_jump(&pages, L3_PAGE_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

3631

RADIX_PGD_SIZE / PAGE_SIZE,

sys/powerpc/aim/mmu_radix.c

3647

page_count = RADIX_PGD_SIZE/PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

3745

error = vmem_alloc(kernel_arena, PAGE_SIZE, M_BESTFIT | M_WAITOK,

sys/powerpc/aim/mmu_radix.c

4084

for (pa = ptepa + PAGE_SIZE; pa < ptepa + size;

sys/powerpc/aim/mmu_radix.c

4085

pa += PAGE_SIZE) {

sys/powerpc/aim/mmu_radix.c

4114

pmap_resident_count_inc(pmap, L3_PAGE_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

4259

pagezero((vm_offset_t)pmap->pm_pml1 + j * PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

4518

va < eva; va += PAGE_SIZE, m++)

sys/powerpc/aim/mmu_radix.c

4626

sva += PAGE_SIZE) {

sys/powerpc/aim/mmu_radix.c

4681

while (va < sva + PAGE_SIZE * count) {

sys/powerpc/aim/mmu_radix.c

4699

va += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

4704

PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

4720

while (va < sva + PAGE_SIZE * count) {

sys/powerpc/aim/mmu_radix.c

4725

va += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

4913

newpte += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

5084

pmap->pm_stats.wired_count -= (L3_PAGE_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

5085

pmap_resident_count_dec(pmap, L3_PAGE_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

5092

va < eva; va += PAGE_SIZE, m++) {

sys/powerpc/aim/mmu_radix.c

5195

sva += PAGE_SIZE) {

sys/powerpc/aim/mmu_radix.c

5208

sva += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

5252

if (sva + PAGE_SIZE == eva) {

sys/powerpc/aim/mmu_radix.c

5554

for (mt = m; mt < &m[L3_PAGE_SIZE / PAGE_SIZE]; mt++)

sys/powerpc/aim/mmu_radix.c

5565

pmap_resident_count_dec(pmap, L3_PAGE_SIZE / PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

5570

for (mt = m; mt < &m[L3_PAGE_SIZE / PAGE_SIZE]; mt++)

sys/powerpc/aim/mmu_radix.c

5756

PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

5764

sva += PAGE_SIZE) {

sys/powerpc/aim/mmu_radix.c

5800

MPASS(off + size <= PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

5902

size = roundup2(offset + size, PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

5916

size -= PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

5917

tmpva += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

5918

ppa += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

5952

PAGE_SIZE, m->md.mdpg_cache_attrs))

sys/powerpc/aim/mmu_radix.c

5989

sync_sz = PAGE_SIZE - (va & PAGE_MASK);

sys/powerpc/aim/mmu_radix.c

6307

tmpva += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

6387

pa_end = pa_start + PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

6389

pa_end += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

6399

pa_end = pa_start + PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

6402

tmpva += PAGE_SIZE;

sys/powerpc/aim/mmu_radix.c

6458

pa = vm_phys_early_alloc(domain, PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

646

#define NL2EPG (PAGE_SIZE/sizeof(pml2_entry_t))

sys/powerpc/aim/mmu_radix.c

6468

dump_add_page(pa + i * PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

647

#define NL3EPG (PAGE_SIZE/sizeof(pml3_entry_t))

sys/powerpc/aim/mmu_radix.c

670

CTASSERT(sizeof(struct pv_chunk) == PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

890

bzero((void *)va, PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

898

ret = moea64_bootstrap_alloc(n * PAGE_SIZE, PAGE_SIZE);

sys/powerpc/aim/mmu_radix.c

900

pagezero(PHYS_TO_DMAP(ret + i * PAGE_SIZE));

sys/powerpc/aim/moea64_native.c

645

for (pa = off; pa < off + size; pa += PAGE_SIZE)

sys/powerpc/aim/slb.c

502

VM_ALLOC_WIRED, 1, 0, realmax, PAGE_SIZE, PAGE_SIZE,

sys/powerpc/booke/booke_machdep.c

295

ptr = (void *)pmap_early_io_map(arg1, PAGE_SIZE);

sys/powerpc/booke/booke_machdep.c

310

pmap_early_io_unmap((vm_offset_t)ptr, PAGE_SIZE);

sys/powerpc/booke/pmap.c

1000

pc->pc_qmap_addr = kva_alloc(PAGE_SIZE);

sys/powerpc/booke/pmap.c

1107

va += PAGE_SIZE;

sys/powerpc/booke/pmap.c

1124

va += PAGE_SIZE;

sys/powerpc/booke/pmap.c

1172

__syncicache((void *)va, PAGE_SIZE);

sys/powerpc/booke/pmap.c

1438

__syncicache((void *)va, PAGE_SIZE);

sys/powerpc/booke/pmap.c

1532

for (; va < endva; va += PAGE_SIZE) {

sys/powerpc/booke/pmap.c

1584

va += PAGE_SIZE;

sys/powerpc/booke/pmap.c

1585

pa_start += PAGE_SIZE;

sys/powerpc/booke/pmap.c

1683

for (va = sva; va < eva; va += PAGE_SIZE) {

sys/powerpc/booke/pmap.c

1976

for (va = sva; va < eva; va += PAGE_SIZE) {

sys/powerpc/booke/pmap.c

2173

va += PAGE_SIZE;

sys/powerpc/booke/pmap.c

2177

va += PAGE_SIZE;

sys/powerpc/booke/pmap.c

2186

va += PAGE_SIZE;

sys/powerpc/booke/pmap.c

2261

size = roundup(size, PAGE_SIZE);

sys/powerpc/booke/pmap.c

2337

size = roundup(offset + size, PAGE_SIZE);

sys/powerpc/booke/pmap.c

2427

for (va = addr; va < addr + sz; va += PAGE_SIZE) {

sys/powerpc/booke/pmap.c

2435

for (va = addr; va < addr + sz; va += PAGE_SIZE) {

sys/powerpc/booke/pmap.c

2879

size = roundup(size, PAGE_SIZE);

sys/powerpc/booke/pmap.c

2914

pa_base = rounddown(pa, PAGE_SIZE);

sys/powerpc/booke/pmap.c

2915

size = roundup(size + (pa - pa_base), PAGE_SIZE);

sys/powerpc/booke/pmap.c

698

sz = (round_page(sz) / (PAGE_SIZE + sizeof(struct vm_page)));

sys/powerpc/booke/pmap.c

733

virtual_avail += PAGE_SIZE;

sys/powerpc/booke/pmap.c

735

virtual_avail += PAGE_SIZE;

sys/powerpc/booke/pmap.c

737

virtual_avail += PAGE_SIZE;

sys/powerpc/booke/pmap.c

748

virtual_avail += PTBL_BUFS * PTBL_PAGES * PAGE_SIZE;

sys/powerpc/booke/pmap.c

755

virtual_avail += MAXDUMPPGS * PAGE_SIZE;

sys/powerpc/booke/pmap.c

834

kstack0_sz = kstack_pages * PAGE_SIZE;

sys/powerpc/booke/pmap.c

928

kstack0 = virtual_avail + KSTACK_GUARD_PAGES * PAGE_SIZE;

sys/powerpc/booke/pmap.c

938

virtual_avail += KSTACK_GUARD_PAGES * PAGE_SIZE + kstack0_sz;

sys/powerpc/booke/pmap.c

941

kstack0 += PAGE_SIZE;

sys/powerpc/booke/pmap.c

942

kstack0_phys += PAGE_SIZE;

sys/powerpc/booke/pmap_32.c

116

#define VM_MAPDEV_BASE ((vm_offset_t)VM_MAXUSER_ADDRESS + PAGE_SIZE)

sys/powerpc/booke/pmap_32.c

171

__func__, ptbl_buf_pool_vabase, PTBL_BUFS * PTBL_PAGES * PAGE_SIZE);

sys/powerpc/booke/pmap_32.c

178

ptbl_buf_pool_vabase + i * PTBL_PAGES * PAGE_SIZE;

sys/powerpc/booke/pmap_32.c

286

bzero((caddr_t)ptbl, PTBL_PAGES * PAGE_SIZE);

sys/powerpc/booke/pmap_32.c

329

va = ((vm_offset_t)ptbl + (i * PAGE_SIZE));

sys/powerpc/booke/pmap_32.c

371

(vm_offset_t)ptbl + (i * PAGE_SIZE));

sys/powerpc/booke/pmap_32.c

417

(vm_offset_t)ptbl + (i * PAGE_SIZE));

sys/powerpc/booke/pmap_32.c

616

*pva = PDIR_SIZE * i + PAGE_SIZE * j;

sys/powerpc/booke/pmap_32.c

640

(pte_t *)(pdir_start + (i * PAGE_SIZE * PTBL_PAGES));

sys/powerpc/booke/pmap_32.c

649

for (va = addr; va < data_end; va += PAGE_SIZE) {

sys/powerpc/booke/pmap_32.c

675

data_end += kernel_ptbls * PTBL_PAGES * PAGE_SIZE;

sys/powerpc/booke/pmap_32.c

744

sync_sz = PAGE_SIZE - (va & PAGE_MASK);

sys/powerpc/booke/pmap_32.c

813

bzero((void *)va, PAGE_SIZE);

sys/powerpc/booke/pmap_32.c

837

memcpy((caddr_t)dva, (caddr_t)sva, PAGE_SIZE);

sys/powerpc/booke/pmap_32.c

855

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/powerpc/booke/pmap_32.c

860

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/powerpc/booke/pmap_32.c

907

__syncicache((void *)qaddr, PAGE_SIZE);

sys/powerpc/booke/pmap_64.c

236

PAGE_SIZE * l;

sys/powerpc/booke/pmap_64.c

534

pdir_va = l1_va + pdir_l1s * PAGE_SIZE;

sys/powerpc/booke/pmap_64.c

535

ptbl_va = pdir_va + kernel_pdirs * PAGE_SIZE;

sys/powerpc/booke/pmap_64.c

545

i++, l1_va += PAGE_SIZE) {

sys/powerpc/booke/pmap_64.c

549

j++, pdir_va += PAGE_SIZE) {

sys/powerpc/booke/pmap_64.c

553

k++, va += PDIR_SIZE, ptbl_va += PAGE_SIZE)

sys/powerpc/booke/pmap_64.c

563

for (va = addr; va < data_end; va += PAGE_SIZE) {

sys/powerpc/booke/pmap_64.c

578

data_end += howmany(kva_size, PG_ROOT_SIZE) * PAGE_SIZE;

sys/powerpc/booke/pmap_64.c

579

data_end += howmany(kva_size, PDIR_L1_SIZE) * PAGE_SIZE;

sys/powerpc/booke/pmap_64.c

580

data_end += howmany(kva_size, PDIR_SIZE) * PAGE_SIZE;

sys/powerpc/booke/pmap_64.c

647

sync_sz = PAGE_SIZE - (va & PAGE_MASK);

sys/powerpc/booke/pmap_64.c

686

bzero((void *)va, PAGE_SIZE);

sys/powerpc/booke/pmap_64.c

701

memcpy((caddr_t)dva, (caddr_t)sva, PAGE_SIZE);

sys/powerpc/booke/pmap_64.c

719

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/powerpc/booke/pmap_64.c

720

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/powerpc/include/param.h

101

#define PAGE_MASK (PAGE_SIZE - 1)

sys/powerpc/include/param.h

102

#define NPTEPG (PAGE_SIZE/(sizeof (pt_entry_t)))

sys/powerpc/include/param.h

103

#define NPDEPG (PAGE_SIZE/(sizeof (pt_entry_t)))

sys/powerpc/include/param.h

129

#define USPACE (kstack_pages * PAGE_SIZE) /* total size of pcb */

sys/powerpc/include/pcpu_aux.h

46

_Static_assert(PAGE_SIZE % sizeof(struct pcpu) == 0, "fix pcpu size");

sys/powerpc/include/pte.h

359

#define PDIR_L1_PAGES ((PDIR_L1_NENTRIES * (1<<PDIR_L1_ENTRY_SHIFT)) / PAGE_SIZE)

sys/powerpc/include/pte.h

376

#define PDIR_PAGES ((PDIR_NENTRIES * (1<<PDIR_ENTRY_SHIFT)) / PAGE_SIZE)

sys/powerpc/include/pte.h

390

#define PTBL_SIZE PAGE_SIZE /* va range mapped by ptbl entry */

sys/powerpc/include/pte.h

394

#define PTBL_PAGES ((PTBL_NENTRIES * (1<<PTBL_ENTRY_SHIFT)) / PAGE_SIZE)

sys/powerpc/include/pte.h

421

#define PTBL_SIZE PAGE_SIZE /* va range mapped by ptbl entry */

sys/powerpc/include/stack.h

41

(total) = td->td_kstack_pages * PAGE_SIZE - sizeof(struct pcb); \

sys/powerpc/include/stack.h

49

va + len <= td->td_kstack + td->td_kstack_pages * PAGE_SIZE -

sys/powerpc/include/vmparam.h

107

#define SHAREDPAGE (VM_MAXUSER_ADDRESS - PAGE_SIZE)

sys/powerpc/include/vmparam.h

109

#define FREEBSD32_SHAREDPAGE (VM_MAXUSER_ADDRESS32 - PAGE_SIZE)

sys/powerpc/mpc85xx/fsl_diu.c

407

M_DEVBUF, M_ZERO, 0, BUS_SPACE_MAXADDR_32BIT, PAGE_SIZE, 0);

sys/powerpc/mpc85xx/fsl_diu.c

414

BUS_SPACE_MAXADDR_32BIT, PAGE_SIZE, 0);

sys/powerpc/mpc85xx/fsl_diu.c

421

BUS_SPACE_MAXADDR_32BIT, PAGE_SIZE, 0);

sys/powerpc/mpc85xx/fsl_sata.c

1870

cpi->maxio = (FSL_SATA_SG_ENTRIES - 1) * PAGE_SIZE;

sys/powerpc/mpc85xx/platform_mpc85xx.c

359

rel_page = kva_alloc(PAGE_SIZE);

sys/powerpc/mpc85xx/platform_mpc85xx.c

380

kva_free(rel_page, PAGE_SIZE);

sys/powerpc/mpc85xx/platform_mpc85xx.c

465

(tgt << OCP85XX_TRGT_SHIFT_QORIQ) | (ffsl(PAGE_SIZE) - 2));

sys/powerpc/ofw/ofw_machdep.c

637

tmp_fdt_ptr = pmap_early_io_map((vm_paddr_t)fdt, PAGE_SIZE);

sys/powerpc/ofw/ofw_machdep.c

639

pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE);

sys/powerpc/ofw/ofw_machdep.c

643

pmap_early_io_unmap(tmp_fdt_ptr, PAGE_SIZE);

sys/powerpc/ofw/ofw_real.c

276

temp = contigmalloc(4 * PAGE_SIZE, M_OFWREAL, 0, 0,

sys/powerpc/ofw/ofw_real.c

277

ulmin(platform_real_maxaddr(), BUS_SPACE_MAXADDR_32BIT), PAGE_SIZE,

sys/powerpc/ofw/ofw_real.c

278

4 * PAGE_SIZE);

sys/powerpc/ofw/ofw_real.c

287

of_bounce_size = 4 * PAGE_SIZE;

sys/powerpc/ofw/rtas.c

107

rtas_bounce_virt = contigmalloc(rtas_size + PAGE_SIZE, M_RTAS, 0, 0,

sys/powerpc/ofw/rtas.c

114

rtas_bounce_size = PAGE_SIZE;

sys/powerpc/powermac/dbdma.c

74

BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE, 0, NULL,

sys/powerpc/powermac/dbdma.c

82

channel->sc_slots, PAGE_SIZE, dbdma_phys_callback, channel, 0);

sys/powerpc/powermac/dbdma.c

95

if (newslots > (PAGE_SIZE / sizeof(struct dbdma_command)))

sys/powerpc/powermac/grackle.c

133

sc->sc_addr = (vm_offset_t)pmap_mapdev(GRACKLE_ADDR, PAGE_SIZE);

sys/powerpc/powermac/grackle.c

134

sc->sc_data = (vm_offset_t)pmap_mapdev(GRACKLE_DATA, PAGE_SIZE);

sys/powerpc/powermac/platform_powermac.c

376

rstvec_virtbase = pmap_mapdev(0x80000000, PAGE_SIZE);

sys/powerpc/powermac/smu.c

301

BUS_SPACE_MAXADDR, NULL, NULL, PAGE_SIZE, 1, PAGE_SIZE, 0, NULL,

sys/powerpc/powermac/smu.c

313

sc->sc_cmd, PAGE_SIZE, smu_phys_callback, sc, 0);

sys/powerpc/powermac/uninorth.c

394

sc->sc_addr = (vm_offset_t)pmap_mapdev(sc->sc_physaddr, PAGE_SIZE);

sys/powerpc/powermac/uninorthpci.c

165

sc->sc_addr = (vm_offset_t)pmap_mapdev(regbase + 0x800000, PAGE_SIZE);

sys/powerpc/powermac/uninorthpci.c

166

sc->sc_data = (vm_offset_t)pmap_mapdev(regbase + 0xc00000, PAGE_SIZE);

sys/powerpc/powernv/opal_flash.c

177

size = MIN(count, PAGE_SIZE);

sys/powerpc/powernv/opal_flash.c

178

size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK));

sys/powerpc/powernv/opal_flash.c

256

size = MIN(count, PAGE_SIZE);

sys/powerpc/powernv/opal_flash.c

257

size = MIN(size, PAGE_SIZE - ((u_long)data & PAGE_MASK));

sys/powerpc/powernv/opal_nvram.c

146

0, BUS_SPACE_MAXADDR, PAGE_SIZE, 0);

sys/powerpc/powernv/xive.c

375

xive_cpud->queue.q_page = contigmalloc(PAGE_SIZE, M_XIVE,

sys/powerpc/powernv/xive.c

376

M_ZERO | M_WAITOK, 0, BUS_SPACE_MAXADDR, PAGE_SIZE, 0);

sys/powerpc/powerpc/bus_machdep.c

136

va += PAGE_SIZE;

sys/powerpc/powerpc/bus_machdep.c

137

pa += PAGE_SIZE;

sys/powerpc/powerpc/busdma_machdep.c

173

newtag->lowaddr = trunc_page((vm_paddr_t)lowaddr) + (PAGE_SIZE - 1);

sys/powerpc/powerpc/busdma_machdep.c

174

newtag->highaddr = trunc_page((vm_paddr_t)highaddr) + (PAGE_SIZE - 1);

sys/powerpc/powerpc/busdma_machdep.c

427

if ((dmat->maxsize <= PAGE_SIZE) &&

sys/powerpc/powerpc/busdma_machdep.c

493

PAGE_SIZE - (curaddr & PAGE_MASK));

sys/powerpc/powerpc/busdma_machdep.c

527

PAGE_SIZE - ((vm_offset_t)vaddr & PAGE_MASK));

sys/powerpc/powerpc/busdma_machdep.c

574

sgsize = MIN(sgsize, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/powerpc/powerpc/busdma_machdep.c

648

sgsize = MIN(buflen, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/powerpc/powerpc/db_trace.c

157

if (stackframe < PAGE_SIZE)

sys/powerpc/powerpc/db_trace.c

175

if (stackframe < PAGE_SIZE)

sys/powerpc/powerpc/elf32_machdep.c

131

.sv_shared_page_len = PAGE_SIZE,

sys/powerpc/powerpc/elf64_machdep.c

138

.sv_shared_page_len = PAGE_SIZE,

sys/powerpc/powerpc/elf64_machdep.c

94

.sv_shared_page_len = PAGE_SIZE,

sys/powerpc/powerpc/exec_machdep.c

1086

PAGE_SIZE - sizeof(struct pcb), 0x40);

sys/powerpc/powerpc/machdep.c

151

struct pcpu __pcpu[MAXCPU] __aligned(PAGE_SIZE);

sys/powerpc/powerpc/machdep.c

228

(uintmax_t)size1, (uintmax_t)size1 / PAGE_SIZE);

sys/powerpc/powerpc/machdep.c

494

thread0.td_kstack_pages * PAGE_SIZE - sizeof(struct pcb), 16);

sys/powerpc/powerpc/machdep.c

572

kernelimg = (u_char *)pmap_early_io_map(start, PAGE_SIZE);

sys/powerpc/powerpc/machdep.c

578

pmap_early_io_unmap(start, PAGE_SIZE);

sys/powerpc/powerpc/machdep.c

584

pmap_early_io_unmap(start, PAGE_SIZE);

sys/powerpc/powerpc/mem.c

117

cnt = PAGE_SIZE - ((vm_offset_t)iov->iov_base &

sys/powerpc/powerpc/mem.c

119

cnt = min(cnt, PAGE_SIZE - off);

sys/powerpc/powerpc/mem.c

154

for (; va < eva; va += PAGE_SIZE) {

sys/powerpc/powerpc/minidump_machdep.c

103

maxdumpsz = MIN(di->maxiosize, MAXDUMPPGS * PAGE_SIZE);

sys/powerpc/powerpc/minidump_machdep.c

105

maxdumpsz = PAGE_SIZE;

sys/powerpc/powerpc/minidump_machdep.c

107

if ((sz % PAGE_SIZE) != 0) {

sys/powerpc/powerpc/minidump_machdep.c

115

if ((pa % PAGE_SIZE) != 0) {

sys/powerpc/powerpc/minidump_machdep.c

142

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

sys/powerpc/powerpc/minidump_machdep.c

176

ctx = dumpsys_dump_pmap_init(sizeof(pgbuf) / PAGE_SIZE);

sys/powerpc/powerpc/minidump_machdep.c

207

if (pmapsize % PAGE_SIZE != 0) {

sys/powerpc/powerpc/minidump_machdep.c

214

dumpsize = PAGE_SIZE; /* header */

sys/powerpc/powerpc/minidump_machdep.c

222

dumpsize += PAGE_SIZE;

sys/powerpc/powerpc/minidump_machdep.c

258

error = blk_write(di, pgbuf, 0, PAGE_SIZE);

sys/powerpc/powerpc/minidump_machdep.c

261

dump_total("header", PAGE_SIZE);

sys/powerpc/powerpc/minidump_machdep.c

272

error = blk_write(di, pgbuf, 0, PAGE_SIZE);

sys/powerpc/powerpc/minidump_machdep.c

292

error = blk_write(di, 0, pa, PAGE_SIZE);

sys/powerpc/powerpc/minidump_machdep.c

69

static char pgbuf[PAGE_SIZE];

sys/powerpc/powerpc/stack_machdep.c

58

if (frame < PAGE_SIZE)

sys/powerpc/powerpc/stack_machdep.c

62

if (frame < PAGE_SIZE)

sys/powerpc/powerpc/uio_machdep.c

94

cnt = min(cnt, PAGE_SIZE - page_offset);

sys/powerpc/powerpc/vm_machdep.c

127

td2->td_kstack_pages * PAGE_SIZE - sizeof(struct pcb), 0x40);

sys/powerpc/ps3/if_glc.c

181

BUS_SPACE_MAXADDR_32BIT, 8, PAGE_SIZE);

sys/powerpc/ps3/ps3_syscons.c

146

for (va = 0; va < sc->fb_info.fb_size; va += PAGE_SIZE)

sys/powerpc/ps3/ps3cdrom.c

194

BUS_SPACE_UNRESTRICTED, 1, PAGE_SIZE, 0,

sys/powerpc/ps3/ps3cdrom.c

430

cpi->maxio = PAGE_SIZE;

sys/powerpc/ps3/ps3disk.c

215

BUS_SPACE_UNRESTRICTED, 1, PAGE_SIZE, 0,

sys/powerpc/ps3/ps3disk.c

242

d->d_maxsize = PAGE_SIZE;

sys/powerpc/ps3/ps3pic.c

124

PAGE_SIZE /* boundary */);

sys/powerpc/pseries/phyp_llan.c

280

sc->rx_buf_len = segs[0].ds_len - 2*PAGE_SIZE;

sys/powerpc/pseries/phyp_llan.c

281

sc->input_buf_phys = segs[0].ds_addr + segs[0].ds_len - PAGE_SIZE;

sys/powerpc/pseries/phyp_llan.c

282

sc->filter_buf_phys = segs[0].ds_addr + segs[0].ds_len - 2*PAGE_SIZE;

sys/powerpc/pseries/phyp_llan.c

61

#define LLAN_RX_BUF_LEN 8*PAGE_SIZE

sys/powerpc/pseries/phyp_vscsi.c

325

error = bus_dma_tag_create(bus_get_dma_tag(dev), PAGE_SIZE, 0,

sys/powerpc/pseries/phyp_vscsi.c

326

BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL, 8*PAGE_SIZE,

sys/powerpc/pseries/phyp_vscsi.c

333

8*PAGE_SIZE, vscsi_crq_load_cb, sc, 0);

sys/powerpc/pseries/phyp_vscsi.c

724

sc->n_crqs = PAGE_SIZE/sizeof(struct vscsi_crq);

sys/powerpc/pseries/phyp_vscsi.c

728

sc->srp_iu_arena = vmem_create("VSCSI SRP IU", PAGE_SIZE,

sys/powerpc/pseries/phyp_vscsi.c

729

segs[0].ds_len - PAGE_SIZE, 16, 0, M_BESTFIT | M_NOWAIT);

sys/powerpc/pseries/plpar_iommu.c

138

window->map->vmem = vmem_create("IOMMU mappings", PAGE_SIZE,

sys/powerpc/pseries/plpar_iommu.c

139

trunc_page(VMEM_ADDR_MAX) - PAGE_SIZE, PAGE_SIZE, 0,

sys/powerpc/pseries/plpar_iommu.c

181

(alignment < PAGE_SIZE) ? PAGE_SIZE : alignment, 0,

sys/powerpc/pseries/plpar_iommu.c

187

KASSERT(alloced % PAGE_SIZE == 0, ("Alloc not page aligned"));

sys/powerpc/pseries/plpar_iommu.c

194

for (j = 0; j < allocsize; j += PAGE_SIZE) {

sys/powerpc/pseries/plpar_iommu.c

232

roundedsize/PAGE_SIZE);

sys/powerpc/pseries/plpar_iommu.c

234

for (j = 0; j < roundedsize; j += PAGE_SIZE)

sys/riscv/include/param.h

79

#define PAGE_MASK (PAGE_SIZE - 1)

sys/riscv/include/pcpu_aux.h

46

_Static_assert(PAGE_SIZE % sizeof(struct pcpu) == 0, "fix pcpu size");

sys/riscv/include/stack.h

56

(total) = td->td_kstack_pages * PAGE_SIZE - sizeof(struct pcb); \

sys/riscv/include/stack.h

64

va + len <= td->td_kstack + td->td_kstack_pages * PAGE_SIZE -

sys/riscv/include/vmparam.h

203

#define SHAREDPAGE_SV39 (VM_MAX_USER_ADDRESS_SV39 - PAGE_SIZE)

sys/riscv/include/vmparam.h

204

#define SHAREDPAGE_SV48 (VM_MAX_USER_ADDRESS_SV48 - PAGE_SIZE)

sys/riscv/riscv/busdma_bounce.c

428

if ((dmat->common.maxsize <= PAGE_SIZE) &&

sys/riscv/riscv/busdma_bounce.c

434

howmany(dmat->common.maxsize, MIN(dmat->common.maxsegsz, PAGE_SIZE)) &&

sys/riscv/riscv/busdma_bounce.c

435

dmat->common.alignment <= PAGE_SIZE &&

sys/riscv/riscv/busdma_bounce.c

436

(dmat->common.boundary % PAGE_SIZE) == 0) {

sys/riscv/riscv/busdma_bounce.c

503

PAGE_SIZE - (curaddr & PAGE_MASK));

sys/riscv/riscv/busdma_bounce.c

538

PAGE_SIZE - ((vm_offset_t)vaddr & PAGE_MASK));

sys/riscv/riscv/busdma_bounce.c

589

sgsize = MIN(sgsize, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/riscv/riscv/busdma_bounce.c

670

sgsize = MIN(buflen, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/riscv/riscv/busdma_bounce.c

784

len = min(PAGE_SIZE - offset, size);

sys/riscv/riscv/busdma_machdep.c

81

common->lowaddr = trunc_page((vm_paddr_t)lowaddr) + (PAGE_SIZE - 1);

sys/riscv/riscv/busdma_machdep.c

82

common->highaddr = trunc_page((vm_paddr_t)highaddr) + (PAGE_SIZE - 1);

sys/riscv/riscv/elf_machdep.c

91

.sv_shared_page_len = PAGE_SIZE,

sys/riscv/riscv/machdep.c

123

static char static_kenv[PAGE_SIZE];

sys/riscv/riscv/machdep.c

150

(uintmax_t)size, (uintmax_t)size / PAGE_SIZE);

sys/riscv/riscv/machdep.c

300

thread0.td_kstack_pages * PAGE_SIZE) - 1;

sys/riscv/riscv/mem.c

71

cnt = ulmin(iov->iov_len, PAGE_SIZE - (u_int)off);

sys/riscv/riscv/minidump_machdep.c

105

if ((((uintptr_t)pa) % PAGE_SIZE) != 0) {

sys/riscv/riscv/minidump_machdep.c

184

pmapsize += PAGE_SIZE;

sys/riscv/riscv/minidump_machdep.c

196

for (i = 0; i < Ln_ENTRIES; i++, pa += PAGE_SIZE) {

sys/riscv/riscv/minidump_machdep.c

206

pa = (l3e >> PTE_PPN0_S) * PAGE_SIZE;

sys/riscv/riscv/minidump_machdep.c

223

dumpsize += PAGE_SIZE;

sys/riscv/riscv/minidump_machdep.c

227

dumpsize += PAGE_SIZE;

sys/riscv/riscv/minidump_machdep.c

257

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

271

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

286

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

303

error = blk_write(di, (char *)&tmpbuffer, 0, PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

312

pa = (l2e >> PTE_PPN0_S) * PAGE_SIZE;

sys/riscv/riscv/minidump_machdep.c

319

error = blk_write(di, NULL, pa, PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

322

PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

331

error = blk_write(di, 0, pa, PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

63

static uint64_t tmpbuffer[PAGE_SIZE / sizeof(uint64_t)];

sys/riscv/riscv/minidump_machdep.c

93

maxdumpsz = min(di->maxiosize, MAXDUMPPGS * PAGE_SIZE);

sys/riscv/riscv/minidump_machdep.c

95

maxdumpsz = PAGE_SIZE;

sys/riscv/riscv/minidump_machdep.c

97

if ((sz % PAGE_SIZE) != 0) {

sys/riscv/riscv/mp_machdep.c

71

#define MP_BOOTSTACK_SIZE (kstack_pages * PAGE_SIZE)

sys/riscv/riscv/pmap.c

1300

pn = (pa / PAGE_SIZE);

sys/riscv/riscv/pmap.c

1306

va += PAGE_SIZE;

sys/riscv/riscv/pmap.c

1307

pa += PAGE_SIZE;

sys/riscv/riscv/pmap.c

1308

size -= PAGE_SIZE;

sys/riscv/riscv/pmap.c

1352

va += PAGE_SIZE;

sys/riscv/riscv/pmap.c

1353

size -= PAGE_SIZE;

sys/riscv/riscv/pmap.c

1402

pn = (pa / PAGE_SIZE);

sys/riscv/riscv/pmap.c

1428

for (va = sva; count-- > 0; va += PAGE_SIZE) {

sys/riscv/riscv/pmap.c

1985

pn = (paddr / PAGE_SIZE);

sys/riscv/riscv/pmap.c

2011

pn = (paddr / PAGE_SIZE);

sys/riscv/riscv/pmap.c

2378

va_last = va + L2_SIZE - PAGE_SIZE;

sys/riscv/riscv/pmap.c

2387

va += PAGE_SIZE;

sys/riscv/riscv/pmap.c

2434

va_last = va + L2_SIZE - PAGE_SIZE;

sys/riscv/riscv/pmap.c

2437

va += PAGE_SIZE;

sys/riscv/riscv/pmap.c

2530

pmap->pm_stats.wired_count -= L2_SIZE / PAGE_SIZE;

sys/riscv/riscv/pmap.c

2531

pmap_resident_count_dec(pmap, L2_SIZE / PAGE_SIZE);

sys/riscv/riscv/pmap.c

2538

va < eva; va += PAGE_SIZE, m++) {

sys/riscv/riscv/pmap.c

3007

newl1 = ((l2phys / PAGE_SIZE) << PTE_PPN0_S) | PTE_V;

sys/riscv/riscv/pmap.c

3072

newl2 = ((mptepa / PAGE_SIZE) << PTE_PPN0_S) | PTE_V;

sys/riscv/riscv/pmap.c

3179

pa += L2_SIZE - PAGE_SIZE;

sys/riscv/riscv/pmap.c

3203

pa -= PAGE_SIZE;

sys/riscv/riscv/pmap.c

3273

pn = (pa / PAGE_SIZE);

sys/riscv/riscv/pmap.c

3453

pmap_sync_icache(pmap, va, PAGE_SIZE);

sys/riscv/riscv/pmap.c

3523

pn = VM_PAGE_TO_PHYS(m) / PAGE_SIZE;

sys/riscv/riscv/pmap.c

360

memcpy(d, s, PAGE_SIZE);

sys/riscv/riscv/pmap.c

3613

for (sva = va; sva < va + L2_SIZE; sva += PAGE_SIZE) {

sys/riscv/riscv/pmap.c

367

bzero(p, PAGE_SIZE);

sys/riscv/riscv/pmap.c

3676

for (mt = m; mt < &m[L2_SIZE / PAGE_SIZE]; mt++)

sys/riscv/riscv/pmap.c

3684

pmap->pm_stats.wired_count += L2_SIZE / PAGE_SIZE;

sys/riscv/riscv/pmap.c

3685

pmap->pm_stats.resident_count += L2_SIZE / PAGE_SIZE;

sys/riscv/riscv/pmap.c

3736

m = vm_radix_iter_jump(&pages, L2_SIZE / PAGE_SIZE);

sys/riscv/riscv/pmap.c

376

((((pte) & ~PTE_HI_MASK) >> PTE_PPN0_S) * PAGE_SIZE)

sys/riscv/riscv/pmap.c

3861

newl3 = ((VM_PAGE_TO_PHYS(m) / PAGE_SIZE) << PTE_PPN0_S) |

sys/riscv/riscv/pmap.c

3875

pmap_sync_icache(pmap, va, PAGE_SIZE);

sys/riscv/riscv/pmap.c

4050

if (off == 0 && size == PAGE_SIZE)

sys/riscv/riscv/pmap.c

4090

cnt = min(xfersize, PAGE_SIZE - a_pg_offset);

sys/riscv/riscv/pmap.c

4091

cnt = min(cnt, PAGE_SIZE - b_pg_offset);

sys/riscv/riscv/pmap.c

4930

pmap_change_attr(PHYS_TO_DMAP(VM_PAGE_TO_PHYS(m)), PAGE_SIZE,

sys/riscv/riscv/pmap.c

5040

tmpva += PAGE_SIZE;

sys/riscv/riscv/pmap.c

5102

tmpva += PAGE_SIZE;

sys/riscv/riscv/pmap.c

5118

tmpva += PAGE_SIZE;

sys/riscv/riscv/pmap.c

5317

error = vmem_alloc(kernel_arena, PAGE_SIZE,

sys/riscv/riscv/pmap.c

5526

sbuf_new_for_sysctl(sb, NULL, PAGE_SIZE, req);

sys/riscv/riscv/pmap.c

574

*freemempos += npages * PAGE_SIZE;

sys/riscv/riscv/pmap.c

575

bzero(pt, npages * PAGE_SIZE);

sys/riscv/riscv/pmap.c

785

freemempos = roundup2(kernend, PAGE_SIZE);

sys/riscv/riscv/pmap.c

983

for (i = 0; i < howmany(DPCPU_SIZE, PAGE_SIZE); i++)

sys/riscv/riscv/pmap.c

997

for (i = 0; i < howmany(msgbufsize, PAGE_SIZE); i++)

sys/riscv/riscv/uio_machdep.c

89

cnt = min(cnt, PAGE_SIZE - page_offset);

sys/riscv/riscv/vm_machdep.c

65

td->td_kstack_pages * PAGE_SIZE) - 1;

sys/riscv/sifive/sifive_ccache.c

96

step = min(PAGE_SIZE - (paddr & PAGE_MASK), len);

sys/riscv/vmm/vmm.c

589

addr = (vme->htval << 2) & ~(PAGE_SIZE - 1);

sys/riscv/vmm/vmm_fence.c

106

va += PAGE_SIZE)

sys/riscv/vmm/vmm_fence.c

115

va += PAGE_SIZE)

sys/riscv/vmm/vmm_riscv.c

131

hyp = malloc_aligned(size, PAGE_SIZE, M_HYP, M_WAITOK | M_ZERO);

sys/riscv/vmm/vmm_riscv.c

213

hypctx = malloc_aligned(size, PAGE_SIZE, M_HYP, M_WAITOK | M_ZERO);

sys/security/mac_veriexec/veriexec_fingerprint.c

149

filebuf = malloc(PAGE_SIZE, M_VERIEXEC, M_WAITOK);

sys/security/mac_veriexec/veriexec_fingerprint.c

154

if ((offset + PAGE_SIZE) > file_size)

sys/security/mac_veriexec/veriexec_fingerprint.c

157

count = PAGE_SIZE;

sys/sys/_pv_entry.h

107

_Static_assert(sizeof(struct pv_chunk) == PAGE_SIZE,

sys/sys/_pv_entry.h

63

#if PAGE_SIZE == 4 * 1024

sys/sys/_pv_entry.h

71

#elif PAGE_SIZE == 16 * 1024

sys/sys/imgact.h

39

#define MAXSHELLCMDLEN PAGE_SIZE

sys/sys/imgact_binmisc.h

49

#define IBE_MATCH_MAX PAGE_SIZE

sys/sys/mbuf.h

252

(MBUF_PEXT_MAX_PGS * PAGE_SIZE + MBUF_PEXT_HDR_LEN + MBUF_PEXT_TRAIL_LEN)

sys/sys/mbuf.h

424

return (PAGE_SIZE - pgoff);

sys/sys/mbuf.h

442

MCHECK(m->m_epg_1st_off < PAGE_SIZE, \

sys/sys/mbuf.h

445

MCHECK(m->m_epg_last_len <= PAGE_SIZE, \

sys/sys/mbuf.h

449

m->m_epg_last_len <= PAGE_SIZE, \

sys/sys/param.h

175

#define BLKDEV_IOSIZE PAGE_SIZE /* default block device I/O size */

sys/sys/param.h

181

#define MAXDUMPPGS (DFLTPHYS/PAGE_SIZE)

sys/sys/param.h

201

#if PAGE_SIZE <= 8192

sys/sys/param.h

202

#define MJUMPAGESIZE PAGE_SIZE

sys/sys/param.h

213

#define round_page(x) roundup2(x, PAGE_SIZE)

sys/sys/param.h

214

#define trunc_page(x) rounddown2(x, PAGE_SIZE)

sys/sys/param.h

219

#define pgtok(x) ((x) * (PAGE_SIZE / 1024))

sys/sys/pcpu.h

221

#define UMA_PCPU_ALLOC_SIZE PAGE_SIZE

sys/sys/pcpu.h

75

#define DPCPU_SIZE roundup2(DPCPU_BYTES, PAGE_SIZE)

sys/sys/pipe.h

37

#define SMALL_PIPE_SIZE PAGE_SIZE

sys/sys/pipe.h

48

#define PIPENPAGES (BIG_PIPE_SIZE / PAGE_SIZE + 1)

sys/sys/shm.h

55

#define SHMLBA PAGE_SIZE /* Segment low boundary address multiple */

sys/ufs/ffs/ffs_rawread.c

204

bp->b_bcount -= PAGE_SIZE;

sys/ufs/ffs/ffs_vnops.c

1959

if (!use_buf_pager && um->um_devvp->v_bufobj.bo_bsize <= PAGE_SIZE)

sys/ufs/ffs/ffs_vnops.c

1978

if (um->um_devvp->v_bufobj.bo_bsize <= PAGE_SIZE) {

sys/ufs/ufs/ufs_dirhash.c

1303

ufs_dirhashmaxmem = lmax(roundup(hibufspace / 64, PAGE_SIZE),

sys/ufs/ufs/ufs_vnops.c

2733

*ap->a_retval = PAGE_SIZE;

sys/ufs/ufs/ufs_vnops.c

328

ip->i_ump->um_bsize >= PAGE_SIZE) {

sys/ufs/ufs/ufs_vnops.c

566

sb->st_blksize = max(PAGE_SIZE, vp->v_mount->mnt_stat.f_iosize);

sys/vm/device_pager.c

530

for (off = foff; npages--; off += PAGE_SIZE) {

sys/vm/device_pager.c

539

*color = atop(paddr) - OFF_TO_IDX(off - PAGE_SIZE);

sys/vm/memguard.c

173

PAGE_SIZE;

sys/vm/memguard.c

186

memguard_physlimit = (mem_pgs / vm_memguard_divisor) * PAGE_SIZE;

sys/vm/memguard.c

194

if (memguard_mapsize / (2 * PAGE_SIZE) > mem_pgs)

sys/vm/memguard.c

195

memguard_mapsize = mem_pgs * 2 * PAGE_SIZE;

sys/vm/memguard.c

213

PAGE_SIZE, 0, M_WAITOK);

sys/vm/memguard.c

306

size_v += 2 * PAGE_SIZE;

sys/vm/memguard.c

315

req_size < PAGE_SIZE) {

sys/vm/memguard.c

334

addr += PAGE_SIZE;

sys/vm/memguard.c

345

if (req_size < PAGE_SIZE) {

sys/vm/memguard.c

346

memguard_wasted += (PAGE_SIZE - req_size);

sys/vm/memguard.c

354

addr += (PAGE_SIZE - req_size);

sys/vm/memguard.c

394

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

sys/vm/memguard.c

406

addr -= PAGE_SIZE;

sys/vm/memguard.c

408

if (req_size < PAGE_SIZE)

sys/vm/memguard.c

409

memguard_wasted -= (PAGE_SIZE - req_size);

sys/vm/memguard.c

445

if ((memguard_options & MG_GUARD_ALLLARGE) != 0 && size >= PAGE_SIZE)

sys/vm/redzone.c

71

return (PAGE_SIZE);

sys/vm/sg_pager.c

173

if (space + sg->sg_segs[i].ss_len <= (offset * PAGE_SIZE)) {

sys/vm/sg_pager.c

177

paddr = sg->sg_segs[i].ss_paddr + offset * PAGE_SIZE - space;

sys/vm/sg_pager.c

93

if ((sg->sg_segs[i].ss_paddr % PAGE_SIZE) != 0 ||

sys/vm/sg_pager.c

94

(sg->sg_segs[i].ss_len % PAGE_SIZE) != 0)

sys/vm/sg_pager.c

96

npages += sg->sg_segs[i].ss_len / PAGE_SIZE;

sys/vm/swap_pager.c

1637

bp->b_bcount = PAGE_SIZE * n;

sys/vm/swap_pager.c

1638

bp->b_bufsize = PAGE_SIZE * n;

sys/vm/swap_pager.c

2750

blist_free(sp->sw_blist, howmany(BBSIZE, PAGE_SIZE),

sys/vm/swap_pager.c

2751

nblks - howmany(BBSIZE, PAGE_SIZE));

sys/vm/swap_pager.c

2769

swap_pager_avail += nblks - howmany(BBSIZE, PAGE_SIZE);

sys/vm/swap_pager.c

2943

nswapdev * howmany(BBSIZE, PAGE_SIZE);

sys/vm/swap_pager.c

3216

bio->bio_offset = (bp->b_blkno - sp->sw_first) * PAGE_SIZE;

sys/vm/swap_pager.c

694

nsw_cluster_max = min(maxphys / PAGE_SIZE, MAX_PAGEOUT_CLUSTER);

sys/vm/swap_pager.c

999

&bp->b_pages[0], bp->b_bcount / PAGE_SIZE);

sys/vm/uma_core.c

139

#define SLABZONE0_SETSIZE (PAGE_SIZE / 16)

sys/vm/uma_core.c

1600

keg->uk_name, keg, slab, PAGE_SIZE * keg->uk_ppera);

sys/vm/uma_core.c

1603

size = PAGE_SIZE * keg->uk_ppera;

sys/vm/uma_core.c

1797

size = keg->uk_ppera * PAGE_SIZE;

sys/vm/uma_core.c

1822

vsetzoneslab((vm_offset_t)mem + (i * PAGE_SIZE),

sys/vm/uma_core.c

1883

pages = howmany(bytes, PAGE_SIZE);

sys/vm/uma_core.c

1894

for (i = 0; i < pages; i++, pa += PAGE_SIZE) {

sys/vm/uma_core.c

1903

m->phys_addr + (pages * PAGE_SIZE), VM_PROT_READ | VM_PROT_WRITE));

sys/vm/uma_core.c

1921

for (; bytes != 0; bytes -= PAGE_SIZE, m++) {

sys/vm/uma_core.c

1965

MPASS(bytes == (mp_maxid + 1) * PAGE_SIZE);

sys/vm/uma_core.c

1996

zkva += PAGE_SIZE;

sys/vm/uma_core.c

2035

npages = howmany(bytes, PAGE_SIZE);

sys/vm/uma_core.c

2059

zkva += PAGE_SIZE;

sys/vm/uma_core.c

2144

MPASS(size == (mp_maxid+1)*PAGE_SIZE);

sys/vm/uma_core.c

2152

for (curva = sva; curva < sva + size; curva += PAGE_SIZE) {

sys/vm/uma_core.c

2269

kl->slabsize += PAGE_SIZE;

sys/vm/uma_core.c

2343

slabsize = rsize * (PAGE_SIZE / alignsize);

sys/vm/uma_core.c

2390

i = (slabsize + rsize - keg->uk_size) / MAX(PAGE_SIZE, rsize);

sys/vm/uma_core.c

2395

slabsize = (rsize <= PAGE_SIZE) ? ptoa(i) :

sys/vm/uma_core.c

2441

(keg->uk_ipers - 1) * rsize >= PAGE_SIZE) {

sys/vm/uma_core.c

2562

keg->uk_pgoff = (PAGE_SIZE * keg->uk_ppera) - shsize;

sys/vm/uma_core.c

2570

KASSERT(keg->uk_pgoff + shsize <= PAGE_SIZE * keg->uk_ppera,

sys/vm/uma_core.c

5202

kva = kva_alloc((vm_size_t)pages * PAGE_SIZE);

sys/vm/uma_core.c

5282

return (sz * PAGE_SIZE);

sys/vm/uma_core.c

5712

total = keg->uk_ppera * PAGE_SIZE;

sys/vm/uma_core.c

593

sz = keg->uk_ppera * PAGE_SIZE;

sys/vm/uma_core.c

605

sz = keg->uk_ppera * PAGE_SIZE;

sys/vm/uma_int.h

133

#define UMA_SLAB_SIZE PAGE_SIZE /* How big are our slabs? */

sys/vm/uma_int.h

134

#define UMA_SLAB_MASK (PAGE_SIZE - 1) /* Mask to get back to the page */

sys/vm/uma_int.h

369

#define SLAB_MAX_SETSIZE (PAGE_SIZE / UMA_SMALLEST_UNIT)

sys/vm/vm_dumpset.h

56

adj += howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_dumpset.h

57

dump_avail[i] / PAGE_SIZE;

sys/vm/vm_dumpset.h

75

adj += howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_dumpset.h

76

dump_avail[i] / PAGE_SIZE;

sys/vm/vm_dumpset.h

86

tot = howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_dumpset.h

87

dump_avail[i] / PAGE_SIZE;

sys/vm/vm_dumpset.h

89

return ((vm_paddr_t)bit * PAGE_SIZE +

sys/vm/vm_fault.c

1253

for (i = 0; i < PAGE_SIZE / sizeof(*p); i++, p++) {

sys/vm/vm_fault.c

1902

fs.entry->next_read = vaddr + ptoa(ahead) + PAGE_SIZE;

sys/vm/vm_fault.c

1974

PAGE_SIZE + behind * PAGE_SIZE);

sys/vm/vm_fault.c

1978

PAGE_SIZE + ahead * PAGE_SIZE);

sys/vm/vm_fault.c

2021

if (vaddr - end >= size - PAGE_SIZE - ptoa(ahead) &&

sys/vm/vm_fault.c

2084

if (addra < backward * PAGE_SIZE) {

sys/vm/vm_fault.c

2087

starta = addra - backward * PAGE_SIZE;

sys/vm/vm_fault.c

2109

addr = addra + ((i >> 1) + 1) * ((i & 1) == 0 ? -PAGE_SIZE :

sys/vm/vm_fault.c

2110

PAGE_SIZE);

sys/vm/vm_fault.c

2111

if (addr > addra + forward * PAGE_SIZE)

sys/vm/vm_fault.c

2193

for (mp = ma, va = addr; va < end; mp++, va += PAGE_SIZE) {

sys/vm/vm_fault.c

2231

for (mp = ma, va = addr; va < end; mp++, va += PAGE_SIZE) {

sys/vm/vm_fault.c

2370

vaddr += PAGE_SIZE, dst_pindex++) {

sys/vm/vm_glue.c

405

*addrp = *addrp + (kpages - rem) * PAGE_SIZE;

sys/vm/vm_glue.c

512

vm_thread_free_kstack_kva(ks - (KSTACK_GUARD_PAGES * PAGE_SIZE),

sys/vm/vm_glue.c

685

kstack_pages * PAGE_SIZE, NULL, NULL, NULL, NULL,

sys/vm/vm_glue.c

699

kstack_quantum -= (kstack_pages + KSTACK_GUARD_PAGES) * PAGE_SIZE;

sys/vm/vm_glue.c

706

PAGE_SIZE, 0, M_WAITOK);

sys/vm/vm_glue.c

743

stack_top = td->td_kstack + td->td_kstack_pages * PAGE_SIZE;

sys/vm/vm_init.c

112

KASSERT(pagesizes[0] == PAGE_SIZE, ("pagesizes[0] != PAGE_SIZE"));

sys/vm/vm_init.c

254

PAGE_SIZE, (mp_ncpus > 4) ? BKVASIZE * 8 : 0, M_WAITOK);

sys/vm/vm_init.c

262

kmi->buffer_eva, size, PAGE_SIZE, 0, M_WAITOK);

sys/vm/vm_init.c

278

exec_map_entries * exec_map_entry_size + 64 * PAGE_SIZE, false);

sys/vm/vm_kern.c

282

for (i = 0; i < asize; i += PAGE_SIZE) {

sys/vm/vm_kern.c

284

domain, pflags, 1, low, high, PAGE_SIZE, 0, memattr);

sys/vm/vm_kern.c

393

tmp += PAGE_SIZE;

sys/vm/vm_kern.c

566

for (; i < size; i += PAGE_SIZE) {

sys/vm/vm_kern.c

673

for (; offset < end; offset += PAGE_SIZE,

sys/vm/vm_kern.c

783

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

sys/vm/vm_kern.c

885

vmem_init(kernel_arena, "kernel arena", 0, 0, PAGE_SIZE, 0, 0);

sys/vm/vm_kern.c

896

"kernel arena domain", 0, 0, PAGE_SIZE, 0, M_WAITOK);

sys/vm/vm_kern.c

912

"kernel rwx arena domain", 0, 0, PAGE_SIZE, 0, M_WAITOK);

sys/vm/vm_kern.c

914

"kernel NOFREE arena domain", 0, 0, PAGE_SIZE, 0, M_WAITOK);

sys/vm/vm_kern.c

956

for (va = start; va < end; va += PAGE_SIZE) {

sys/vm/vm_map.c

4627

(vm_size_t)stack_guard_page * PAGE_SIZE;

sys/vm/vm_mmap.c

120

td->td_retval[0] = PAGE_SIZE;

sys/vm/vm_mmap.c

324

PAGE_SIZE));

sys/vm/vm_mmap.c

900

for (; addr < cend; addr += PAGE_SIZE) {

sys/vm/vm_page.c

237

PAGE_SIZE, NULL, NULL, NULL, NULL,

sys/vm/vm_page.c

254

#if PAGE_SIZE == 32768

sys/vm/vm_page.c

271

vm_cnt.v_page_size = PAGE_SIZE;

sys/vm/vm_page.c

3042

~(vm_paddr_t)0, PAGE_SIZE,

sys/vm/vm_page.c

3051

PAGE_SIZE, 0,

sys/vm/vm_page.c

3058

req, 1, pa, high, PAGE_SIZE,

sys/vm/vm_page.c

4071

for (i = 0; i < PAGE_SIZE / sizeof(*p); i++, p++) {

sys/vm/vm_page.c

5078

KASSERT(end - base <= PAGE_SIZE, ("%s: base %d end %d", __func__, base,

sys/vm/vm_page.c

5322

base + size <= PAGE_SIZE,

sys/vm/vm_page.c

5340

#if PAGE_SIZE == 32768

sys/vm/vm_page.c

5342

#elif PAGE_SIZE == 16384

sys/vm/vm_page.c

5344

#elif (PAGE_SIZE == 8192) && defined(atomic_set_16)

sys/vm/vm_page.c

5346

#elif (PAGE_SIZE == 4096) && defined(atomic_set_8)

sys/vm/vm_page.c

5373

#if PAGE_SIZE == 32768

sys/vm/vm_page.c

5375

#elif PAGE_SIZE == 16384

sys/vm/vm_page.c

5377

#elif (PAGE_SIZE == 8192) && defined(atomic_clear_16)

sys/vm/vm_page.c

5379

#elif (PAGE_SIZE == 4096) && defined(atomic_clear_8)

sys/vm/vm_page.c

5405

#if PAGE_SIZE == 32768

sys/vm/vm_page.c

5411

#elif PAGE_SIZE == 16384

sys/vm/vm_page.c

5417

#elif (PAGE_SIZE == 8192) && defined(atomic_fcmpset_16)

sys/vm/vm_page.c

5423

#elif (PAGE_SIZE == 4096) && defined(atomic_fcmpset_8)

sys/vm/vm_page.c

545

*vaddr += PAGE_SIZE;

sys/vm/vm_page.c

5626

if (base == 0 && size == PAGE_SIZE) {

sys/vm/vm_page.c

5741

for (b = i = 0; i <= PAGE_SIZE / DEV_BSIZE; ++i) {

sys/vm/vm_page.c

5742

if (i == (PAGE_SIZE / DEV_BSIZE) ||

sys/vm/vm_page.c

632

vm_page_dump_pages += howmany(dump_avail[i + 1], PAGE_SIZE) -

sys/vm/vm_page.c

633

dump_avail[i] / PAGE_SIZE;

sys/vm/vm_page.c

648

for (pa = new_end; pa < end; pa += PAGE_SIZE)

sys/vm/vm_page.c

665

pa += PAGE_SIZE;

sys/vm/vm_page.c

700

first_page = low_avail / PAGE_SIZE;

sys/vm/vm_page.c

706

pmap_page_array_startup(size / PAGE_SIZE);

sys/vm/vm_page.c

719

page_range = size / PAGE_SIZE;

sys/vm/vm_page.c

723

page_range = size / (PAGE_SIZE + sizeof(struct vm_page));

sys/vm/vm_page.c

733

if (size % (PAGE_SIZE + sizeof(struct vm_page)) >= PAGE_SIZE) {

sys/vm/vm_page.c

735

high_avail -= PAGE_SIZE;

sys/vm/vm_page.c

736

new_end -= PAGE_SIZE;

sys/vm/vm_page.c

754

for (pa = new_end; pa < end; pa += PAGE_SIZE)

sys/vm/vm_page.c

812

startp < endp; startp += PAGE_SIZE, m++) {

sys/vm/vm_page.h

194

#if PAGE_SIZE == 4096

sys/vm/vm_page.h

197

#elif PAGE_SIZE == 8192

sys/vm/vm_page.h

200

#elif PAGE_SIZE == 16384

sys/vm/vm_page.h

203

#elif PAGE_SIZE == 32768

sys/vm/vm_pageout.c

1083

vm_background_launder_max * PAGE_SIZE / 1024) {

sys/vm/vm_pageout.c

1086

launder = vm_background_launder_rate * PAGE_SIZE / 1024;

sys/vm/vm_pageout.c

2293

vmd->vmd_pageout_free_min = 2 * MAXBSIZE / PAGE_SIZE +

sys/vm/vm_phys.c

1075

vm_page_initfake(&range[i], start + PAGE_SIZE * i, memattr);

sys/vm/vm_phys.c

1097

page_count = (end - start) / PAGE_SIZE;

sys/vm/vm_phys.c

1998

if (alloc_size == PAGE_SIZE) {

sys/vm/vm_phys.c

2000

phys_avail[biggestone] += PAGE_SIZE;

sys/vm/vm_phys.c

776

((PAGE_SIZE << ilog2(npages)) - 1)) == 0,

sys/vm/vm_phys.c

812

((VM_PAGE_TO_PHYS(m) + npages * PAGE_SIZE) &

sys/vm/vm_phys.c

813

((PAGE_SIZE << ilog2(npages)) - 1)) == 0,

sys/vm/vm_phys.c

845

pa = m->phys_addr + PAGE_SIZE;

sys/vm/vm_phys.c

848

m_tmp++, pa += PAGE_SIZE)

sys/vm/vm_radix.c

103

((vm_paddr_t)vm_cnt.v_page_count * PAGE_SIZE) / (PAGE_SIZE +

sys/vm/vm_reserv.c

1303

ppn_align = (int)(ulmin(ulmax(PAGE_SIZE, alignment),

sys/vm/vm_reserv.c

1306

(int)(MIN(MAX(PAGE_SIZE, boundary),

sys/vm/vm_reserv.c

1416

return (VM_SUBLEVEL_0_NPAGES * PAGE_SIZE);

sys/vm/vm_reserv.c

1421

return (PAGE_SIZE);

sys/vm/vm_reserv.c

349

unused_pages * ((int)PAGE_SIZE / 1024), counter);

sys/vm/vnode_pager.c

1083

KASSERT(secmask < PAGE_SIZE && secmask > 0,

sys/vm/vnode_pager.c

1210

nextoff = tfoff + PAGE_SIZE;

sys/vm/vnode_pager.c

1381

vm_page_clear_dirty(m, pgoff, PAGE_SIZE -

sys/vm/vnode_pager.c

1552

vm_page_clear_dirty(ma[i], pos, PAGE_SIZE - pos);

sys/vm/vnode_pager.c

396

blocksperpage = (PAGE_SIZE / bsize);

sys/vm/vnode_pager.c

449

KASSERT(end > base && end <= PAGE_SIZE,

sys/vm/vnode_pager.c

552

PAGE_SIZE);

sys/vm/vnode_pager.c

598

pend = same_page ? (int)end & PAGE_MASK : PAGE_SIZE;

sys/vm/vnode_pager.c

689

for (i = 0; i < PAGE_SIZE / bsize; i++) {

sys/vm/vnode_pager.c

777

size = PAGE_SIZE;

sys/vm/vnode_pager.c

805

else if (count != PAGE_SIZE)

sys/vm/vnode_pager.c

807

PAGE_SIZE - count);

sys/x86/cpufreq/smist.c

174

strlcpy(data->buf, smist_magic, PAGE_SIZE);

sys/x86/cpufreq/smist.c

202

/*alignment*/ PAGE_SIZE, /*no boundary*/ 0,

sys/x86/cpufreq/smist.c

204

NULL, NULL, /*maxsize*/ PAGE_SIZE, /*segments*/ 1,

sys/x86/cpufreq/smist.c

205

/*maxsegsize*/ PAGE_SIZE, 0, NULL, NULL, &tag) != 0) {

sys/x86/cpufreq/smist.c

218

if (bus_dmamap_load(tag, map, cb_data.buf, PAGE_SIZE, set_ownership_cb,

sys/x86/iommu/amd_cmd.c

323

unit->x86c.qi_buf_maxsz = ilog2(AMDIOMMU_CMDBUF_MAX / PAGE_SIZE);

sys/x86/iommu/amd_cmd.c

337

qi_sz = ilog2(unit->x86c.inv_queue_size / PAGE_SIZE) + 8;

sys/x86/iommu/amd_drv.c

281

j++, seg_vaddr += PAGE_SIZE, m++) {

sys/x86/iommu/amd_event.c

278

unit->event_log_size, M_WAITOK | M_ZERO, 0, ~0ull, PAGE_SIZE,

sys/x86/iommu/intel_ctx.c

264

ma[i] = vm_page_getfake(entry->start + PAGE_SIZE * i,

sys/x86/iommu/intel_drv.c

236

DMAR_REG_RID, dmarh->Address, PAGE_SIZE);

sys/x86/iommu/intel_idpgtbl.c

438

PAGE_SIZE)

sys/x86/iommu/intel_intrmap.c

348

M_ZERO | M_WAITOK, 0, iommu_high, PAGE_SIZE, 0,

sys/x86/iommu/intel_intrmap.c

355

M_ZERO | M_WAITOK, 0, iommu_high, PAGE_SIZE, 0,

sys/x86/iommu/intel_qi.c

363

qi_sz = ilog2(unit->x86c.inv_queue_size / PAGE_SIZE);

sys/x86/iommu/iommu_utils.c

516

x86c->inv_queue_size = (1ULL << qi_sz) * PAGE_SIZE;

sys/x86/iommu/iommu_utils.c

526

M_WAITOK | M_ZERO, 0, iommu_high, PAGE_SIZE, 0,

sys/x86/iommu/iommu_utils.c

97

iommu_high, PAGE_SIZE, 0, VM_MEMATTR_DEFAULT);

sys/x86/iommu/x86_iommu.h

39

#define IOMMU_PAGE_SIZE PAGE_SIZE

sys/x86/isa/isa_dma.c

395

for (; va < (caddr_t) endva ; va += PAGE_SIZE) {

sys/x86/isa/isa_dma.c

402

if (priorpage + PAGE_SIZE != phys)

sys/x86/x86/busdma_bounce.c

435

if (dmat->common.maxsize <= PAGE_SIZE &&

sys/x86/x86/busdma_bounce.c

436

dmat->common.alignment <= PAGE_SIZE &&

sys/x86/x86/busdma_bounce.c

443

dmat->common.maxsize <= PAGE_SIZE,

sys/x86/x86/busdma_bounce.c

449

PAGE_SIZE)) &&

sys/x86/x86/busdma_bounce.c

450

dmat->common.alignment <= PAGE_SIZE &&

sys/x86/x86/busdma_bounce.c

451

(dmat->common.boundary % PAGE_SIZE) == 0) {

sys/x86/x86/busdma_bounce.c

517

PAGE_SIZE - (curaddr & PAGE_MASK));

sys/x86/x86/busdma_bounce.c

567

PAGE_SIZE - ((vm_offset_t)vaddr & PAGE_MASK));

sys/x86/x86/busdma_bounce.c

606

sg_len = PAGE_SIZE - ma_offs;

sys/x86/x86/busdma_bounce.c

661

sgsize = MIN(sgsize, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/x86/x86/busdma_bounce.c

724

sgsize = MIN(buflen, PAGE_SIZE - (curaddr & PAGE_MASK));

sys/x86/x86/busdma_bounce.c

787

sgsize = MIN(buflen, PAGE_SIZE - ma_offs);

sys/x86/x86/busdma_bounce.c

799

if ((ma_offs + sgsize) > PAGE_SIZE)

sys/x86/x86/busdma_bounce.c

888

datacount1 = min(PAGE_SIZE - bpage->dataoffs,

sys/x86/x86/busdma_bounce.c

929

datacount1 = min(PAGE_SIZE - bpage->dataoffs,

sys/x86/x86/busdma_machdep.c

86

common->lowaddr = trunc_page((vm_paddr_t)lowaddr) + (PAGE_SIZE - 1);

sys/x86/x86/busdma_machdep.c

87

common->highaddr = trunc_page((vm_paddr_t)highaddr) + (PAGE_SIZE - 1);

sys/x86/x86/dump_machdep.c

58

a = pa + i * PAGE_SIZE;

sys/x86/x86/local_apic.c

574

lapic_map = pmap_mapdev(addr, PAGE_SIZE);

sys/x86/x86/mp_x86.c

1168

kmem_free(bootstacks[cpu], kstack_pages * PAGE_SIZE);

sys/x86/x86/ucode.c

370

for (va = free; va < free + len; va += PAGE_SIZE)

sys/x86/x86/ucode.c

384

for (va = free; va < free + len; va += PAGE_SIZE)

sys/x86/x86/ucode.c

415

KASSERT(free % PAGE_SIZE == 0, ("unaligned boundary %p", (void *)free));

sys/x86/xen/hvm.c

180

uint8_t raw[PAGE_SIZE];

sys/x86/xen/hvm.c

181

} shared_page __attribute__((aligned(PAGE_SIZE)));

sys/x86/xen/hvm.c

188

_Static_assert(sizeof(shared_page) == PAGE_SIZE,

sys/x86/xen/pv.c

175

PAGE_SIZE);

sys/x86/xen/pv.c

176

physfree = MAX(roundup2((vm_paddr_t)_end - KERNBASE, PAGE_SIZE),

sys/x86/xen/pv.c

182

sizeof(struct hvm_memmap_table_entry), PAGE_SIZE),

sys/x86/xen/pv.c

196

PAGE_SIZE), physfree);

sys/x86/xen/pv.c

322

static char kenv_buffer[PAGE_SIZE];

tests/sys/aio/aio_test.c

1678

unmapped = mmap(NULL, PAGE_SIZE, PROT_NONE, MAP_GUARD, -1, 0);

tests/sys/file/closefrom_test.c

68

fp = fmemopen(shared_page, PAGE_SIZE - 1, "w");

tests/sys/file/closefrom_test.c

84

shared_page = mmap(NULL, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_ANON |

tests/sys/fs/fusefs/getattr.cc

166

EXPECT_EQ((blksize_t)PAGE_SIZE, sb.st_blksize);

tests/sys/kern/kern_copyin.c

147

munmap(addr, PAGE_SIZE);

tests/sys/kern/pdrfork.c

111

unmapped = mmap(NULL, PAGE_SIZE, PROT_NONE, MAP_GUARD, -1, 0);

tests/sys/kern/pdrfork.c

164

#define STACK_SZ (PAGE_SIZE * 10)

tests/sys/kern/pdwait.c

45

unmapped = mmap(NULL, PAGE_SIZE, PROT_NONE, MAP_GUARD, -1, 0);

tests/sys/kern/subr_physmem_test.c

101

physmem_exclude_region(4 * PAGE_SIZE - 1, PAGE_SIZE + 2,

tests/sys/kern/subr_physmem_test.c

105

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

106

ATF_CHECK_EQ(avail[1], 3 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

107

ATF_CHECK_EQ(avail[2], 6 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

108

ATF_CHECK_EQ(avail[3], 7 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

118

physmem_hardware_region(PAGE_SIZE, PAGE_SIZE / 2);

tests/sys/kern/subr_physmem_test.c

120

physmem_hardware_region( 2 * PAGE_SIZE, PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

122

physmem_hardware_region(PAGE_SIZE + PAGE_SIZE / 2, PAGE_SIZE / 2);

tests/sys/kern/subr_physmem_test.c

126

ATF_CHECK_EQ(avail[0], PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

127

ATF_CHECK_EQ(avail[1], 3 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

41

physmem_hardware_region(2 * PAGE_SIZE, PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

45

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

46

ATF_CHECK_EQ(avail[1], 3 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

49

physmem_hardware_region(2 * PAGE_SIZE, 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

52

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

53

ATF_CHECK_EQ(avail[1], 4 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

56

physmem_hardware_region(4 * PAGE_SIZE, PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

59

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

60

ATF_CHECK_EQ(avail[1], 5 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

63

physmem_hardware_region(4 * PAGE_SIZE, 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

66

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

67

ATF_CHECK_EQ(avail[1], 6 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

70

physmem_hardware_region(6 * PAGE_SIZE, PAGE_SIZE / 2);

tests/sys/kern/subr_physmem_test.c

73

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

74

ATF_CHECK_EQ(avail[1], 6 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

77

physmem_hardware_region(6 * PAGE_SIZE + PAGE_SIZE / 2, PAGE_SIZE / 2);

tests/sys/kern/subr_physmem_test.c

80

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

81

ATF_CHECK_EQ(avail[1], 7 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

90

physmem_hardware_region(2 * PAGE_SIZE, 5 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

91

physmem_exclude_region(4 * PAGE_SIZE, PAGE_SIZE, EXFLAG_NOALLOC);

tests/sys/kern/subr_physmem_test.c

95

ATF_CHECK_EQ(avail[0], 2 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

96

ATF_CHECK_EQ(avail[1], 4 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

97

ATF_CHECK_EQ(avail[2], 5 * PAGE_SIZE);

tests/sys/kern/subr_physmem_test.c

98

ATF_CHECK_EQ(avail[3], 7 * PAGE_SIZE);

tests/sys/vm/mmap_test.c

99

p = mmap((void *)map_at_zero_tests[i].addr, PAGE_SIZE,

tools/build/cross-build/include/common/sys/param.h

44

#define BLKDEV_IOSIZE PAGE_SIZE /* default block device I/O size */

tools/build/cross-build/include/common/sys/param.h

53

#define MAXDUMPPGS (DFLTPHYS / PAGE_SIZE)

tools/test/stress2/testcases/badcode/badcode.c

105

if (mprotect(st, PAGE_SIZE, PROT_WRITE | PROT_READ |

tools/test/stress2/tools/bench.c

326

len = PAGE_SIZE;

tools/test/vm86/vm86_test.c

103

vm86_code = mmap((void *)0x10000, PAGE_SIZE, PROT_READ | PROT_WRITE |

tools/test/vm86/vm86_test.c

85

ssa.ss_size = PAGE_SIZE * 128;

tools/tools/syscall_timing/syscall_timing.c

623

buf = mmap(0, PAGE_SIZE, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);

tools/tools/syscall_timing/syscall_timing.c

667

error = munmap(buf, PAGE_SIZE);

usr.bin/mdo/mdo.c

121

} else if (old_size < PAGE_SIZE)

usr.bin/mdo/mdo.c

128

new_size = roundup2(old_size, PAGE_SIZE) + PAGE_SIZE;

usr.bin/posixshmcontrol/posixshmcontrol.c

450

PAGE_SIZE) / st.st_blocks);

usr.bin/truss/syscalls.c

1005

if (size > PAGE_SIZE)

usr.bin/truss/syscalls.c

1006

size = PAGE_SIZE;

usr.bin/truss/syscalls.c

1745

int32_t strarray32[PAGE_SIZE / sizeof(int32_t)];

usr.bin/truss/syscalls.c

1746

int64_t strarray64[PAGE_SIZE / sizeof(int64_t)];

usr.bin/truss/syscalls.c

1747

char buf[PAGE_SIZE];

usr.bin/truss/syscalls.c

1778

len = PAGE_SIZE - (addr & PAGE_MASK);

usr.bin/truss/syscalls.c

1810

len = PAGE_SIZE;

usr.bin/truss/syscalls.c

983

size = PAGE_SIZE - (addr % PAGE_SIZE);

usr.sbin/bhyve/amd64/kernemu_dev.c

59

.size = PAGE_SIZE,

usr.sbin/bhyve/bootrom.c

260

(var_size != 0 && var_size < PAGE_SIZE)) {

usr.sbin/bhyve/bootrom.c

281

for (i = 0; i < rom_size / PAGE_SIZE; i++) {

usr.sbin/bhyve/bootrom.c

282

rlen = read(fd, ptr + i * PAGE_SIZE, PAGE_SIZE);

usr.sbin/bhyve/bootrom.c

283

if (rlen != PAGE_SIZE) {

usr.sbin/bhyve/pci_nvme.c

105

#define NVME_PRP2_ITEMS (PAGE_SIZE/sizeof(uint64_t))

usr.sbin/bhyve/pci_nvme.c

1132

bytes = PAGE_SIZE - (prp1 & PAGE_MASK);

usr.sbin/bhyve/pci_nvme.c

1152

len = MIN(len, PAGE_SIZE);

usr.sbin/bhyve/pci_nvme.c

2438

size = MIN(PAGE_SIZE - (prp1 % PAGE_SIZE), bytes);

usr.sbin/bhyve/pci_nvme.c

2449

} else if (bytes <= PAGE_SIZE) {

usr.sbin/bhyve/pci_nvme.c

2463

if ((prp_list == last) && (bytes > PAGE_SIZE)) {

usr.sbin/bhyve/pci_nvme.c

2467

PAGE_SIZE - (prp % PAGE_SIZE));

usr.sbin/bhyve/pci_nvme.c

2475

size = MIN(bytes, PAGE_SIZE);

usr.sbin/bhyve/pci_virtio_9p.c

318

sc->vsc_conn->lc_msize = L9P_MAX_IOV * PAGE_SIZE;

usr.sbin/bhyve/vmgenc.c

59

error = bootrom_alloc(ctx, PAGE_SIZE, PROT_READ, 0, &region,

usr.sbin/bhyvectl/amd64/bhyvectl_machdep.c

413

map_size = PAGE_SIZE;

usr.sbin/bhyvectl/amd64/bhyvectl_machdep.c

415

map_size = 2 * PAGE_SIZE;

usr.sbin/dconschat/dconschat.c

161

char buf[PAGE_SIZE];

usr.sbin/dconschat/dconschat.c

165

snprintf(buf, PAGE_SIZE,

usr.sbin/dconschat/dconschat.c

169

bzero(&buf[0], PAGE_SIZE);

usr.sbin/dconschat/dconschat.c

170

dwrite(dc, (void *)buf, PAGE_SIZE, dc->reset);

usr.sbin/diskinfo/diskinfo.c

147

if (posix_memalign((void **)&buf, PAGE_SIZE, MAXTX))