lib/libc/stdlib/nmalloc.c

1003

if (alignment < PAGE_SIZE)

lib/libc/stdlib/nmalloc.c

1004

alignment = PAGE_SIZE;

lib/libc/stdlib/nmalloc.c

1008

if (alignment == PAGE_SIZE && size <= BIGCACHE_LIMIT) {

lib/libc/stdlib/nmalloc.c

1138

if ((size & (PAGE_SIZE * 2 - 1)) == 0)

lib/libc/stdlib/nmalloc.c

1139

size += PAGE_SIZE;

lib/libc/stdlib/nmalloc.c

1159

chunk = _vmem_alloc(size, PAGE_SIZE, flags);

lib/libc/stdlib/nmalloc.c

158

#define MAX_SLAB_PAGEALIGN (2 * PAGE_SIZE) /* max slab for PAGE_SIZE*n */

lib/libc/stdlib/nmalloc.c

195

struct slchunk *z_PageAry[ZALLOC_ZONE_SIZE / PAGE_SIZE];

lib/libc/stdlib/nmalloc.c

338

static const int ZonePageCount = ZALLOC_ZONE_SIZE / PAGE_SIZE;

lib/libc/stdlib/nmalloc.c

982

if (size < PAGE_SIZE) {

lib/libc/sysvipc/sem.c

514

undoid = _shmget(IPC_PRIVATE, PAGE_SIZE, IPC_CREAT | IPC_EXCL | 0600,

lib/libc/sysvipc/sem.c

553

if (size > (unsigned int)(undos->un_pages * PAGE_SIZE)) {

lib/libc/sysvipc/sem.c

569

data->size = undos->un_pages * PAGE_SIZE;

lib/libkvm/kvm_minidump_x86_64.c

117

pa = (idx * sizeof(*base) * NBBY + bit) * PAGE_SIZE;

lib/libkvm/kvm_minidump_x86_64.c

119

off += PAGE_SIZE;

lib/libkvm/kvm_minidump_x86_64.c

188

off = PAGE_SIZE + round_page(hdr->msgbufsize);

lib/libkvm/kvm_minidump_x86_64.c

242

off = PAGE_SIZE + round_page(hdr->msgbufsize);

lib/libkvm/kvm_minidump_x86_64.c

298

offset = va & (PAGE_SIZE - 1);

lib/libkvm/kvm_minidump_x86_64.c

402

return (PAGE_SIZE - offset);

lib/libkvm/kvm_minidump_x86_64.c

411

return (PAGE_SIZE - offset);

lib/libkvm/kvm_proc.c

614

kd->argspc = (char *)_kvm_malloc(kd, PAGE_SIZE);

lib/libkvm/kvm_proc.c

617

kd->arglen = PAGE_SIZE;

lib/libkvm/kvm_proc.c

624

kd->argbuf = (char *)_kvm_malloc(kd, PAGE_SIZE);

lib/libkvm/kvm_proc.c

655

addr = rounddown2((u_long)*argv, PAGE_SIZE);

lib/libkvm/kvm_proc.c

659

if (kvm_uread(kd, pid, addr, kd->argbuf, PAGE_SIZE) !=

lib/libkvm/kvm_proc.c

660

PAGE_SIZE)

lib/libkvm/kvm_proc.c

666

addr = (u_long)*argv & (PAGE_SIZE - 1);

lib/libkvm/kvm_proc.c

670

cc = PAGE_SIZE - addr;

lib/libkvm/kvm_x86_64.c

118

return (PAGE_SIZE - ((size_t)pa & PAGE_MASK));

lib/libkvm/kvm_x86_64.c

129

return (PAGE_SIZE - ((size_t)pa & PAGE_MASK));

lib/libkvm/kvm_x86_64.c

213

PML4 = _kvm_malloc(kd, PAGE_SIZE);

lib/libkvm/kvm_x86_64.c

214

if (kvm_read(kd, pa, PML4, PAGE_SIZE) != PAGE_SIZE) {

lib/libkvm/kvm_x86_64.c

243

offset = va & (PAGE_SIZE - 1);

lib/libkvm/kvm_x86_64.c

256

return (PAGE_SIZE - offset);

lib/libkvm/kvm_x86_64.c

353

return (PAGE_SIZE - offset);

lib/libnvmm/libnvmm_x86.c

102

#define PAGE_MASK (PAGE_SIZE - 1)

lib/libnvmm/libnvmm_x86.c

523

limit *= PAGE_SIZE;

lib/libnvmm/libnvmm_x86.c

602

if ((gva & PAGE_MASK) + size > PAGE_SIZE) {

lib/libnvmm/libnvmm_x86.c

603

remain = ((gva & PAGE_MASK) + size - PAGE_SIZE);

lib/libnvmm/libnvmm_x86.c

659

if ((gva & PAGE_MASK) + size > PAGE_SIZE) {

lib/libnvmm/libnvmm_x86.c

660

remain = ((gva & PAGE_MASK) + size - PAGE_SIZE);

libexec/rtld-elf/map_object.c

127

if ((segs[nsegs]->p_align & (PAGE_SIZE - 1)) != 0) {

libexec/rtld-elf/map_object.c

157

if (phdr->p_offset > PAGE_SIZE ||

libexec/rtld-elf/map_object.c

158

phdr->p_offset + phdr->p_filesz > PAGE_SIZE)

libexec/rtld-elf/map_object.c

242

mprotect(clear_page, PAGE_SIZE, data_prot|PROT_WRITE)) {

libexec/rtld-elf/map_object.c

255

madvise(clear_page, PAGE_SIZE, MADV_CORE);

libexec/rtld-elf/map_object.c

256

mprotect(clear_page, PAGE_SIZE, data_prot);

libexec/rtld-elf/map_object.c

325

munmap(hdr, PAGE_SIZE);

libexec/rtld-elf/map_object.c

331

munmap(hdr, PAGE_SIZE);

libexec/rtld-elf/map_object.c

341

hdr = mmap(NULL, PAGE_SIZE, PROT_READ, MAP_PRIVATE, fd, 0);

libexec/rtld-elf/map_object.c

382

(size_t)PAGE_SIZE) {

libexec/rtld-elf/map_object.c

389

munmap(hdr, PAGE_SIZE);

libexec/rtld-elf/rtld.c

635

space = (space + PAGE_SIZE - 1) & ~((ssize_t)PAGE_SIZE - 1);

sbin/fsck/pass1.c

206

if (kernmaxfilesize > (u_int64_t)0x80000000u * PAGE_SIZE - 1)

sbin/fsck/pass1.c

207

kernmaxfilesize = (u_int64_t)0x80000000u * PAGE_SIZE - 1;

stand/boot/common/load_elf.c

111

ef.firstpage = malloc(PAGE_SIZE);

stand/boot/common/load_elf.c

116

bytes_read = read(ef.fd, ef.firstpage, PAGE_SIZE);

stand/boot/common/load_elf.c

161

pad = PAGE_SIZE - pad;

stand/boot/common/load_elf_obj.c

144

dest = roundup(dest, PAGE_SIZE);

stand/boot/efi/loader/bootinfo.c

379

addr = roundup(addr, PAGE_SIZE);

stand/boot/efi/loader/bootinfo.c

386

addr = roundup(addr, PAGE_SIZE);

stand/boot/efi/loader/bootinfo.c

404

kernend = roundup(addr + size, PAGE_SIZE);

stand/boot/pc32/boot2/boot2.c

387

fs_off = PAGE_SIZE;

stand/boot/pc32/boot2/boot2.c

390

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

stand/boot/pc32/boot2/boot2.c

407

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

stand/boot/pc32/libi386/bootinfo32.c

203

addr = roundup(addr, PAGE_SIZE);

stand/boot/pc32/libi386/bootinfo32.c

210

addr = roundup(addr, PAGE_SIZE);

stand/boot/pc32/libi386/bootinfo32.c

226

kernend = roundup(addr + size, PAGE_SIZE);

stand/boot/pc32/libi386/bootinfo64.c

218

addr = roundup(addr, PAGE_SIZE);

stand/boot/pc32/libi386/bootinfo64.c

225

addr = roundup(addr, PAGE_SIZE);

stand/boot/pc32/libi386/bootinfo64.c

241

kernend = roundup(addr + size, PAGE_SIZE);

stand/boot/pc32/libi386/elf64_freebsd.c

88

bzero(PT4, PAGE_SIZE);

stand/boot/pc32/libi386/elf64_freebsd.c

89

bzero(PT3, PAGE_SIZE);

stand/boot/pc32/libi386/elf64_freebsd.c

90

bzero(PT2, PAGE_SIZE);

sys/bus/firewire/fwdev.c

532

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

sys/bus/firewire/fwdma.c

153

if (esize > PAGE_SIZE) {

sys/bus/firewire/fwdma.c

155

esize = ssize = roundup2(esize, PAGE_SIZE);

sys/bus/firewire/fwdma.c

159

ssize = rounddown(PAGE_SIZE, esize);

sys/bus/firewire/fwohci.c

149

#define DMA_PROG_ALLOC (8 * PAGE_SIZE)

sys/bus/firewire/fwohci.c

622

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

sys/bus/firewire/fwohci.c

623

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

sys/bus/firewire/fwohci.c

624

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

sys/bus/firewire/fwohci.c

625

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

sys/bus/isa/x86_64/isa_dma.c

376

for (; va < (caddr_t) endva ; va += PAGE_SIZE) {

sys/bus/isa/x86_64/isa_dma.c

384

if (priorpage + PAGE_SIZE != phys)

sys/bus/u4b/usb_busdma.h

38

#define USB_PAGE_SIZE PAGE_SIZE /* use system PAGE_SIZE */

sys/bus/u4b/uvc/uvc_buf.c

107

uint64_t max_offset = (uint64_t)(bq->buf_size * bq->buf_count) - PAGE_SIZE;

sys/cpu/x86_64/include/param.h

101

#define NPML4EPG (PAGE_SIZE/8LU) /* PAGE_SIZE/sizeof(pml4_entry_t) */

sys/cpu/x86_64/include/param.h

119

#define BLKDEV_IOSIZE PAGE_SIZE /* default block device I/O size */

sys/cpu/x86_64/include/param.h

123

#define MAXDUMPPGS (MAXPHYS/PAGE_SIZE)

sys/cpu/x86_64/include/param.h

192

#define pgtok(x) ((x) * (PAGE_SIZE / 1024))

sys/cpu/x86_64/include/param.h

79

#define PAGE_MASK (PAGE_SIZE-1)

sys/cpu/x86_64/include/param.h

80

#define NPTEPG (PAGE_SIZE/8LU) /* PAGE_SIZE/sizeof(pt_entry_t) */

sys/cpu/x86_64/include/param.h

87

#define NPDEPG (PAGE_SIZE/8LU) /* PAGE_SIZE/sizeof(pd_entry_t) */

sys/cpu/x86_64/include/param.h

94

#define NPDPEPG (PAGE_SIZE/8LU) /* PAGE_SIZE/sizeof(pdp_entry_t) */

sys/cpu/x86_64/include/signal.h

109

#define SZSIGCODE_EXTRA_BYTES (1*PAGE_SIZE)

sys/dev/agp/agp.c

147

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

sys/dev/agp/agp.c

535

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

sys/dev/agp/agp.c

555

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

sys/dev/agp/agp.c

570

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

sys/dev/agp/agp.c

627

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

sys/dev/agp/intel-gtt.c

1168

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

sys/dev/agp/intel-gtt.c

1426

npages = sg_dma_len(sg) / PAGE_SIZE;

sys/dev/agp/intel-gtt.c

1428

page = sg_dma_address(sg) + subpage * PAGE_SIZE;

sys/dev/agp/intel-gtt.c

1463

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

sys/dev/agp/intel-gtt.c

1517

temp + PAGE_SIZE - 1);

sys/dev/agp/intel-gtt.c

1574

temp + PAGE_SIZE - 1);

sys/dev/disk/advansys/adwcam.c

1125

PAGE_SIZE, /*nsegments*/1,

sys/dev/disk/advansys/adwcam.c

172

PAGE_SIZE, adwmapmem, &sg_map->sg_physaddr, /*flags*/0);

sys/dev/disk/advansys/adwcam.c

174

bzero(sg_map->sg_vaddr, PAGE_SIZE);

sys/dev/disk/advansys/adwcam.c

201

newcount = (PAGE_SIZE / (ADW_SG_BLOCKCNT * sizeof(*blocks)));

sys/dev/disk/ahci/ahci.h

388

#if AHCI_MAXPHYS / PAGE_SIZE + 1 > AHCI_MAX_PRDT

sys/dev/disk/ahci/ahci_attach.c

375

PAGE_SIZE, /* boundary */

sys/dev/disk/buslogic/bt.c

706

/* maxsize */ PAGE_SIZE,

sys/dev/disk/buslogic/bt.c

827

PAGE_SIZE, btmapsgs, bt, /*flags*/0);

sys/dev/disk/buslogic/bt.c

832

newcount = (PAGE_SIZE / (BT_NSEG * sizeof(bt_sg_t)));

sys/dev/disk/dm/crypt/dm_target_crypt.c

172

nmax = (physmem * 2 / 1000 * PAGE_SIZE) /

sys/dev/disk/isp/isp_freebsd.h

660

#define ISP_NSEGS ((MAXPHYS / PAGE_SIZE) + 1)

sys/dev/disk/isp/isp_pci.c

1583

ns = (len / PAGE_SIZE) + 1;

sys/dev/disk/mpt/mpt.c

2530

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

sys/dev/disk/mpt/mpt.c

2538

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

sys/dev/disk/mpt/mpt.c

2699

mpt->max_cam_seg_cnt = min(mpt->max_seg_cnt, (MAXPHYS / PAGE_SIZE) + 1);

sys/dev/disk/mpt/mpt.c

2898

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

sys/dev/disk/mpt/mpt_cam.c

3577

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

sys/dev/disk/mpt/mpt_pci.c

724

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

sys/dev/disk/mpt/mpt_pci.c

726

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

sys/dev/disk/mpt/mpt_pci.c

736

(u_long) (2 * PAGE_SIZE));

sys/dev/disk/mpt/mpt_pci.c

745

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

sys/dev/disk/nata/ata-dma.c

103

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

sys/dev/disk/nata/ata-dma.c

130

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

sys/dev/disk/nata/ata-dma.c

55

#define MAXTABSZ PAGE_SIZE

sys/dev/disk/nata/ata-dma.c

56

#define MAXWSPCSZ PAGE_SIZE*2

sys/dev/disk/nata/chipsets/ata-ahci.c

558

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

sys/dev/disk/nata/chipsets/ata-marvell.c

565

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

sys/dev/disk/ncr/ncr.c

158

#define MAX_SIZE ((MAX_SCATTER-1) * (long) PAGE_SIZE)

sys/dev/disk/ncr/ncr.c

3587

} else if (sizeof (struct script) > PAGE_SIZE) {

sys/dev/disk/ncr/ncr.c

3590

0, 0xffffffff, PAGE_SIZE);

sys/dev/disk/ncr/ncr.c

3597

if (sizeof (struct scripth) > PAGE_SIZE) {

sys/dev/disk/ncr/ncr.c

3600

0, 0xffffffff, PAGE_SIZE);

sys/dev/disk/ncr/ncr.c

6648

if (vaddr & PAGE_MASK) free -= datalen / PAGE_SIZE;

sys/dev/disk/ncr/ncr.c

6677

pnext = (paddr & (~PAGE_MASK)) + PAGE_SIZE;

sys/dev/disk/nvme/nvme.c

384

(MAXPHYS / PAGE_SIZE) * req->cmd_id;

sys/dev/disk/nvme/nvme.c

386

(MAXPHYS / PAGE_SIZE) * req->cmd_id *

sys/dev/disk/nvme/nvme.c

394

count += (((intptr_t)kva + PAGE_SIZE) &

sys/dev/disk/nvme/nvme.c

397

} else if (idx == 1 && count + PAGE_SIZE >= bytes) {

sys/dev/disk/nvme/nvme.c

400

count += PAGE_SIZE;

sys/dev/disk/nvme/nvme.c

406

count += PAGE_SIZE;

sys/dev/disk/nvme/nvme_attach.c

337

sc->prp_bytes = sizeof(uint64_t) * (MAXPHYS / PAGE_SIZE) * sc->maxqe;

sys/dev/disk/nvme/nvme_attach.c

346

PAGE_SIZE, /* alignment */

sys/dev/disk/nvme/nvme_attach.c

358

PAGE_SIZE, /* alignment */

sys/dev/disk/nvme/nvme_attach.c

370

PAGE_SIZE, /* alignment */

sys/dev/disk/nvme/nvme_attach.c

382

PAGE_SIZE, /* alignment */

sys/dev/disk/sbp/sbp.c

139

#define SBP_SEG_MAX rounddown(0xffff, PAGE_SIZE)

sys/dev/disk/sbp/sbp.c

140

#define SBP_IND_MAX howmany(SBP_MAXPHYS, PAGE_SIZE)

sys/dev/disk/sbp/sbp.c

73

#define SBP_DMA_SIZE PAGE_SIZE

sys/dev/disk/sdhci/sdhci.h

332

#define SDHCI_ADMA2_DESCBUF_SIZE PAGE_SIZE

sys/dev/disk/sdhci/sdhci.h

351

_Static_assert(SDHCI_ADMA2_DESC_COUNT >= MAXPHYS / PAGE_SIZE + 1,

sys/dev/disk/sili/sili.h

644

#if SILI_MAXPHYS / PAGE_SIZE + 1 > (SILI_MAX_SGET * 3 / 4)

sys/dev/disk/sym/sym_hipd.c

302

#if SYM_CONF_MAX_QUEUE > PAGE_SIZE/8

sys/dev/disk/sym/sym_hipd.c

304

#define SYM_CONF_MAX_QUEUE PAGE_SIZE/8

sys/dev/disk/vn/vn.c

560

vn->sc_size = vio->vn_size * PAGE_SIZE / vn->sc_secsize;

sys/dev/disk/vn/vn.c

630

vn->sc_secsize = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_amdkfd.c

283

bp.byte_align = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_atombios.c

1967

return snprintf(buf, PAGE_SIZE, "%s\n", ctx->vbios_version);

sys/dev/drm/amd/amdgpu/amdgpu_benchmark.c

85

bp.byte_align = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_cgs.c

225

gpu_addr += ALIGN(le32_to_cpu(header->header.ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_cgs.c

457

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_cs.c

59

if (size != PAGE_SIZE || (data->offset + 8) > size) {

sys/dev/drm/amd/amdgpu/amdgpu_device.c

435

PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM,

sys/dev/drm/amd/amdgpu/amdgpu_device.c

600

PAGE_SIZE, AMDGPU_GEM_DOMAIN_GTT,

sys/dev/drm/amd/amdgpu/amdgpu_fb.c

152

aligned_size = ALIGN(size, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_gart.c

120

bp.byte_align = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_gart.c

354

if (PAGE_SIZE < AMDGPU_GPU_PAGE_SIZE) {

sys/dev/drm/amd/amdgpu/amdgpu_gart.c

362

adev->gart.num_cpu_pages = adev->gmc.gart_size / PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_gart.c

76

PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

sys/dev/drm/amd/amdgpu/amdgpu_gart.c

97

PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

sys/dev/drm/amd/amdgpu/amdgpu_gart.h

40

#define AMDGPU_GPU_PAGES_IN_CPU_PAGE (PAGE_SIZE / AMDGPU_GPU_PAGE_SIZE)

sys/dev/drm/amd/amdgpu/amdgpu_gem.c

58

if (alignment < PAGE_SIZE) {

sys/dev/drm/amd/amdgpu/amdgpu_gem.c

59

alignment = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_gem.c

762

args->size = ALIGN(args->size, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

289

r = amdgpu_bo_create_kernel(adev, hpd_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

323

r = amdgpu_bo_create_kernel(adev, mqd_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_gfx.c

341

r = amdgpu_bo_create_kernel(adev, mqd_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_gmc.c

99

if (ttm->dma_address[0] + PAGE_SIZE >= adev->gmc.agp_size)

sys/dev/drm/amd/amdgpu/amdgpu_gtt_mgr.c

250

return (result > 0 ? result : 0) * PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_ih.c

80

r = amdgpu_bo_create_kernel(adev, ih->ring_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_kms.c

614

vram_gtt.gtt_size *= PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_kms.c

640

mem.gtt.total_heap_size *= PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_kms.c

733

dev_info.virtual_address_alignment = max((int)PAGE_SIZE, AMDGPU_GPU_PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_object.c

434

page_align = roundup(bp->byte_align, PAGE_SIZE) >> PAGE_SHIFT;

sys/dev/drm/amd/amdgpu/amdgpu_object.c

439

size = ALIGN(size, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1058

return snprintf(buf, PAGE_SIZE, "%d\n", temp);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1074

return snprintf(buf, PAGE_SIZE, "%d\n", temp);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1230

return snprintf(buf, PAGE_SIZE, "%d\n", min_rpm);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1250

return snprintf(buf, PAGE_SIZE, "%d\n", max_rpm);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

132

return snprintf(buf, PAGE_SIZE, "%s\n",

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1380

return snprintf(buf, PAGE_SIZE, "%d\n", vddgfx);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1387

return snprintf(buf, PAGE_SIZE, "vddgfx\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1419

return snprintf(buf, PAGE_SIZE, "%d\n", vddnb);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1426

return snprintf(buf, PAGE_SIZE, "vddnb\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1458

return snprintf(buf, PAGE_SIZE, "%u\n", uw);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1477

return snprintf(buf, PAGE_SIZE, "%u\n", limit * 1000000);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1479

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1492

return snprintf(buf, PAGE_SIZE, "%u\n", limit * 1000000);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

1494

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

243

return snprintf(buf, PAGE_SIZE, "off\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

250

return snprintf(buf, PAGE_SIZE, "%s\n",

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

338

buf_len = snprintf(buf, PAGE_SIZE, "states: %d\n", data.nums);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

340

buf_len += snprintf(buf + buf_len, PAGE_SIZE, "%d %s\n", i,

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

373

return snprintf(buf, PAGE_SIZE, "%d\n", i);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

386

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

455

if (size >= PAGE_SIZE)

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

456

size = PAGE_SIZE - 1;

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

628

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

660

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

732

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

768

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

805

return snprintf(buf, PAGE_SIZE, "%d\n", value);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

849

return snprintf(buf, PAGE_SIZE, "%d\n", value);

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

912

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/amdgpu/amdgpu_pm.c

995

return snprintf(buf, PAGE_SIZE, "%d\n", value);

sys/dev/drm/amd/amdgpu/amdgpu_prime.c

172

bp.byte_align = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_psp.c

230

PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM,

sys/dev/drm/amd/amdgpu/amdgpu_psp.c

358

ret = amdgpu_bo_create_kernel(adev, PSP_FENCE_BUFFER_SIZE, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_psp.c

366

ret = amdgpu_bo_create_kernel(adev, PSP_CMD_BUFFER_SIZE, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_ring.c

305

r = amdgpu_bo_create_kernel(adev, ring->ring_size + ring->funcs->extra_dw, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_test.c

65

bp.byte_align = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1411

size = (unsigned long)gtt->ttm.ttm.num_pages * PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1698

bp.byte_align = PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1723

offset = ALIGN(offset, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1836

r = amdgpu_bo_create_kernel(adev, adev->gmc.stolen_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1876

PAGE_SIZE, AMDGPU_GEM_DOMAIN_GDS,

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1889

PAGE_SIZE, AMDGPU_GEM_DOMAIN_GWS,

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

1902

PAGE_SIZE, AMDGPU_GEM_DOMAIN_OA,

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

2378

loff_t p = *pos / PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

2380

size_t cur_size = min_t(size_t, size, PAGE_SIZE - off);

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

2438

size_t bytes = PAGE_SIZE - off;

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

2495

size_t bytes = PAGE_SIZE - off;

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

421

src_page_offset = src_node_start & (PAGE_SIZE - 1);

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

427

dst_page_offset = dst_node_start & (PAGE_SIZE - 1);

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

490

src_page_offset = src_node_start & (PAGE_SIZE - 1);

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

499

dst_page_offset = dst_node_start & (PAGE_SIZE - 1);

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

853

unsigned long end = gtt->userptr + ttm->num_pages * PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_ttm.c

867

uint64_t userptr = gtt->userptr + pinned * PAGE_SIZE;

sys/dev/drm/amd/amdgpu/amdgpu_ucode.c

414

PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_ucode.c

426

amdgpu_bo_create_kernel(adev, adev->firmware.fw_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_ucode.c

482

fw_offset += ALIGN(le32_to_cpu(cp_hdr->jt_size) << 2, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_ucode.c

484

fw_offset += ALIGN(ucode->ucode_size, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_uvd.c

1127

r = amdgpu_bo_create_reserved(adev, 1024, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_uvd.c

1159

r = amdgpu_bo_create_reserved(adev, 1024, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_uvd.c

258

r = amdgpu_bo_create_kernel(adev, bo_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_vce.c

181

r = amdgpu_bo_create_kernel(adev, size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_vcn.c

127

r = amdgpu_bo_create_kernel(adev, bo_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_vcn.c

525

r = amdgpu_bo_create_reserved(adev, 1024, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_vcn.c

559

r = amdgpu_bo_create_reserved(adev, 1024, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_virt.c

338

r = amdgpu_bo_create_kernel(adev, PAGE_SIZE, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_virt.c

348

memset((void *)adev->virt.mm_table.cpu_addr, 0, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/amdgpu_virt.c

49

r = amdgpu_bo_create_kernel(adev, AMDGPU_CSA_SIZE, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/amdgpu_vm.c

2020

(pages_addr[idx - 1] + PAGE_SIZE))

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

2783

r = amdgpu_bo_create_reserved(adev, mec_hpd_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

3049

r = amdgpu_bo_create_reserved(adev, sizeof(struct cik_mqd), PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

3311

r = amdgpu_bo_create_reserved(adev, dws * 4, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

3334

r = amdgpu_bo_create_reserved(adev, dws * 4, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v7_0.c

3355

PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM,

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1181

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1188

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1195

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1202

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1209

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1214

ALIGN(le32_to_cpu(cp_hdr->jt_size) << 2, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1221

ALIGN(le32_to_cpu(64 * PAGE_SIZE), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1230

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1387

r = amdgpu_bo_create_reserved(adev, dws * 4, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1409

PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM,

sys/dev/drm/amd/amdgpu/gfx_v8_0.c

1445

r = amdgpu_bo_create_reserved(adev, mec_hpd_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1157

r = amdgpu_bo_create_reserved(adev, dws * 4, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1180

PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM,

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1266

r = amdgpu_bo_create_reserved(adev, mec_hpd_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1290

PAGE_SIZE, AMDGPU_GEM_DOMAIN_GTT,

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

1497

PAGE_SIZE, AMDGPU_GEM_DOMAIN_VRAM,

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

753

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

760

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

767

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

774

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

784

ALIGN(adev->gfx.rlc.save_restore_list_cntl_size_bytes, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

790

ALIGN(adev->gfx.rlc.save_restore_list_gpm_size_bytes, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

796

ALIGN(adev->gfx.rlc.save_restore_list_srm_size_bytes, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

805

ALIGN(le32_to_cpu(header->ucode_size_bytes) - le32_to_cpu(cp_hdr->jt_size) * 4, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

811

ALIGN(le32_to_cpu(cp_hdr->jt_size) * 4, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

820

ALIGN(le32_to_cpu(header->ucode_size_bytes) - le32_to_cpu(cp_hdr->jt_size) * 4, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/gfx_v9_0.c

825

ALIGN(le32_to_cpu(cp_hdr->jt_size) * 4, PAGE_SIZE);

sys/dev/drm/amd/amdgpu/psp_v10_0.c

192

ret = amdgpu_bo_create_kernel(adev, ring->ring_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/psp_v11_0.c

260

ret = amdgpu_bo_create_kernel(adev, ring->ring_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/psp_v3_1.c

310

ret = amdgpu_bo_create_kernel(adev, ring->ring_size, PAGE_SIZE,

sys/dev/drm/amd/amdgpu/sdma_v2_4.c

169

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/sdma_v3_0.c

326

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/sdma_v4_0.c

322

ALIGN(le32_to_cpu(header->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/uvd_v7_0.c

439

ALIGN(le32_to_cpu(hdr->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/uvd_v7_0.c

445

ALIGN(le32_to_cpu(hdr->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/vce_v4_0.c

450

ALIGN(le32_to_cpu(hdr->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/amdgpu/vcn_v1_0.c

115

ALIGN(le32_to_cpu(hdr->ucode_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/display/amdgpu_dm/amdgpu_dm.c

369

int r = amdgpu_bo_create_kernel(adev, max_size * 4, PAGE_SIZE,

sys/dev/drm/amd/display/amdgpu_dm/amdgpu_dm.c

578

ALIGN(le32_to_cpu(hdr->header.ucode_size_bytes) - le32_to_cpu(hdr->intv_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/display/amdgpu_dm/amdgpu_dm.c

583

ALIGN(le32_to_cpu(hdr->intv_size_bytes), PAGE_SIZE);

sys/dev/drm/amd/powerplay/amd_powerplay.c

150

PAGE_SIZE, AMDGPU_GEM_DOMAIN_GTT,

sys/dev/drm/amd/powerplay/amd_powerplay.c

882

return snprintf(buf, PAGE_SIZE, "\n");

sys/dev/drm/amd/powerplay/smumgr/smu10_smumgr.c

237

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/smu10_smumgr.c

253

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/smu7_smumgr.c

556

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/smu7_smumgr.c

571

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/smu8_smumgr.c

766

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/smu8_smumgr.c

776

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega10_smumgr.c

193

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega10_smumgr.c

208

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega10_smumgr.c

224

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega10_smumgr.c

241

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega10_smumgr.c

256

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega12_smumgr.c

219

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega12_smumgr.c

233

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega12_smumgr.c

249

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega12_smumgr.c

264

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega12_smumgr.c

279

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega20_smumgr.c

395

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega20_smumgr.c

409

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega20_smumgr.c

423

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega20_smumgr.c

437

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega20_smumgr.c

451

PAGE_SIZE,

sys/dev/drm/amd/powerplay/smumgr/vega20_smumgr.c

465

PAGE_SIZE,

sys/dev/drm/drm_agpsupport.c

227

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

sys/dev/drm/drm_agpsupport.c

350

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

sys/dev/drm/drm_agpsupport.c

375

DRM_DEBUG("agp_bind, page_size=%x\n", (int)PAGE_SIZE);

sys/dev/drm/drm_agpsupport.c

381

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

sys/dev/drm/drm_bufs.c

1011

byte_count += PAGE_SIZE << page_order;

sys/dev/drm/drm_bufs.c

1042

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

sys/dev/drm/drm_bufs.c

106

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

sys/dev/drm/drm_bufs.c

1092

total = PAGE_SIZE << page_order;

sys/dev/drm/drm_bufs.c

1172

byte_count += PAGE_SIZE << page_order;

sys/dev/drm/drm_bufs.c

295

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

sys/dev/drm/drm_bufs.c

717

total = PAGE_SIZE << page_order;

sys/dev/drm/drm_bufs.c

737

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

sys/dev/drm/drm_bufs.c

810

byte_count += PAGE_SIZE << page_order;

sys/dev/drm/drm_bufs.c

894

total = PAGE_SIZE << page_order;

sys/dev/drm/drm_bufs.c

958

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

sys/dev/drm/drm_bufs.c

974

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

sys/dev/drm/drm_bufs.c

976

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

sys/dev/drm/drm_cache.c

103

(unsigned long)page_virtual + PAGE_SIZE);

sys/dev/drm/drm_cache.c

55

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

sys/dev/drm/drm_fb_helper.c

1079

end = start + PAGE_SIZE - 1;

sys/dev/drm/drm_gem.c

219

BUG_ON((size & (PAGE_SIZE - 1)) != 0);

sys/dev/drm/drm_gem.c

586

size / PAGE_SIZE);

sys/dev/drm/drm_hashtab.c

201

if ((PAGE_SIZE / sizeof(*ht->table)) >> ht->order)

sys/dev/drm/drm_hashtab.c

47

if (size <= PAGE_SIZE / sizeof(*ht->table))

sys/dev/drm/drm_pci.c

135

sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {

sys/dev/drm/drm_pci.c

169

sz > 0; addr += PAGE_SIZE, sz -= PAGE_SIZE) {

sys/dev/drm/drm_prime.c

969

addr += PAGE_SIZE;

sys/dev/drm/drm_prime.c

970

len -= PAGE_SIZE;

sys/dev/drm/drm_sysctl.c

245

* (int)PAGE_SIZE / 1024);

sys/dev/drm/drm_vm.c

181

page_count = (end - start) / PAGE_SIZE;

sys/dev/drm/drm_vm.c

187

vm_page_initfake(&fp[i], start + PAGE_SIZE * i, memattr);

sys/dev/drm/i915/i915_cmd_parser.c

1104

int len = min_t(int, batch_len, PAGE_SIZE - offset);

sys/dev/drm/i915/i915_drv.h

2329

(((__iter).curr += PAGE_SIZE) >= (__iter).max) ? \

sys/dev/drm/i915/i915_drv.h

2339

GEM_BUG_ON(!IS_ALIGNED(sg->length, PAGE_SIZE));

sys/dev/drm/i915/i915_drv.h

2354

size = rounddown(size, PAGE_SIZE);

sys/dev/drm/i915/i915_drv.h

2356

if (size < PAGE_SIZE)

sys/dev/drm/i915/i915_drv.h

2357

size = PAGE_SIZE;

sys/dev/drm/i915/i915_gem.c

1156

unsigned int length = min_t(u64, remain, PAGE_SIZE - offset);

sys/dev/drm/i915/i915_gem.c

1188

vaddr = io_mapping_map_wc(mapping, base, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

1228

ret = insert_mappable_node(ggtt, &node, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

1253

unsigned page_length = PAGE_SIZE - page_offset;

sys/dev/drm/i915/i915_gem.c

1369

vaddr = io_mapping_map_wc(mapping, base, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

1431

ret = insert_mappable_node(ggtt, &node, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

1457

unsigned int page_length = PAGE_SIZE - page_offset;

sys/dev/drm/i915/i915_gem.c

1610

unsigned int length = min_t(u64, remain, PAGE_SIZE - offset);

sys/dev/drm/i915/i915_gem.c

2863

const unsigned long page_count = obj->base.size / PAGE_SIZE;

sys/dev/drm/i915/i915_gem.c

2977

sg_set_page(sg, page, PAGE_SIZE, 0);

sys/dev/drm/i915/i915_gem.c

2979

sg->length += PAGE_SIZE;

sys/dev/drm/i915/i915_gem.c

3004

if (max_segment > PAGE_SIZE) {

sys/dev/drm/i915/i915_gem.c

3009

max_segment = PAGE_SIZE;

sys/dev/drm/i915/i915_gem.c

306

for (i = 0; i < obj->base.size / PAGE_SIZE; i++) {

sys/dev/drm/i915/i915_gem.c

321

memcpy(vaddr, src, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

322

drm_clflush_virt_range(vaddr, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

326

vaddr += PAGE_SIZE;

sys/dev/drm/i915/i915_gem.c

3305

len = PAGE_SIZE - pg;

sys/dev/drm/i915/i915_gem.c

404

for (i = 0; i < obj->base.size / PAGE_SIZE; i++) {

sys/dev/drm/i915/i915_gem.c

413

drm_clflush_virt_range(vaddr, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

414

memcpy(dst, vaddr, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

421

vaddr += PAGE_SIZE;

sys/dev/drm/i915/i915_gem.c

5999

IS_GEN2(dev_priv) ? SZ_256K : PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

6475

obj = i915_gem_object_create(dev_priv, round_up(size, PAGE_SIZE));

sys/dev/drm/i915/i915_gem.c

6484

unsigned int len = min_t(typeof(size), size, PAGE_SIZE);

sys/dev/drm/i915/i915_gem.c

746

size = roundup(size, PAGE_SIZE);

sys/dev/drm/i915/i915_gem_context.c

381

ctx->ring_size = 4 * PAGE_SIZE;

sys/dev/drm/i915/i915_gem_context.c

469

ctx->ring_size = 512 * PAGE_SIZE; /* Max ring buffer size */

sys/dev/drm/i915/i915_gem_context.c

508

ctx->ring_size = PAGE_SIZE;

sys/dev/drm/i915/i915_gem_execbuffer.c

1050

PAGE_SIZE, 0, I915_COLOR_UNEVICTABLE,

sys/dev/drm/i915/i915_gem_execbuffer.c

1153

obj = i915_gem_batch_pool_get(&eb->engine->batch_pool, PAGE_SIZE);

sys/dev/drm/i915/i915_gem_execbuffer.c

1190

batch->node.start, PAGE_SIZE,

sys/dev/drm/i915/i915_gem_execbuffer.c

1232

if (cache->rq_size > PAGE_SIZE/sizeof(u32) - (len + 1))

sys/dev/drm/i915/i915_gem_execbuffer.c

1577

for (; addr < end; addr += PAGE_SIZE) {

sys/dev/drm/i915/i915_gem_fence_reg.c

729

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

sys/dev/drm/i915/i915_gem_gtt.c

2951

PAGE_SIZE, 0, I915_COLOR_UNEVICTABLE,

sys/dev/drm/i915/i915_gem_gtt.c

2973

ggtt->vm.clear_range(&ggtt->vm, ggtt->vm.total - PAGE_SIZE, PAGE_SIZE);

sys/dev/drm/i915/i915_gem_gtt.c

573

p->page, 0, PAGE_SIZE,

sys/dev/drm/i915/i915_gem_gtt.c

594

dma_unmap_page(vm->dma, p->daddr, PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

sys/dev/drm/i915/i915_gem_gtt.c

611

memset64(vaddr, val, PAGE_SIZE / sizeof(val));

sys/dev/drm/i915/i915_gem_gtt.h

85

#define I915_PTES(pte_len) ((unsigned int)(PAGE_SIZE / (pte_len)))

sys/dev/drm/i915/i915_gem_gtt.h

92

#define GEN6_PD_SIZE (I915_PDES * PAGE_SIZE)

sys/dev/drm/i915/i915_gem_gtt.h

93

#define GEN6_PD_ALIGN (PAGE_SIZE * 16)

sys/dev/drm/i915/i915_gem_internal.c

110

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

sys/dev/drm/i915/i915_gem_internal.c

111

sg_page_sizes |= PAGE_SIZE << order;

sys/dev/drm/i915/i915_gem_internal.c

192

GEM_BUG_ON(!IS_ALIGNED(size, PAGE_SIZE));

sys/dev/drm/i915/i915_gem_internal.c

66

PAGE_SIZE) >> PAGE_SHIFT;

sys/dev/drm/i915/i915_gem_internal.c

84

npages = obj->base.size / PAGE_SIZE;

sys/dev/drm/i915/i915_gem_render_state.c

190

if (so.rodata->batch_items * 4 > PAGE_SIZE)

sys/dev/drm/i915/i915_gem_render_state.c

193

so.obj = i915_gem_object_create_internal(engine->i915, PAGE_SIZE);

sys/dev/drm/i915/i915_gem_render_state.c

73

if ((i) >= PAGE_SIZE / sizeof(u32)) \

sys/dev/drm/i915/i915_gem_userptr.c

451

if (max_segment > PAGE_SIZE) {

sys/dev/drm/i915/i915_gem_userptr.c

452

max_segment = PAGE_SIZE;

sys/dev/drm/i915/i915_gem_userptr.c

531

obj->userptr.ptr + pinned * PAGE_SIZE,

sys/dev/drm/i915/i915_gpu_error.c

1010

ggtt->vm.clear_range(&ggtt->vm, slot, PAGE_SIZE);

sys/dev/drm/i915/i915_gpu_error.c

1427

max = min_t(long, max, PAGE_SIZE / sizeof(*bo));

sys/dev/drm/i915/i915_gpu_error.c

256

if (c->tmp && i915_memcpy_from_wc(c->tmp, src, PAGE_SIZE))

sys/dev/drm/i915/i915_gpu_error.c

258

zstream->avail_in = PAGE_SIZE;

sys/dev/drm/i915/i915_gpu_error.c

266

zstream->avail_out = PAGE_SIZE;

sys/dev/drm/i915/i915_gpu_error.c

292

zstream->avail_out = PAGE_SIZE;

sys/dev/drm/i915/i915_gpu_error.c

347

if (!i915_memcpy_from_wc(ptr, src, PAGE_SIZE))

sys/dev/drm/i915/i915_gpu_error.c

348

memcpy(ptr, src, PAGE_SIZE);

sys/dev/drm/i915/i915_gpu_error.c

585

len = PAGE_SIZE;

sys/dev/drm/i915/i915_gpu_error.c

860

ebuf->size = count + 1 > PAGE_SIZE ? count + 1 : PAGE_SIZE;

sys/dev/drm/i915/i915_gpu_error.c

865

ebuf->size = PAGE_SIZE;

sys/dev/drm/i915/i915_perf.c

1753

regs += LRC_STATE_PN * PAGE_SIZE / sizeof(*regs);

sys/dev/drm/i915/i915_reg.h

2328

#define RING_CTL_SIZE(size) ((size) - PAGE_SIZE) /* in bytes -> pages */

sys/dev/drm/i915/i915_sysfs.c

101

return snprintf(buf, PAGE_SIZE, "%u\n", rc6_residency);

sys/dev/drm/i915/i915_sysfs.c

280

return snprintf(buf, PAGE_SIZE, "%d\n", ret);

sys/dev/drm/i915/i915_sysfs.c

288

return snprintf(buf, PAGE_SIZE, "%d\n",

sys/dev/drm/i915/i915_sysfs.c

297

return snprintf(buf, PAGE_SIZE, "%d\n",

sys/dev/drm/i915/i915_sysfs.c

338

return snprintf(buf, PAGE_SIZE, "%d\n",

sys/dev/drm/i915/i915_sysfs.c

347

return snprintf(buf, PAGE_SIZE, "%d\n",

sys/dev/drm/i915/i915_sysfs.c

405

return snprintf(buf, PAGE_SIZE, "%d\n",

sys/dev/drm/i915/i915_sysfs.c

484

return snprintf(buf, PAGE_SIZE, "%d\n", val);

sys/dev/drm/i915/i915_sysfs.c

69

return snprintf(buf, PAGE_SIZE, "%x\n", mask);

sys/dev/drm/i915/i915_sysfs.c

77

return snprintf(buf, PAGE_SIZE, "%u\n", rc6_residency);

sys/dev/drm/i915/i915_sysfs.c

85

return snprintf(buf, PAGE_SIZE, "%u\n", rc6p_residency);

sys/dev/drm/i915/i915_sysfs.c

93

return snprintf(buf, PAGE_SIZE, "%u\n", rc6pp_residency);

sys/dev/drm/i915/intel_display.c

2710

u32 base_aligned = round_down(plane_config->base, PAGE_SIZE);

sys/dev/drm/i915/intel_display.c

2712

PAGE_SIZE);

sys/dev/drm/i915/intel_engine_cs.c

1577

linux_hexdump(m, engine->status_page.page_addr, PAGE_SIZE);

sys/dev/drm/i915/intel_engine_cs.c

194

BUILD_BUG_ON(I915_GTT_PAGE_SIZE != PAGE_SIZE);

sys/dev/drm/i915/intel_engine_cs.c

216

PAGE_SIZE);

sys/dev/drm/i915/intel_engine_cs.c

220

PAGE_SIZE);

sys/dev/drm/i915/intel_engine_cs.c

38

#define HSW_CXT_TOTAL_SIZE (17 * PAGE_SIZE)

sys/dev/drm/i915/intel_engine_cs.c

40

#define DEFAULT_LR_CONTEXT_RENDER_SIZE (22 * PAGE_SIZE)

sys/dev/drm/i915/intel_engine_cs.c

41

#define GEN8_LR_CONTEXT_RENDER_SIZE (20 * PAGE_SIZE)

sys/dev/drm/i915/intel_engine_cs.c

42

#define GEN9_LR_CONTEXT_RENDER_SIZE (22 * PAGE_SIZE)

sys/dev/drm/i915/intel_engine_cs.c

43

#define GEN10_LR_CONTEXT_RENDER_SIZE (18 * PAGE_SIZE)

sys/dev/drm/i915/intel_engine_cs.c

44

#define GEN11_LR_CONTEXT_RENDER_SIZE (14 * PAGE_SIZE)

sys/dev/drm/i915/intel_engine_cs.c

46

#define GEN8_LR_CONTEXT_OTHER_SIZE ( 2 * PAGE_SIZE)

sys/dev/drm/i915/intel_engine_cs.c

513

obj = i915_gem_object_create_internal(engine->i915, PAGE_SIZE);

sys/dev/drm/i915/intel_engine_cs.c

556

engine->status_page.page_addr = memset(vaddr, 0, PAGE_SIZE);

sys/dev/drm/i915/intel_guc.c

171

vma = intel_guc_allocate_vma(guc, PAGE_SIZE);

sys/dev/drm/i915/intel_guc_ads.c

85

u8 reg_state_buffer[GUC_S3_SAVE_SPACE_PAGES * PAGE_SIZE];

sys/dev/drm/i915/intel_guc_ads.c

89

const u32 skipped_offset = LRC_HEADER_PAGES * PAGE_SIZE;

sys/dev/drm/i915/intel_guc_ads.c

90

const u32 skipped_size = LRC_PPHWSP_SZ * PAGE_SIZE + LR_HW_CONTEXT_SIZE;

sys/dev/drm/i915/intel_guc_ct.c

181

vma = intel_guc_allocate_vma(guc, PAGE_SIZE);

sys/dev/drm/i915/intel_guc_ct.c

200

ctch->ctbs[i].desc = blob + PAGE_SIZE/4 * i;

sys/dev/drm/i915/intel_guc_ct.c

201

ctch->ctbs[i].cmds = blob + PAGE_SIZE/4 * i + PAGE_SIZE/2;

sys/dev/drm/i915/intel_guc_ct.c

246

base + PAGE_SIZE/4 * i + PAGE_SIZE/2,

sys/dev/drm/i915/intel_guc_ct.c

247

PAGE_SIZE/4,

sys/dev/drm/i915/intel_guc_ct.c

255

base + PAGE_SIZE/4 * CTB_RECV,

sys/dev/drm/i915/intel_guc_ct.c

261

base + PAGE_SIZE/4 * CTB_SEND,

sys/dev/drm/i915/intel_guc_fwif.h

239

#define GUC_DB_SIZE (PAGE_SIZE)

sys/dev/drm/i915/intel_guc_fwif.h

240

#define GUC_WQ_SIZE (PAGE_SIZE * 2)

sys/dev/drm/i915/intel_guc_log.c

263

src_data += PAGE_SIZE;

sys/dev/drm/i915/intel_guc_log.c

264

dst_data += PAGE_SIZE;

sys/dev/drm/i915/intel_guc_log.c

480

guc_log_size = PAGE_SIZE + CRASH_BUFFER_SIZE + DPC_BUFFER_SIZE +

sys/dev/drm/i915/intel_guc_submission.c

391

LRC_STATE_PN * PAGE_SIZE;

sys/dev/drm/i915/intel_lrc.c

1373

ce->lrc_reg_state = vaddr + LRC_STATE_PN * PAGE_SIZE;

sys/dev/drm/i915/intel_lrc.c

1663

#define CTX_WA_BB_OBJ_SIZE (PAGE_SIZE)

sys/dev/drm/i915/intel_lrc.c

1986

engine->pinned_default_state + LRC_STATE_PN * PAGE_SIZE,

sys/dev/drm/i915/intel_lrc.c

1987

engine->context_size - PAGE_SIZE);

sys/dev/drm/i915/intel_lrc.c

233

desc |= i915_ggtt_offset(ce->state) + LRC_HEADER_PAGES * PAGE_SIZE;

sys/dev/drm/i915/intel_lrc.c

2785

const unsigned long start = LRC_HEADER_PAGES * PAGE_SIZE;

sys/dev/drm/i915/intel_lrc.c

2801

regs = vaddr + LRC_STATE_PN * PAGE_SIZE;

sys/dev/drm/i915/intel_lrc.c

2836

context_size += LRC_HEADER_PAGES * PAGE_SIZE;

sys/dev/drm/i915/intel_overlay.c

1311

obj = i915_gem_object_create_stolen(overlay->i915, PAGE_SIZE);

sys/dev/drm/i915/intel_overlay.c

1313

obj = i915_gem_object_create_internal(overlay->i915, PAGE_SIZE);

sys/dev/drm/i915/intel_pm.c

6773

(rc6_ctx_base + PAGE_SIZE < dev_priv->dsm_reserved.end))) {

sys/dev/drm/i915/intel_ringbuffer.c

1457

ring = intel_engine_create_ring(engine, timeline, 32 * PAGE_SIZE);

sys/dev/drm/include/asm/shmparam.h

30

#define SHMLBA PAGE_SIZE

sys/dev/drm/include/linux/gfp.h

103

size_t bytes = PAGE_SIZE << order;

sys/dev/drm/include/linux/gfp.h

88

size_t bytes = PAGE_SIZE << order;

sys/dev/drm/include/linux/io-mapping.h

83

return ioremap_wc(mapping->base + offset, PAGE_SIZE);

sys/dev/drm/include/linux/mm.h

149

return Realmem / PAGE_SIZE;

sys/dev/drm/include/linux/pagemap.h

57

uaddr += PAGE_SIZE;

sys/dev/drm/include/linux/pagemap.h

82

uaddr += PAGE_SIZE;

sys/dev/drm/include/linux/pfn_t.h

32

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

sys/dev/drm/include/linux/scatterlist.h

104

if (offset > PAGE_SIZE)

sys/dev/drm/include/linux/scatterlist.h

87

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

sys/dev/drm/linux_compat.c

104

si->mem_unit = PAGE_SIZE;

sys/dev/drm/linux_dma.c

46

align = PAGE_SIZE << get_order(size);

sys/dev/drm/linux_dma.c

56

size_t align = PAGE_SIZE << get_order(size);

sys/dev/drm/linux_iomapping.c

52

imp->npages = size / PAGE_SIZE;

sys/dev/drm/linux_iomapping.c

80

paddr_end = imp->paddr + (imp->npages * PAGE_SIZE) - 1;

sys/dev/drm/linux_iomapping.c

96

pmap_unmapdev((vm_offset_t)imp->pmap_addr, imp->npages * PAGE_SIZE);

sys/dev/drm/linux_shmem.c

145

m = vm_fault_page(map, start + i * PAGE_SIZE,

sys/dev/drm/linux_vmalloc.c

55

size = count * PAGE_SIZE;

sys/dev/drm/linux_vmalloc.c

57

VM_SUBSYS_DRM_VMAP, PAGE_SIZE);

sys/dev/drm/linux_vmalloc.c

79

size = vmp->npages * PAGE_SIZE;

sys/dev/drm/radeon/cik.c

4421

PAGE_SIZE, true,

sys/dev/drm/radeon/cik.c

4592

PAGE_SIZE, true,

sys/dev/drm/radeon/evergreen.c

4155

r = radeon_bo_create(rdev, dws * 4, PAGE_SIZE, true,

sys/dev/drm/radeon/evergreen.c

4234

r = radeon_bo_create(rdev, dws * 4, PAGE_SIZE, true,

sys/dev/drm/radeon/evergreen.c

4311

PAGE_SIZE, true,

sys/dev/drm/radeon/r600.c

1504

PAGE_SIZE, true, RADEON_GEM_DOMAIN_VRAM,

sys/dev/drm/radeon/r600.c

3499

PAGE_SIZE, true,

sys/dev/drm/radeon/radeon_benchmark.c

109

r = radeon_bo_create(rdev, size, PAGE_SIZE, true, ddomain, 0, NULL, NULL, &dobj);

sys/dev/drm/radeon/radeon_benchmark.c

97

r = radeon_bo_create(rdev, size, PAGE_SIZE, true, sdomain, 0, NULL, NULL, &sobj);

sys/dev/drm/radeon/radeon_device.c

457

r = radeon_bo_create(rdev, RADEON_GPU_PAGE_SIZE, PAGE_SIZE, true,

sys/dev/drm/radeon/radeon_device.c

782

rdev->dummy_page.dmah = drm_pci_alloc(rdev->ddev, PAGE_SIZE, PAGE_SIZE);

sys/dev/drm/radeon/radeon_fb.c

155

aligned_size = ALIGN(size, PAGE_SIZE);

sys/dev/drm/radeon/radeon_gart.c

133

PAGE_SIZE, true, RADEON_GEM_DOMAIN_VRAM,

sys/dev/drm/radeon/radeon_gart.c

253

p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);

sys/dev/drm/radeon/radeon_gart.c

257

for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {

sys/dev/drm/radeon/radeon_gart.c

300

p = t / (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);

sys/dev/drm/radeon/radeon_gart.c

305

for (j = 0; j < (PAGE_SIZE / RADEON_GPU_PAGE_SIZE); j++, t++) {

sys/dev/drm/radeon/radeon_gart.c

337

if (PAGE_SIZE < RADEON_GPU_PAGE_SIZE) {

sys/dev/drm/radeon/radeon_gart.c

345

rdev->gart.num_cpu_pages = rdev->mc.gtt_size / PAGE_SIZE;

sys/dev/drm/radeon/radeon_gem.c

266

args->size = roundup(args->size, PAGE_SIZE);

sys/dev/drm/radeon/radeon_gem.c

58

if (alignment < PAGE_SIZE) {

sys/dev/drm/radeon/radeon_gem.c

59

alignment = PAGE_SIZE;

sys/dev/drm/radeon/radeon_gem.c

767

args->size = ALIGN(args->size, PAGE_SIZE);

sys/dev/drm/radeon/radeon_object.c

185

unsigned long page_align = roundup(byte_align, PAGE_SIZE) >> PAGE_SHIFT;

sys/dev/drm/radeon/radeon_object.c

189

size = ALIGN(size, PAGE_SIZE);

sys/dev/drm/radeon/radeon_pm.c

363

return ksnprintf(buf, PAGE_SIZE, "%s\n",

sys/dev/drm/radeon/radeon_pm.c

418

return ksnprintf(buf, PAGE_SIZE, "%s\n",

sys/dev/drm/radeon/radeon_pm.c

477

return snprintf(buf, PAGE_SIZE, "%s\n",

sys/dev/drm/radeon/radeon_pm.c

523

return ksnprintf(buf, PAGE_SIZE, "off\n");

sys/dev/drm/radeon/radeon_pm.c

525

return snprintf(buf, PAGE_SIZE, "%s\n",

sys/dev/drm/radeon/radeon_pm.c

690

return ksnprintf(buf, PAGE_SIZE, "%d\n", temp);

sys/dev/drm/radeon/radeon_pm.c

706

return ksnprintf(buf, PAGE_SIZE, "%d\n", temp);

sys/dev/drm/radeon/radeon_prime.c

83

ret = radeon_bo_create(rdev, attach->dmabuf->size, PAGE_SIZE, false,

sys/dev/drm/radeon/radeon_ring.c

385

r = radeon_bo_create(rdev, ring->ring_size, PAGE_SIZE, true,

sys/dev/drm/radeon/radeon_test.c

69

r = radeon_bo_create(rdev, size, PAGE_SIZE, true, RADEON_GEM_DOMAIN_VRAM,

sys/dev/drm/radeon/radeon_test.c

89

r = radeon_bo_create(rdev, size, PAGE_SIZE, true,

sys/dev/drm/radeon/radeon_ttm.c

1141

loff_t p = *pos / PAGE_SIZE;

sys/dev/drm/radeon/radeon_ttm.c

1143

size_t cur_size = min_t(size_t, size, PAGE_SIZE - off);

sys/dev/drm/radeon/radeon_ttm.c

299

BUILD_BUG_ON((PAGE_SIZE % RADEON_GPU_PAGE_SIZE) != 0);

sys/dev/drm/radeon/radeon_ttm.c

301

num_pages = new_mem->num_pages * (PAGE_SIZE / RADEON_GPU_PAGE_SIZE);

sys/dev/drm/radeon/radeon_ttm.c

562

unsigned long end = gtt->userptr + ttm->num_pages * PAGE_SIZE;

sys/dev/drm/radeon/radeon_ttm.c

571

uint64_t userptr = gtt->userptr + pinned * PAGE_SIZE;

sys/dev/drm/radeon/radeon_ttm.c

786

0, PAGE_SIZE,

sys/dev/drm/radeon/radeon_ttm.c

792

PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

sys/dev/drm/radeon/radeon_ttm.c

841

PAGE_SIZE, PCI_DMA_BIDIRECTIONAL);

sys/dev/drm/radeon/radeon_ttm.c

923

r = radeon_bo_create(rdev, 256 * 1024, PAGE_SIZE, true,

sys/dev/drm/radeon/radeon_uvd.c

187

r = radeon_bo_create(rdev, bo_size, PAGE_SIZE, true,

sys/dev/drm/radeon/radeon_vce.c

142

r = radeon_bo_create(rdev, size, PAGE_SIZE, true,

sys/dev/drm/ttm/ttm_bo.c

117

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

sys/dev/drm/ttm/ttm_bo.c

1220

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

sys/dev/drm/ttm/ttm_bo_util.c

258

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

sys/dev/drm/ttm/ttm_bo_util.c

286

memcpy_fromio(dst, src, PAGE_SIZE);

sys/dev/drm/ttm/ttm_bo_util.c

322

memcpy_toio(dst, src, PAGE_SIZE);

sys/dev/drm/ttm/ttm_bo_util.c

376

memset_io(new_iomap, 0, new_mem->num_pages*PAGE_SIZE);

sys/dev/drm/ttm/ttm_bo_vm.c

289

address += PAGE_SIZE;

sys/dev/drm/ttm/ttm_bo_vm.c

337

unsigned long bytes = min(bytes_left, PAGE_SIZE - offset);

sys/dev/drm/ttm/ttm_memory.c

105

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

sys/dev/drm/ttm/ttm_memory.c

279

if ((physmem * PAGE_SIZE) <= ((uint64_t) 1ULL << 32)) {

sys/dev/drm/ttm/ttm_memory.c

334

mem = (uint64_t)vm_contig_avail_pages() * PAGE_SIZE;

sys/dev/drm/ttm/ttm_memory.c

353

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

sys/dev/drm/ttm/ttm_memory.c

354

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

sys/dev/drm/ttm/ttm_memory.c

575

else if (size > PAGE_SIZE)

sys/dev/drm/ttm/ttm_page_alloc.c

1000

dma_unmap_page(dev, tt->dma_address[i], num_pages * PAGE_SIZE,

sys/dev/drm/ttm/ttm_page_alloc.c

172

val = val / (PAGE_SIZE >> 10);

sys/dev/drm/ttm/ttm_page_alloc.c

181

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 7),

sys/dev/drm/ttm/ttm_page_alloc.c

182

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm/ttm/ttm_page_alloc.c

186

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm/ttm/ttm_page_alloc.c

208

val = val * (PAGE_SIZE >> 10);

sys/dev/drm/ttm/ttm_page_alloc.c

210

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

sys/dev/drm/ttm/ttm_page_alloc.c

58

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

sys/dev/drm/ttm/ttm_page_alloc.c

881

ttm_mem_global_free_page(mem_glob, ttm->pages[i], PAGE_SIZE);

sys/dev/drm/ttm/ttm_page_alloc.c

911

PAGE_SIZE, ctx);

sys/dev/drm/ttm/ttm_page_alloc.c

959

0, num_pages * PAGE_SIZE,

sys/dev/drm/ttm/ttm_page_alloc.c

964

PAGE_SIZE, DMA_BIDIRECTIONAL);

sys/dev/drm/ttm/ttm_page_alloc.c

972

tt->dma_address[i + 1] = tt->dma_address[i] + PAGE_SIZE;

sys/dev/drm/ttm/ttm_page_alloc_dma.c

214

val = val / (PAGE_SIZE >> 10);

sys/dev/drm/ttm/ttm_page_alloc_dma.c

223

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 7),

sys/dev/drm/ttm/ttm_page_alloc_dma.c

224

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm/ttm/ttm_page_alloc_dma.c

228

NUM_PAGES_TO_ALLOC*(PAGE_SIZE >> 10));

sys/dev/drm/ttm/ttm_page_alloc_dma.c

250

val = val * (PAGE_SIZE >> 10);

sys/dev/drm/ttm/ttm_page_alloc_dma.c

252

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

sys/dev/drm/ttm/ttm_page_alloc_dma.c

356

num_pages = pool->size / PAGE_SIZE;

sys/dev/drm/ttm/ttm_page_alloc_dma.c

55

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

sys/dev/drm/ttm/ttm_page_alloc_dma.c

598

pool->size = PAGE_SIZE;

sys/dev/drm/ttm/ttm_page_alloc_dma.c

705

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

sys/dev/drm/ttm/ttm_page_alloc_dma.c

751

npages = pool->size / PAGE_SIZE;

sys/dev/drm/ttm/ttm_page_alloc_dma.c

936

PAGE_SIZE;

sys/dev/misc/cuse/cuse.c

1416

if ((size % PAGE_SIZE) != 0 || (size < PAGE_SIZE))

sys/dev/misc/cuse/cuse.c

1428

max_off = min_off + (PAGE_SIZE * mem->page_count);

sys/dev/misc/cuse/cuse.c

460

object = swap_pager_alloc(NULL, PAGE_SIZE * page_count,

sys/dev/misc/cuse/cuse.c

67

(CUSE_ALLOC_BYTES_MAX / PAGE_SIZE)

sys/dev/misc/dcons/dcons_os.c

463

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

sys/dev/misc/syscons/syscons.c

4091

roundup(scp->sc->fbi->height * scp->sc->fbi->stride, PAGE_SIZE);

sys/dev/misc/syscons/syscons.c

4092

if (ap->a_offset > sz - PAGE_SIZE) {

sys/dev/netif/ath/ath/if_ath_descdma.c

184

PAGE_SIZE, 0, /* alignment, bounds */

sys/dev/netif/bce/if_bce.c

2186

BCE_MAX_SEGMENTS, PAGE_SIZE,

sys/dev/netif/bfe/if_bfe.c

208

error = bus_dmamem_coherent(sc->bfe_parent_tag, PAGE_SIZE, 0,

sys/dev/netif/bfe/if_bfe.c

222

error = bus_dmamem_coherent(sc->bfe_parent_tag, PAGE_SIZE, 0,

sys/dev/netif/bge/if_bge.c

4403

txmaxsz, BGE_NSEG_NEW, PAGE_SIZE,

sys/dev/netif/bge/if_bge.c

4517

error = bus_dmamem_coherent(sc->bge_cdata.bge_parent_tag, PAGE_SIZE, 0,

sys/dev/netif/bge/if_bgevar.h

129

#define BGE_JPAGESZ PAGE_SIZE

sys/dev/netif/bnx/if_bnx.c

4355

error = bus_dmamem_coherent(sc->bnx_cdata.bnx_parent_tag, PAGE_SIZE, 0,

sys/dev/netif/bnx/if_bnx.c

5195

txmaxsegsz = PAGE_SIZE;

sys/dev/netif/bnx/if_bnxvar.h

129

#define BNX_JPAGESZ PAGE_SIZE

sys/dev/netif/dc/if_dc.c

2087

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

sys/dev/netif/em/if_em.c

2922

PAGE_SIZE, /* maxsegsize */

sys/dev/netif/emx/if_emx.h

174

#define EMX_MAX_SEGSIZE PAGE_SIZE

sys/dev/netif/igb/if_igb.c

1914

PAGE_SIZE, /* maxsegsize */

sys/dev/netif/iwm/if_iwm.c

1150

error = bus_dma_tag_create(sc->sc_dmat, PAGE_SIZE,

sys/dev/netif/iwm/if_iwm.c

999

error = bus_dma_tag_create(sc->sc_dmat, PAGE_SIZE,

sys/dev/netif/iwm/if_iwmvar.h

312

#define IWM_CMD_RESP_MAX PAGE_SIZE

sys/dev/netif/ix/if_ix.c

2052

PAGE_SIZE, /* maxsegsize */

sys/dev/netif/ix/if_ix.c

2471

PAGE_SIZE, /* maxsize */

sys/dev/netif/ix/if_ix.c

2473

PAGE_SIZE, /* maxsegsize */

sys/dev/netif/lge/if_lge.c

500

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

sys/dev/netif/lge/if_lge.c

740

M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/netif/lge/if_lgereg.h

497

#define LGE_JPAGESZ PAGE_SIZE

sys/dev/netif/msk/if_msk.c

2086

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/netif/msk/if_msk.c

2103

PAGE_SIZE, 0, /* alignment, boundary */

sys/dev/netif/msk/if_mskreg.h

2349

#define MSK_JPAGESZ PAGE_SIZE

sys/dev/netif/mxge/if_mxge.c

205

pmap_change_attr((vm_offset_t) sc->sram, len / PAGE_SIZE,

sys/dev/netif/mxge/if_mxge.c

385

va = pmap_mapdev(trunc_page((vm_paddr_t)off), PAGE_SIZE);

sys/dev/netif/mxge/if_mxge.c

399

pmap_unmapdev((vm_offset_t)va, PAGE_SIZE);

sys/dev/netif/mxge/if_mxge.c

408

pmap_unmapdev((vm_offset_t)va, PAGE_SIZE);

sys/dev/netif/mxge/if_mxge.c

412

pmap_unmapdev((vm_offset_t)va, PAGE_SIZE);

sys/dev/netif/nfe/if_nfe.c

1660

error = bus_dmamem_coherent(sc->sc_dtag, PAGE_SIZE, 0,

sys/dev/netif/nfe/if_nfe.c

1882

error = bus_dmamem_coherent(sc->sc_dtag, PAGE_SIZE, 0,

sys/dev/netif/nfe/if_nfe.c

1947

error = bus_dmamem_coherent(sc->sc_dtag, PAGE_SIZE, 0,

sys/dev/netif/nge/if_nge.c

1093

M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/netif/nge/if_nge.c

820

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

sys/dev/netif/nge/if_ngereg.h

607

#define NGE_JPAGESZ PAGE_SIZE

sys/dev/netif/oce/oce_queue.c

241

PAGE_SIZE, 0, &wq->tag);

sys/dev/netif/oce/oce_queue.c

442

1, PAGE_SIZE, 0, &rq->tag);

sys/dev/netif/pcn/if_pcn.c

580

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

sys/dev/netif/sf/if_sf.c

737

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

sys/dev/netif/sk/if_sk.c

2973

error = bus_dmamem_coherent(cd->sk_buf_dtag, PAGE_SIZE /* XXX */, 0,

sys/dev/netif/sk/if_skreg.h

1357

#define SK_JPAGESZ PAGE_SIZE

sys/dev/netif/sln/if_sln.c

222

M_DEVBUF, M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/netif/ste/if_ste.c

933

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

sys/dev/netif/stge/if_stgevar.h

53

#define STGE_MAXSGSIZE PAGE_SIZE

sys/dev/netif/ti/if_ti.c

1483

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

sys/dev/netif/ti/if_ti.c

585

M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/netif/ti/if_tireg.h

1051

#define TI_JPAGESZ PAGE_SIZE

sys/dev/netif/ti/if_tireg.h

824

#define TI_PAGE_SIZE PAGE_SIZE

sys/dev/netif/tl/if_tl.c

1135

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

sys/dev/netif/tx/if_tx.c

1417

((desc->next & PAGE_MASK) + sizeof *desc) > PAGE_SIZE) {

sys/dev/netif/tx/if_tx.c

1441

((desc->next & PAGE_MASK) + sizeof *desc) > PAGE_SIZE) {

sys/dev/netif/tx/if_tx.c

1450

((desc->bufaddr & PAGE_MASK) + sizeof(struct epic_frag_list)) > PAGE_SIZE) {

sys/dev/netif/txp/if_txp.c

247

M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/netif/txp/if_txp.c

256

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

sys/dev/netif/vr/if_vr.c

743

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

sys/dev/netif/vr/if_vr.c

753

M_WAITOK, 0, 0xffffffff, PAGE_SIZE, 0);

sys/dev/netif/wb/if_wb.c

780

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

sys/dev/raid/aac/aac.c

1809

if (sc->aac_max_fib_size > PAGE_SIZE)

sys/dev/raid/aac/aac.c

1810

sc->aac_max_fib_size = PAGE_SIZE;

sys/dev/raid/aac/aac.c

1811

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

sys/dev/raid/aac/aac_pci.c

441

PAGE_SIZE, 0, /* algnmnt, boundary */

sys/dev/raid/amr/amr_disk.c

255

sc->amrd_dev_t->si_iosize_max = (AMR_NSEG - 1) * PAGE_SIZE;

sys/dev/raid/arcmsr/arcmsr.c

4384

/*maxsize*/ ARCMSR_MAX_SG_ENTRIES * PAGE_SIZE * ARCMSR_MAX_FREESRB_NUM,

sys/dev/raid/asr/asr.c

1538

next = trunc_page(base) + PAGE_SIZE;

sys/dev/raid/asr/asr.c

1820

next = trunc_page(base) + PAGE_SIZE;

sys/dev/raid/asr/asr.c

1872

I2O_EXEC_OUTBOUND_INIT_MESSAGE_setHostPageFrameSize(Message_Ptr, PAGE_SIZE);

sys/dev/raid/asr/asr.c

3379

next = trunc_page(base) + PAGE_SIZE;

sys/dev/raid/ciss/ciss.c

2970

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

sys/dev/raid/dpt/dpt_scsi.c

1238

PAGE_SIZE, /*nsegments*/1,

sys/dev/raid/dpt/dpt_scsi.c

312

PAGE_SIZE, dptmapmem, &sg_map->sg_physaddr,

sys/dev/raid/dpt/dpt_scsi.c

353

newcount = (PAGE_SIZE / (dpt->sgsize * sizeof(dpt_sg_t)));

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

1046

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

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

127

return contigmalloc(PAGE_SIZE<<order,

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

128

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

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

133

contigfree(p, PAGE_SIZE<<order, M_DEVBUF);

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

164

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

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

168

HPT_ASSERT(f->alignment<=PAGE_SIZE);

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

182

HPT_ASSERT(PAGE_SIZE==DMAPOOL_PAGE_SIZE);

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

224

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

sys/dev/raid/hpt27xx/hpt27xx_osm_bsd.c

231

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

sys/dev/raid/hptiop/hptiop.c

1951

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

sys/dev/raid/hptmv/entry.c

1300

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

sys/dev/raid/hptmv/entry.c

1407

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

sys/dev/raid/hptmv/entry.c

2977

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

sys/dev/raid/hptmv/entry.c

2983

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

sys/dev/raid/hptmv/entry.c

907

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

sys/dev/raid/hptmv/entry.c

933

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

sys/dev/raid/hptmv/hptproc.c

292

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

sys/dev/raid/hptmv/ioctl.c

643

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

sys/dev/raid/hptmv/ioctl.c

654

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

sys/dev/raid/hptrr/hptrr_osm_bsd.c

1021

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

sys/dev/raid/hptrr/hptrr_osm_bsd.c

142

return contigmalloc(PAGE_SIZE<<order,

sys/dev/raid/hptrr/hptrr_osm_bsd.c

143

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

sys/dev/raid/hptrr/hptrr_osm_bsd.c

148

contigfree(p, PAGE_SIZE<<order, M_DEVBUF);

sys/dev/raid/hptrr/hptrr_osm_bsd.c

179

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

sys/dev/raid/hptrr/hptrr_osm_bsd.c

184

HPT_ASSERT(f->alignment<=PAGE_SIZE);

sys/dev/raid/hptrr/hptrr_osm_bsd.c

198

HPT_ASSERT(PAGE_SIZE==DMAPOOL_PAGE_SIZE);

sys/dev/raid/hptrr/hptrr_osm_bsd.c

240

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

sys/dev/raid/hptrr/hptrr_osm_bsd.c

247

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

sys/dev/raid/mfi/mfi.c

453

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

sys/dev/raid/mfi/mfi.c

952

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

sys/dev/raid/mfi/mfi_disk.c

152

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

sys/dev/raid/mlx/mlx_disk.c

268

s2 = (sc->mlxd_controller->mlx_enq2->me_max_sg - 1) * PAGE_SIZE;

sys/dev/raid/mly/mly.c

1825

if ((segs[0].ds_addr % PAGE_SIZE) >

sys/dev/raid/mly/mly.c

1826

((segs[0].ds_addr + mc->mc_packet->scsi_large.cdb_length) % PAGE_SIZE))

sys/dev/raid/mpr/mpr.c

1450

howmany(rsize, PAGE_SIZE), /* nsegments */

sys/dev/raid/mpr/mpr.c

1504

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

sys/dev/raid/mpr/mpr.c

1593

PRPs_required = sc->maxio / PAGE_SIZE;

sys/dev/raid/mpr/mpr.c

1594

PRPs_per_page = (PAGE_SIZE / PRP_ENTRY_SIZE) - 1;

sys/dev/raid/mpr/mpr.c

1597

sc->prp_buffer_size = PAGE_SIZE * pages_required;

sys/dev/raid/mpr/mpr.c

2732

page_mask = PAGE_SIZE - 1;

sys/dev/raid/mpr/mpr.c

2787

entry_len = PAGE_SIZE - offset;

sys/dev/raid/mpr/mpr.c

2810

if (length > PAGE_SIZE)

sys/dev/raid/mpr/mpr.c

2906

page_mask = PAGE_SIZE - 1;

sys/dev/raid/mpr/mpr.c

2929

if (buff_len > (PAGE_SIZE * 5))

sys/dev/raid/mpr/mpr.c

2931

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

sys/dev/raid/mpr/mpr.c

2932

(buff_len <= (PAGE_SIZE * 5)) )

sys/dev/raid/mpr/mpr.c

2938

first_page_data_size = PAGE_SIZE - first_page_offset;

sys/dev/raid/mpr/mpr.c

2939

end_residual = buff_len % PAGE_SIZE;

sys/dev/raid/mpr/mpr.c

2954

(buff_len - (PAGE_SIZE * 4)))

sys/dev/raid/mpr/mpr.c

3096

entry_len = PAGE_SIZE - offset;

sys/dev/raid/mpr/mpr.c

417

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

sys/dev/raid/mpr/mpr.c

424

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

sys/dev/raid/mpr/mpr.c

431

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

sys/dev/raid/mps/mps.c

829

nsegs = (MAXPHYS / PAGE_SIZE) + 1;

sys/dev/raid/twe/twe_freebsd.c

863

dsk->si_iosize_max = (TWE_MAX_SGL_LENGTH - 1) * PAGE_SIZE;

sys/dev/sound/pci/hda/hdac.c

632

alignment = roundup2(HDA_DMA_ALIGNMENT, PAGE_SIZE);

sys/dev/video/bktr/bktr_core.c

141

#define DMA_PROG_ALLOC (8 * PAGE_SIZE)

sys/dev/video/bktr/bktr_core.c

160

#define BROOKTREE_ALLOC (BROOKTREE_ALLOC_PAGES * PAGE_SIZE)

sys/dev/video/bktr/bktr_core.c

1661

if (geo->frames > 1) temp += PAGE_SIZE;

sys/dev/video/bktr/bktr_core.c

1667

buf = get_bktr_mem(unit, temp*PAGE_SIZE);

sys/dev/video/bktr/bktr_core.c

1670

(bktr->alloc_pages * PAGE_SIZE));

sys/dev/video/bktr/bktr_core.c

1677

bktr_name(bktr), temp*PAGE_SIZE);

sys/dev/video/bktr/bktr_core.c

768

if ((u_int) bktr->alloc_pages * PAGE_SIZE

sys/dev/video/bktr/bktr_os.c

407

0xffffffff, PAGE_SIZE, 0);

sys/dev/video/bktr/bktr_os.c

680

if (ap->a_offset >= bktr->alloc_pages * PAGE_SIZE)

sys/dev/video/cxm/cxm.h

183

#define CXM_SG_SEGMENT rounddown2(0xff00, PAGE_SIZE)

sys/dev/video/fb/vga.c

1721

if (offset > adp->va_window_size - PAGE_SIZE)

sys/dev/virtual/amazon/ena/ena.c

222

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

sys/dev/virtual/hyperv/hyperv.c

141

hypercall_context.hc_addr = hyperv_dmamem_alloc(NULL, PAGE_SIZE, 0,

sys/dev/virtual/hyperv/hyperv.c

142

PAGE_SIZE, &hypercall_context.hc_dma, BUS_DMA_WAITOK);

sys/dev/virtual/hyperv/hyperv_reg.h

149

} __packed __aligned(PAGE_SIZE);

sys/dev/virtual/hyperv/hyperv_reg.h

150

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

sys/dev/virtual/hyperv/vmbus/vmbus.c

645

PAGE_SIZE, 0, PAGE_SIZE, &psc->message_dma,

sys/dev/virtual/hyperv/vmbus/vmbus.c

651

PAGE_SIZE, 0, PAGE_SIZE, &psc->event_flags_dma,

sys/dev/virtual/hyperv/vmbus/vmbus.c

657

evtflags = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,

sys/dev/virtual/hyperv/vmbus/vmbus.c

658

PAGE_SIZE, &sc->vmbus_evtflags_dma, BUS_DMA_WAITOK | BUS_DMA_ZERO);

sys/dev/virtual/hyperv/vmbus/vmbus.c

662

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

sys/dev/virtual/hyperv/vmbus/vmbus.c

665

sc->vmbus_mnf1 = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,

sys/dev/virtual/hyperv/vmbus/vmbus.c

666

PAGE_SIZE, &sc->vmbus_mnf1_dma, BUS_DMA_WAITOK | BUS_DMA_ZERO);

sys/dev/virtual/hyperv/vmbus/vmbus.c

670

sc->vmbus_mnf2 = hyperv_dmamem_alloc(parent_dtag, PAGE_SIZE, 0,

sys/dev/virtual/hyperv/vmbus/vmbus.c

671

PAGE_SIZE, &sc->vmbus_mnf2_dma, BUS_DMA_WAITOK | BUS_DMA_ZERO);

sys/dev/virtual/hyperv/x86_64/hyperv_machdep.c

186

hyperv_ref_tsc.tsc_ref = hyperv_dmamem_alloc(NULL, PAGE_SIZE, 0,

sys/dev/virtual/nvmm/nvmm.c

656

if ((hva % PAGE_SIZE) != 0 || (size % PAGE_SIZE) != 0) {

sys/dev/virtual/nvmm/nvmm.c

823

if ((gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0 ||

sys/dev/virtual/nvmm/nvmm.c

824

(args->hva % PAGE_SIZE) != 0) {

sys/dev/virtual/nvmm/nvmm.c

881

if ((gpa % PAGE_SIZE) != 0 || (args->size % PAGE_SIZE) != 0) {

sys/dev/virtual/nvmm/nvmm_dragonfly.c

220

ret = (void *)kmem_alloc(kernel_map, roundup(size, PAGE_SIZE),

sys/dev/virtual/nvmm/nvmm_dragonfly.c

223

OS_ASSERT((uintptr_t)ret % PAGE_SIZE == 0);

sys/dev/virtual/nvmm/nvmm_dragonfly.c

231

kmem_free(kernel_map, (vaddr_t)ptr, roundup(size, PAGE_SIZE));

sys/dev/virtual/nvmm/nvmm_dragonfly.c

256

addr = contigmalloc(npages * PAGE_SIZE, M_NVMM, M_WAITOK | M_ZERO,

sys/dev/virtual/nvmm/nvmm_dragonfly.c

257

0, ~0UL, PAGE_SIZE, 0);

sys/dev/virtual/nvmm/nvmm_dragonfly.c

269

contigfree((void *)va, npages * PAGE_SIZE, M_NVMM);

sys/dev/virtual/nvmm/nvmm_internal.h

51

(roundup(sizeof(struct nvmm_comm_page), PAGE_SIZE))

sys/dev/virtual/nvmm/nvmm_netbsd.c

151

ret = (void *)uvm_km_alloc(kernel_map, roundup(size, PAGE_SIZE), 0,

sys/dev/virtual/nvmm/nvmm_netbsd.c

154

OS_ASSERT((uintptr_t)ret % PAGE_SIZE == 0);

sys/dev/virtual/nvmm/nvmm_netbsd.c

162

uvm_km_free(kernel_map, (vaddr_t)ptr, roundup(size, PAGE_SIZE),

sys/dev/virtual/nvmm/nvmm_netbsd.c

191

ret = uvm_pglistalloc(npages * PAGE_SIZE, 0, ~0UL, PAGE_SIZE, 0,

sys/dev/virtual/nvmm/nvmm_netbsd.c

196

_va = uvm_km_alloc(kernel_map, npages * PAGE_SIZE, 0,

sys/dev/virtual/nvmm/nvmm_netbsd.c

202

pmap_kenter_pa(_va + i * PAGE_SIZE, _pa + i * PAGE_SIZE,

sys/dev/virtual/nvmm/nvmm_netbsd.c

207

memset((void *)_va, 0, npages * PAGE_SIZE);

sys/dev/virtual/nvmm/nvmm_netbsd.c

215

uvm_pagefree(PHYS_TO_VM_PAGE(_pa + i * PAGE_SIZE));

sys/dev/virtual/nvmm/nvmm_netbsd.c

225

pmap_kremove(va, npages * PAGE_SIZE);

sys/dev/virtual/nvmm/nvmm_netbsd.c

227

uvm_km_free(kernel_map, va, npages * PAGE_SIZE, UVM_KMF_VAONLY);

sys/dev/virtual/nvmm/nvmm_netbsd.c

229

uvm_pagefree(PHYS_TO_VM_PAGE(pa + i * PAGE_SIZE));

sys/dev/virtual/nvmm/x86/nvmm_x86_svm.c

481

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

sys/dev/virtual/nvmm/x86/nvmm_x86_svm.c

522

#define MSRBM_SIZE (MSRBM_NPAGES * PAGE_SIZE)

sys/dev/virtual/nvmm/x86/nvmm_x86_svm.c

525

#define IOBM_SIZE (IOBM_NPAGES * PAGE_SIZE)

sys/dev/virtual/nvmm/x86/nvmm_x86_vmx.c

649

uint8_t data[PAGE_SIZE - 4];

sys/dev/virtual/nvmm/x86/nvmm_x86_vmx.c

652

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

sys/dev/virtual/nvmm/x86/nvmm_x86_vmx.c

667

uint8_t data[PAGE_SIZE - 8];

sys/dev/virtual/nvmm/x86/nvmm_x86_vmx.c

670

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

sys/dev/virtual/nvmm/x86/nvmm_x86_vmx.c

759

#define VMCS_SIZE (VMCS_NPAGES * PAGE_SIZE)

sys/dev/virtual/nvmm/x86/nvmm_x86_vmx.c

762

#define MSRBM_SIZE (MSRBM_NPAGES * PAGE_SIZE)

sys/dev/virtual/virtio/balloon/virtio_balloon.c

197

CTASSERT(VTBALLOON_PAGES_PER_REQUEST * sizeof(uint32_t) <= PAGE_SIZE);

sys/dev/virtual/virtio/block/virtio_blk.c

583

nsegs = MIN(blkcfg->seg_max, MAXPHYS / PAGE_SIZE + 1 + nsegs);

sys/dev/virtual/virtio/block/virtio_blk.c

585

nsegs = MAXPHYS / PAGE_SIZE + 1 + nsegs;

sys/dev/virtual/virtio/mmio/virtio_mmio.c

516

vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_PAGE_SIZE, PAGE_SIZE);

sys/dev/virtual/virtio/mmio/virtio_mmio.c

700

vtmmio_write_config_4(sc, VIRTIO_MMIO_GUEST_PAGE_SIZE, PAGE_SIZE);

sys/dev/virtual/virtio/scsi/virtio_scsi.c

1015

PAGE_SIZE;

sys/dev/virtual/virtio/scsi/virtio_scsi.c

501

nsegs += MIN(seg_max, MAXPHYS / PAGE_SIZE + 1);

sys/dev/virtual/virtio/virtio/virtio.h

96

#define VIRTIO_MAX_INDIRECT ((int) (PAGE_SIZE / 16))

sys/dev/virtual/virtio/virtio/virtqueue.c

196

M_WAITOK | M_ZERO, 0, highaddr, PAGE_SIZE, 0);

sys/dev/virtual/vmware/pvscsi/pvscsi.c

1448

cpi->maxio = (PVSCSI_MAX_SG_ENTRIES_PER_SEGMENT / 2) * PAGE_SIZE;

sys/dev/virtual/vmware/pvscsi/pvscsi.c

1658

PVSCSI_MAX_SG_ENTRIES_PER_SEGMENT * PAGE_SIZE,

sys/dev/virtual/vmware/pvscsi/pvscsi.c

1659

PVSCSI_MAX_SG_ENTRIES_PER_SEGMENT, PAGE_SIZE, BUS_DMA_ALLOCNOW,

sys/dev/virtual/vmware/pvscsi/pvscsi.c

1698

adapter_queue_size = (sc->req_ring_num_pages * PAGE_SIZE) /

sys/dev/virtual/vmware/pvscsi/pvscsi.c

514

error = pvscsi_dma_alloc(sc, dma, num_pages * PAGE_SIZE, PAGE_SIZE);

sys/dev/virtual/vmware/pvscsi/pvscsi.h

174

(PAGE_SIZE / sizeof(struct pvscsi_ring_req_desc))

sys/dev/virtual/vmware/pvscsi/pvscsi.h

176

(PAGE_SIZE / sizeof(struct pvscs_ring_cmp_desc))

sys/dev/virtual/vmware/pvscsi/pvscsi.h

178

(PAGE_SIZE / sizeof(struct pvscsi_ring_msg_desc))

sys/kern/imgact_elf.c

1071

phdr->p_align = PAGE_SIZE;

sys/kern/imgact_elf.c

1173

phdr->p_align = PAGE_SIZE;

sys/kern/imgact_elf.c

1741

limited_to_first_page = noteloc < PAGE_SIZE && endbyte < PAGE_SIZE;

sys/kern/imgact_elf.c

1749

firstlen = PAGE_SIZE - firstloc;

sys/kern/imgact_elf.c

1750

if (notesz < sizeof(Elf_Note) || notesz > PAGE_SIZE)

sys/kern/imgact_elf.c

1836

limited_to_first_page = pathloc < PAGE_SIZE && endbyte < PAGE_SIZE;

sys/kern/imgact_elf.c

1843

firstlen = PAGE_SIZE - firstloc;

sys/kern/imgact_elf.c

485

if ((hdr->e_phoff > PAGE_SIZE) ||

sys/kern/imgact_elf.c

486

(hdr->e_phentsize * hdr->e_phnum) > PAGE_SIZE - hdr->e_phoff) {

sys/kern/imgact_elf.c

637

if ((hdr->e_phoff > PAGE_SIZE) ||

sys/kern/imgact_elf.c

638

(hdr->e_phoff + hdr->e_phentsize * hdr->e_phnum) > PAGE_SIZE) {

sys/kern/imgact_elf.c

664

phdr[i].p_filesz > PAGE_SIZE ||

sys/kern/imgact_elf.c

860

elf_auxargs->pagesz = PAGE_SIZE;

sys/kern/imgact_shell.c

103

KKASSERT(offset <= PAGE_SIZE);

sys/kern/imgact_shell.c

106

if (ihp == &image_header[PAGE_SIZE])

sys/kern/imgact_shell.c

138

while (ihp < &image_header[PAGE_SIZE]) {

sys/kern/imgact_shell.c

154

} while (ihp < &image_header[PAGE_SIZE] &&

sys/kern/imgact_shell.c

75

while (ihp < &image_header[PAGE_SIZE]) {

sys/kern/imgact_shell.c

90

} while (ihp < &image_header[PAGE_SIZE] &&

sys/kern/init_main.c

604

addr = trunc_page(USRSTACK - PAGE_SIZE);

sys/kern/init_main.c

606

0, &addr, PAGE_SIZE,

sys/kern/init_main.c

607

PAGE_SIZE, FALSE,

sys/kern/init_main.c

613

p->p_vmspace->vm_ssize = PAGE_SIZE;

sys/kern/init_main.c

746

kpmap = kmalloc(roundup2(sizeof(*kpmap), PAGE_SIZE),

sys/kern/kern_exec.c

1262

(vm_offset_t)szsigbase + PAGE_SIZE,

sys/kern/kern_exec.c

159

if (new_val > 0 && ((new_val > 16 * PAGE_SIZE) || !powerof2(new_val)))

sys/kern/kern_exec.c

99

__read_mostly u_long ps_arg_cache_limit = PAGE_SIZE / 16;

sys/kern/kern_iosched.c

164

factor = badjiosched(curthread, PAGE_SIZE);

sys/kern/kern_memio.c

250

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

sys/kern/kern_memio.c

251

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

sys/kern/kern_memio.c

306

buf = kmalloc(PAGE_SIZE, M_TEMP, M_WAITOK);

sys/kern/kern_memio.c

307

c = min(iov->iov_len, PAGE_SIZE);

sys/kern/kern_memio.c

336

c = min(iov->iov_len, PAGE_SIZE);

sys/kern/kern_memio.c

351

buf = kmalloc(PAGE_SIZE, M_TEMP, M_WAITOK);

sys/kern/kern_memio.c

368

zbuf = (caddr_t)kmalloc(PAGE_SIZE, M_TEMP,

sys/kern/kern_memio.c

371

c = min(iov->iov_len, PAGE_SIZE);

sys/kern/kern_memio.c

782

offset < roundup2(sizeof(*p->p_upmap), PAGE_SIZE)) {

sys/kern/kern_memio.c

796

offset < roundup2(sizeof(*kpmap), PAGE_SIZE)) {

sys/kern/kern_memio.c

819

offset < roundup2(sizeof(*lp->lwp_lpmap), PAGE_SIZE)) {

sys/kern/kern_mib.c

199

0, PAGE_SIZE, "System memory page size");

sys/kern/kern_p1003_1b.c

370

p31b_setcfg(CTL_P1003_1B_PAGESIZE, PAGE_SIZE);

sys/kern/kern_physio.c

50

if (dev->si_iosize_max < PAGE_SIZE) {

sys/kern/kern_proc.c

1272

upmap = kmalloc(roundup2(sizeof(*upmap), PAGE_SIZE), M_UPMAP,

sys/kern/kern_proc.c

1324

lpmap = kmalloc(roundup2(sizeof(*lpmap), PAGE_SIZE), M_UPMAP,

sys/kern/kern_slaballoc.c

1778

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

sys/kern/kern_slaballoc.c

1799

i -= PAGE_SIZE; /* retry */

sys/kern/kern_slaballoc.c

1811

i -= PAGE_SIZE;

sys/kern/kern_slaballoc.c

1854

i += PAGE_SIZE;

sys/kern/kern_slaballoc.c

259

limsize = (size_t)vmstats.v_page_count * PAGE_SIZE;

sys/kern/kern_slaballoc.c

309

ZonePageCount = ZoneSize / PAGE_SIZE;

sys/kern/kern_slaballoc.c

316

ZeroPage = kmem_slab_alloc(PAGE_SIZE, PAGE_SIZE, M_WAITOK|M_ZERO);

sys/kern/kern_slaballoc.c

942

if (size >= ZoneLimit || ((size & PAGE_MASK) == 0 && size > PAGE_SIZE*2)) {

sys/kern/kern_slaballoc.c

946

chunk = kmem_slab_alloc(size, PAGE_SIZE, flags);

sys/kern/kern_slaballoc.c

954

*kup = size / PAGE_SIZE;

sys/kern/kern_subr.c

574

cnt = min(cnt, PAGE_SIZE - page_offset);

sys/kern/kern_xio.c

111

if ((n = PAGE_SIZE - xio->xio_offset) > kbytes)

sys/kern/kern_xio.c

121

if ((n = kbytes) > PAGE_SIZE)

sys/kern/kern_xio.c

122

n = PAGE_SIZE;

sys/kern/kern_xio.c

123

addr += PAGE_SIZE;

sys/kern/kern_xio.c

151

xio->xio_bytes = npages * PAGE_SIZE;

sys/kern/kern_xio.c

239

if ((n = PAGE_SIZE - offset) > bytes)

sys/kern/kern_xio.c

257

if ((n = bytes) > PAGE_SIZE)

sys/kern/kern_xio.c

258

n = PAGE_SIZE;

sys/kern/kern_xio.c

288

if ((n = PAGE_SIZE - offset) > bytes)

sys/kern/kern_xio.c

304

if ((n = bytes) > PAGE_SIZE)

sys/kern/kern_xio.c

305

n = PAGE_SIZE;

sys/kern/kern_xio.c

335

if ((n = PAGE_SIZE - offset) > bytes)

sys/kern/kern_xio.c

353

if ((n = bytes) > PAGE_SIZE)

sys/kern/kern_xio.c

354

n = PAGE_SIZE;

sys/kern/kern_xio.c

384

if ((n = PAGE_SIZE - offset) > bytes)

sys/kern/kern_xio.c

400

if ((n = bytes) > PAGE_SIZE)

sys/kern/kern_xio.c

401

n = PAGE_SIZE;

sys/kern/link_elf.c

449

firstpage = kmalloc(PAGE_SIZE, M_LINKER, M_WAITOK);

sys/kern/link_elf.c

451

error = vn_rdwr(UIO_READ, vp, firstpage, PAGE_SIZE, 0,

sys/kern/link_elf.c

453

nbytes = PAGE_SIZE - resid;

sys/kern/link_elf.c

490

(hdr->e_phoff + hdr->e_phnum*sizeof(Elf_Phdr) <= PAGE_SIZE) &&

sys/kern/link_elf_obj.c

665

PAGE_SIZE, TRUE,

sys/kern/subr_param.c

245

limsize = (size_t)physpages * PAGE_SIZE;

sys/kern/subr_sbuf.c

81

#ifdef PAGE_SIZE

sys/kern/subr_sbuf.c

82

#define SBUF_MAXEXTENDSIZE PAGE_SIZE

sys/kern/subr_sbuf.c

83

#define SBUF_MAXEXTENDINCR PAGE_SIZE

sys/kern/subr_sglist.c

131

seglen = MIN(len, PAGE_SIZE - offset);

sys/kern/subr_sglist.c

152

seglen = MIN(len, PAGE_SIZE);

sys/kern/subr_sglist.c

190

vaddr += PAGE_SIZE;

sys/kern/subr_sglist.c

193

if (lastaddr + PAGE_SIZE != paddr)

sys/kern/subr_sglist.c

196

vaddr += PAGE_SIZE;

sys/kern/sys_pipe.c

373

npages = round_page(size) / PAGE_SIZE;

sys/kern/sys_pipe.c

388

PAGE_SIZE, TRUE,

sys/kern/sysv_shm.c

360

align = PAGE_SIZE;

sys/kern/sysv_shm.c

716

shminfo.shmmax = shminfo.shmall * PAGE_SIZE;

sys/kern/uipc_syscalls.c

1766

if (xfsize > PAGE_SIZE)

sys/kern/uipc_syscalls.c

1767

xfsize = PAGE_SIZE;

sys/kern/uipc_syscalls.c

1769

if (PAGE_SIZE - pgoff < xfsize)

sys/kern/uipc_syscalls.c

1770

xfsize = PAGE_SIZE - pgoff;

sys/kern/uipc_syscalls.c

1863

m->m_ext.ext_size = PAGE_SIZE;

sys/kern/vfs_bio.c

1485

presid = PAGE_SIZE - poffset;

sys/kern/vfs_bio.c

1503

resid -= PAGE_SIZE - (foff & PAGE_MASK);

sys/kern/vfs_bio.c

1504

foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;

sys/kern/vfs_bio.c

2503

size = PAGE_SIZE;

sys/kern/vfs_bio.c

2515

if (tinc > PAGE_SIZE - ((toff + loffset) & PAGE_MASK))

sys/kern/vfs_bio.c

2516

tinc = PAGE_SIZE - ((toff + loffset) & PAGE_MASK);

sys/kern/vfs_bio.c

3184

tinc = PAGE_SIZE - ((bp->b_loffset + toff) & PAGE_MASK);

sys/kern/vfs_bio.c

3203

tinc = PAGE_SIZE;

sys/kern/vfs_bio.c

3620

resid = ((foff + PAGE_SIZE) & ~(off_t)PAGE_MASK) - foff;

sys/kern/vfs_bio.c

3690

foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;

sys/kern/vfs_bio.c

4070

eoff = PAGE_SIZE;

sys/kern/vfs_bio.c

4073

eoff = soff + PAGE_SIZE;

sys/kern/vfs_bio.c

4174

eoff = PAGE_SIZE;

sys/kern/vfs_bio.c

4177

eoff = soff + PAGE_SIZE;

sys/kern/vfs_bio.c

4206

if ((bp->b_xio.xio_npages == 1) && (bp->b_bufsize < PAGE_SIZE) &&

sys/kern/vfs_bio.c

4223

ea = (caddr_t)trunc_page((vm_offset_t)sa + PAGE_SIZE);

sys/kern/vfs_bio.c

4388

bdata += PAGE_SIZE -

sys/kern/vfs_bio.c

701

bogus_offset = kmem_alloc_pageable(kernel_map, PAGE_SIZE,

sys/kern/vfs_cluster.c

1610

(maxiosize / PAGE_SIZE)) ||

sys/kern/vfs_cluster.c

956

if ((bp->b_xio.xio_npages * PAGE_SIZE) +

sys/kern/vfs_helper.c

344

n = PAGE_SIZE - offset;

sys/kern/vfs_helper.c

355

0, PAGE_SIZE);

sys/kern/vfs_journal.c

1414

offset += PAGE_SIZE;

sys/kern/vfs_journal.c

979

int bytes = xio->xio_npages * PAGE_SIZE;

sys/kern/vfs_subr.c

190

freemem = (int64_t)vmstats.v_page_count * PAGE_SIZE;

sys/kern/vfs_vnops.c

957

sb->st_blksize = PAGE_SIZE;

sys/net/netmap/netmap_mem2.c

122

.objmaxsize = 32*PAGE_SIZE,

sys/net/netmap/netmap_mem2.c

520

delta = used % PAGE_SIZE;

sys/net/netmap/netmap_mem2.c

525

if (delta > ( (clustentries*objsize) % PAGE_SIZE) )

sys/net/netmap/netmap_mem2.c

531

i = (clustsize & (PAGE_SIZE - 1));

sys/net/netmap/netmap_mem2.c

533

clustsize += PAGE_SIZE - i;

sys/net/netmap/netmap_mem2.c

55

.size = 9*PAGE_SIZE,

sys/net/netmap/netmap_mem2.c

592

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

sys/net/netmap/netmap_mem2.c

85

.objmaxsize = 32*PAGE_SIZE,

sys/netinet/ip_output.c

806

if (len > PAGE_SIZE) {

sys/platform/pc64/acpica/acpi_sdt.c

73

mapsz = PAGE_SIZE;

sys/platform/pc64/apic/ioapic.c

607

return pmap_mapdev_uncacheable(pa, PAGE_SIZE);

sys/platform/pc64/include/globaldata.h

104

(MDGLOBALDATA_BASEALLOC_SIZE / PAGE_SIZE)

sys/platform/pc64/include/globaldata.h

126

char unused2[PAGE_SIZE];

sys/platform/pc64/include/globaldata.h

137

char reserved1[PAGE_SIZE -

sys/platform/pc64/include/globaldata.h

149

char dblstack[PAGE_SIZE * 2 -

sys/platform/pc64/include/globaldata.h

152

char dbgstack[PAGE_SIZE * 2 -

sys/platform/pc64/include/globaldata.h

157

char idlestack[UPAGES * PAGE_SIZE];

sys/platform/pc64/x86_64/busdma_machdep.c

1185

bpage->vaddr = (vm_offset_t)contigmalloc(PAGE_SIZE, M_DEVBUF,

sys/platform/pc64/x86_64/busdma_machdep.c

1229

contigfree((void *)bpage->vaddr, PAGE_SIZE, M_DEVBUF);

sys/platform/pc64/x86_64/busdma_machdep.c

1356

size = PAGE_SIZE - (bpage->busaddr & PAGE_MASK);

sys/platform/pc64/x86_64/busdma_machdep.c

258

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

sys/platform/pc64/x86_64/busdma_machdep.c

259

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

sys/platform/pc64/x86_64/busdma_machdep.c

543

dmat->maxsize / PAGE_SIZE, attr);

sys/platform/pc64/x86_64/busdma_machdep.c

628

vaddr += (PAGE_SIZE - (vaddr & PAGE_MASK));

sys/platform/pc64/x86_64/busdma_machdep.c

678

size = PAGE_SIZE - (paddr & PAGE_MASK);

sys/platform/pc64/x86_64/busdma_machdep.c

89

((dmat)->maxsize <= PAGE_SIZE && \

sys/platform/pc64/x86_64/busdma_machdep.c

90

(dmat)->alignment <= PAGE_SIZE && \

sys/platform/pc64/x86_64/db_trace.c

227

if ((unsigned long)*fp < PAGE_SIZE) {

sys/platform/pc64/x86_64/dump_machdep.c

166

pgs = mdp->md_size / PAGE_SIZE;

sys/platform/pc64/x86_64/dump_machdep.c

175

if (chunk > (max_iosize/PAGE_SIZE))

sys/platform/pc64/x86_64/dump_machdep.c

176

chunk = max_iosize/PAGE_SIZE;

sys/platform/pc64/x86_64/dump_machdep.c

184

a = pa + i * PAGE_SIZE;

sys/platform/pc64/x86_64/dump_machdep.c

227

phdr.p_align = PAGE_SIZE;

sys/platform/pc64/x86_64/efirt.c

289

va += PAGE_SIZE) {

sys/platform/pc64/x86_64/genassym.c

81

ASSYM(PAGE_SIZE, PAGE_SIZE);

sys/platform/pc64/x86_64/machdep.c

2116

Realmem += p->md_pages * PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2123

physmap[*physmap_idx + 1] += p->md_pages * PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2134

physmap[*physmap_idx + 1] = p->md_phys + p->md_pages * PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2319

physmap[0] = PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2392

if (pa == end - PAGE_SIZE)

sys/platform/pc64/x86_64/machdep.c

2393

incr = PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2395

incr = end - pa - PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2489

incr = PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2526

physmem += incr / PAGE_SIZE;

sys/platform/pc64/x86_64/machdep.c

2576

for (off = 0; off < msgbuf_size; off += PAGE_SIZE) {

sys/platform/pc64/x86_64/machdep.c

2906

for (off = 0; off < round_page(MSGBUF_SIZE); off += PAGE_SIZE)

sys/platform/pc64/x86_64/machdep.c

3647

bot = (char *)td->td_kstack + PAGE_SIZE; /* skip guard */

sys/platform/pc64/x86_64/machdep.c

367

(intmax_t)(size1 / PAGE_SIZE));

sys/platform/pc64/x86_64/machdep.c

406

long kbytes = physmem * (PAGE_SIZE / 1024); /* physmem */

sys/platform/pc64/x86_64/machdep.c

437

if (nbuf > physmem * PAGE_SIZE / (NBUFCALCSIZE * 2)) {

sys/platform/pc64/x86_64/machdep.c

438

nbuf = physmem * PAGE_SIZE / (NBUFCALCSIZE * 2);

sys/platform/pc64/x86_64/minidump_machdep.c

151

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

sys/platform/pc64/x86_64/minidump_machdep.c

261

lpdpttl += PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

268

lpdpttl += PAGE_SIZE * NPTEPG;

sys/platform/pc64/x86_64/minidump_machdep.c

273

pa += PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

282

lpdpttl += PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

290

lpdpttl += PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

309

pa = (((uint64_t)i * sizeof(*vm_page_dump) * NBBY) + bit) * PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

312

dumpsize += PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

319

dumpsize += PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

356

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

sys/platform/pc64/x86_64/minidump_machdep.c

399

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

sys/platform/pc64/x86_64/minidump_machdep.c

414

pa = (((uint64_t)i * sizeof(*vm_page_dump) * NBBY) + bit) * PAGE_SIZE;

sys/platform/pc64/x86_64/minidump_machdep.c

415

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

sys/platform/pc64/x86_64/mp_flame.c

124

bot = (char *)td->td_kstack + PAGE_SIZE; /* skip guard */

sys/platform/pc64/x86_64/mp_machdep.c

214

boot_address -= PAGE_SIZE; /* not enough, lower by 4k */

sys/platform/pc64/x86_64/mp_machdep.c

216

mptramp_pagetables = boot_address - (PAGE_SIZE * 3);

sys/platform/pc64/x86_64/mp_machdep.c

415

pt3 = pt4 + (PAGE_SIZE) / sizeof(u_int64_t);

sys/platform/pc64/x86_64/mp_machdep.c

416

pt2 = pt3 + (PAGE_SIZE) / sizeof(u_int64_t);

sys/platform/pc64/x86_64/mp_machdep.c

421

pt4[i] = (u_int64_t)(uintptr_t)(mptramp_pagetables + PAGE_SIZE);

sys/platform/pc64/x86_64/mp_machdep.c

427

pt3[i] = (u_int64_t)(uintptr_t)(mptramp_pagetables + (2 * PAGE_SIZE));

sys/platform/pc64/x86_64/mp_machdep.c

524

bootSTK = &ps->idlestack[UPAGES * PAGE_SIZE - PAGE_SIZE];

sys/platform/pc64/x86_64/pmap.c

1199

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

sys/platform/pc64/x86_64/pmap.c

1496

if (vmstats.v_page_count < 7LL * 1024 * 1024 * 1024 / PAGE_SIZE)

sys/platform/pc64/x86_64/pmap.c

1558

bzero(iso_pmap.pm_pml4, PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

1633

va += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2058

va += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2059

start += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2080

if (count >= PMAP_CLFLUSH_THRESHOLD / PAGE_SIZE ||

sys/platform/pc64/x86_64/pmap.c

2087

eva = daddr + PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2138

end_va = beg_va + count * PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2140

for (va = beg_va; va < end_va; va += PAGE_SIZE) {

sys/platform/pc64/x86_64/pmap.c

2182

end_va = beg_va + count * PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2184

for (va = beg_va; va < end_va; va += PAGE_SIZE) {

sys/platform/pc64/x86_64/pmap.c

2205

end_va = beg_va + count * PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2207

for (va = beg_va; va < end_va; va += PAGE_SIZE) {

sys/platform/pc64/x86_64/pmap.c

2230

end_va = beg_va + count * PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

2232

for (va = beg_va; va < end_va; va += PAGE_SIZE) {

sys/platform/pc64/x86_64/pmap.c

2371

PAGE_SIZE * 2,

sys/platform/pc64/x86_64/pmap.c

2373

pmap->pm_pml4_iso = (void *)((char *)pmap->pm_pml4 + PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

2498

(vm_offset_t)pmap->pm_pml4, PAGE_SIZE * 2);

sys/platform/pc64/x86_64/pmap.c

2576

bzero(pmap->pm_pml4, PAGE_SIZE * 2);

sys/platform/pc64/x86_64/pmap.c

2578

bzero(pmap->pm_pml4, PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

2612

bzero(pmap->pm_pml4, PAGE_SIZE * 2);

sys/platform/pc64/x86_64/pmap.c

2614

bzero(pmap->pm_pml4, PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

3350

kernel_vm_end = (kernel_vm_end + PAGE_SIZE * NPTEPG) &

sys/platform/pc64/x86_64/pmap.c

3351

~(vm_offset_t)(PAGE_SIZE * NPTEPG - 1);

sys/platform/pc64/x86_64/pmap.c

3373

kstart = rounddown2(kstart, (vm_offset_t)(PAGE_SIZE * NPTEPG));

sys/platform/pc64/x86_64/pmap.c

3374

kend = roundup2(kend, (vm_offset_t)(PAGE_SIZE * NPTEPG));

sys/platform/pc64/x86_64/pmap.c

3413

kstart = (kstart + PAGE_SIZE * NPTEPG) &

sys/platform/pc64/x86_64/pmap.c

3414

~(vm_offset_t)(PAGE_SIZE * NPTEPG - 1);

sys/platform/pc64/x86_64/pmap.c

3443

kstart = (kstart + PAGE_SIZE * NPTEPG) &

sys/platform/pc64/x86_64/pmap.c

3444

~(vm_offset_t)(PAGE_SIZE * NPTEPG - 1);

sys/platform/pc64/x86_64/pmap.c

4156

if (info->sva + PAGE_SIZE == info->eva) {

sys/platform/pc64/x86_64/pmap.c

4250

info->eva_pd_pindex = pmap_pd_pindex(info->eva - PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

4521

sva += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

4564

sva += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

4645

sva += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

4683

sva += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

5351

pmap_kenter_quick((vm_offset_t)crashdumpmap + (i * PAGE_SIZE), pa);

sys/platform/pc64/x86_64/pmap.c

5578

*pva = va + PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

5699

bcopy((void *)src_virt, (void *)dst_virt, PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

6199

size = roundup(offset + size, PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

6201

va = kmem_alloc_nofault(kernel_map, size, VM_SUBSYS_MAPDEV, PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

6212

tmpsize -= PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

6213

tmpva += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

6214

pa += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

6229

size = roundup(offset + size, PAGE_SIZE);

sys/platform/pc64/x86_64/pmap.c

6283

count -= NBPDR / PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

6294

va += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap.c

848

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

sys/platform/pc64/x86_64/pmap.c

849

*firstaddr += n * PAGE_SIZE;

sys/platform/pc64/x86_64/pmap_inval.c

313

va += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap_inval.c

613

bulk->va_end = va + PAGE_SIZE;

sys/platform/pc64/x86_64/pmap_inval.c

615

bulk->va_end = va + PAGE_SIZE;

sys/platform/pc64/x86_64/pmap_inval.c

627

bulk->va_end = va + PAGE_SIZE;

sys/platform/pc64/x86_64/pmap_inval.c

761

va += PAGE_SIZE;

sys/platform/pc64/x86_64/pmap_inval.c

843

va += PAGE_SIZE;

sys/platform/pc64/x86_64/trap.c

1119

(char *)rptr < td->td_kstack + PAGE_SIZE) {

sys/platform/pc64/x86_64/trap.c

1133

frame->tf_rsp = (register_t)(td->td_kstack + PAGE_SIZE);

sys/platform/pc64/x86_64/trap.c

1135

frame->tf_rbp = (register_t)(td->td_kstack + PAGE_SIZE);

sys/platform/pc64/x86_64/vm_machdep.c

1284

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

sys/platform/pc64/x86_64/vm_machdep.c

372

bzero((caddr_t) PTD, PAGE_SIZE);

sys/platform/vkernel64/include/globaldata.h

104

((sizeof(struct mdglobaldata) + MDGLOBALDATA_PAD + PAGE_SIZE * 4 + \

sys/platform/vkernel64/include/globaldata.h

105

UPAGES * PAGE_SIZE) % SEG_SIZE)) \

sys/platform/vkernel64/include/globaldata.h

113

char idlestack[UPAGES * PAGE_SIZE];

sys/platform/vkernel64/include/globaldata.h

89

(MDGLOBALDATA_BASEALLOC_SIZE / PAGE_SIZE)

sys/platform/vkernel64/include/md_var.h

55

#define pagezero(addr) bzero((addr), PAGE_SIZE)

sys/platform/vkernel64/include/vmparam.h

82

#define KERNEL_STACK_SIZE (512 * PAGE_SIZE)

sys/platform/vkernel64/platform/busdma_machdep.c

1047

bpage->vaddr = (vm_offset_t)contigmalloc(PAGE_SIZE, M_DEVBUF,

sys/platform/vkernel64/platform/busdma_machdep.c

217

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

sys/platform/vkernel64/platform/busdma_machdep.c

218

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

sys/platform/vkernel64/platform/busdma_machdep.c

564

vaddr += (PAGE_SIZE - (vaddr & PAGE_MASK));

sys/platform/vkernel64/platform/busdma_machdep.c

614

size = PAGE_SIZE - (paddr & PAGE_MASK);

sys/platform/vkernel64/platform/busdma_machdep.c

79

((dmat)->maxsize <= PAGE_SIZE && \

sys/platform/vkernel64/platform/busdma_machdep.c

80

(dmat)->alignment <= PAGE_SIZE && \

sys/platform/vkernel64/platform/copyio.c

133

if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))

sys/platform/vkernel64/platform/copyio.c

165

if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))

sys/platform/vkernel64/platform/copyio.c

197

if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))

sys/platform/vkernel64/platform/copyio.c

229

if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))

sys/platform/vkernel64/platform/copyio.c

283

n = PAGE_SIZE - ((vm_offset_t)uptr & PAGE_MASK);

sys/platform/vkernel64/platform/copyio.c

328

n = PAGE_SIZE - ((vm_offset_t)udaddr & PAGE_MASK);

sys/platform/vkernel64/platform/copyio.c

369

n = PAGE_SIZE - ((vm_offset_t)udaddr & PAGE_MASK);

sys/platform/vkernel64/platform/copyio.c

58

if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))

sys/platform/vkernel64/platform/copyio.c

96

if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(u_int))

sys/platform/vkernel64/platform/init.c

1527

xtra = (PAGE_SIZE - (vm_offset_t)sbrk(0)) & PAGE_MASK;

sys/platform/vkernel64/platform/init.c

682

virtual_start += PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

683

phys_avail[0].phys_beg += PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

690

virtual_start += MAXDUMPPGS * PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

699

virtual_start += PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

700

phys_avail[0].phys_beg += PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

708

virtual_start += PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

737

for (i = 0; i < sizeof(struct mdglobaldata); i += PAGE_SIZE) {

sys/platform/vkernel64/platform/init.c

741

phys_avail[0].phys_beg += PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

743

for (i = 0; i < sizeof(CPU_prvspace[0].idlestack); i += PAGE_SIZE) {

sys/platform/vkernel64/platform/init.c

747

phys_avail[0].phys_beg += PAGE_SIZE;

sys/platform/vkernel64/platform/init.c

814

phys_avail[0].phys_beg) / PAGE_SIZE);

sys/platform/vkernel64/platform/init.c

820

for (off = 0; off < round_page(MSGBUF_SIZE); off += PAGE_SIZE)

sys/platform/vkernel64/platform/pmap.c

1174

kmem_alloc_pageable(kernel_map, PAGE_SIZE,

sys/platform/vkernel64/platform/pmap.c

1236

kmem_free(kernel_map, (vm_offset_t)pmap->pm_pml4, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

1358

bzero(pmap->pm_pml4, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

1568

rounddown2(kernel_vm_end + PAGE_SIZE * NPTEPG,

sys/platform/vkernel64/platform/pmap.c

1569

PAGE_SIZE * NPTEPG);

sys/platform/vkernel64/platform/pmap.c

1577

addr = roundup2(addr, PAGE_SIZE * NPTEPG);

sys/platform/vkernel64/platform/pmap.c

1604

rounddown2(kernel_vm_end + PAGE_SIZE * NPTEPG,

sys/platform/vkernel64/platform/pmap.c

1605

PAGE_SIZE * NPTEPG);

sys/platform/vkernel64/platform/pmap.c

1634

rounddown2(kernel_vm_end + PAGE_SIZE * NPTEPG,

sys/platform/vkernel64/platform/pmap.c

1635

PAGE_SIZE * NPTEPG);

sys/platform/vkernel64/platform/pmap.c

1950

if (sva + PAGE_SIZE == eva) {

sys/platform/vkernel64/platform/pmap.c

2000

-NBPDR / PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

2017

sva += PAGE_SIZE) {

sys/platform/vkernel64/platform/pmap.c

2244

-NBPDR / PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

2261

sva += PAGE_SIZE) {

sys/platform/vkernel64/platform/pmap.c

2470

pmap_kenter_quick(crashdumpmap + (i * PAGE_SIZE), pa);

sys/platform/vkernel64/platform/pmap.c

2629

*pva += PAGE_SIZE;

sys/platform/vkernel64/platform/pmap.c

2701

bzero((void *)va, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

2734

bcopy((void *)src_virt, (void *)dst_virt, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

2974

pv->pv_va + PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

3374

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

sys/platform/vkernel64/platform/pmap.c

338

va = va + PAGE_SIZE;

sys/platform/vkernel64/platform/pmap.c

3392

sva += PAGE_SIZE) {

sys/platform/vkernel64/platform/pmap.c

375

if (PAGE_SIZE - (va & PAGE_MASK) < sizeof(u_int))

sys/platform/vkernel64/platform/pmap.c

401

*firstaddr += n * PAGE_SIZE;

sys/platform/vkernel64/platform/pmap.c

438

bzero(KPML4virt, 1 * PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

439

bzero(KPDPvirt, NKPML4E * PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

440

bzero(KPDvirt, NKPDPE * PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

441

bzero(KPTvirt, nkpt * PAGE_SIZE);

sys/platform/vkernel64/platform/pmap.c

524

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

sys/platform/vkernel64/platform/pmap.c

915

end_va = beg_va + count * PAGE_SIZE;

sys/platform/vkernel64/platform/pmap.c

918

for (va = beg_va; va < end_va; va += PAGE_SIZE) {

sys/platform/vkernel64/platform/pmap.c

952

end_va = beg_va + count * PAGE_SIZE;

sys/platform/vkernel64/platform/pmap.c

955

for (va = beg_va; va < end_va; va += PAGE_SIZE) {

sys/platform/vkernel64/platform/pmap_inval.c

106

pmap_inval_cpu(pmap, va, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap_inval.c

117

pmap_inval_cpu(pmap, va, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap_inval.c

217

pmap_inval_cpu(pmap, va, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap_inval.c

249

pmap_inval_cpu(pmap, va, PAGE_SIZE);

sys/platform/vkernel64/platform/pmap_inval.c

256

madvise(addr, PAGE_SIZE, MADV_INVAL);

sys/platform/vkernel64/x86_64/autoconf.c

140

long kbytes = physmem * (PAGE_SIZE / 1024); /* physmem */

sys/platform/vkernel64/x86_64/db_trace.c

227

if ((unsigned long)*fp < PAGE_SIZE) {

sys/platform/vkernel64/x86_64/mp.c

409

for (i = 0; i < sizeof(struct mdglobaldata); i += PAGE_SIZE) {

sys/platform/vkernel64/x86_64/mp.c

415

for (i = 0; i < sizeof(CPU_prvspace[x].idlestack); i += PAGE_SIZE) {

sys/platform/vkernel64/x86_64/mp.c

451

bootSTK = &ps->idlestack[UPAGES*PAGE_SIZE/2];

sys/platform/vkernel64/x86_64/vm_machdep.c

322

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

sys/sys/param.h

452

#define MAXALLOCSAVE (2 * PAGE_SIZE)

sys/sys/param.h

474

#define MJUMPAGESIZE PAGE_SIZE /* jumbo cluster 4k */

sys/sys/shm.h

48

#define SHMLBA PAGE_SIZE /* Segment low boundary address multiple */

sys/sys/thread.h

472

#define LWKT_THREAD_STACK (UPAGES * PAGE_SIZE)

sys/sys/vkernel.h

143

#define VPTE_PAGE_ENTRIES (PAGE_SIZE / sizeof(vpte_t))

sys/sys/vkernel.h

145

#define VPTE_PAGETABLE_SIZE PAGE_SIZE

sys/sys/xio.h

67

#define XIO_INTERNAL_SIZE (XIO_INTERNAL_PAGES * PAGE_SIZE)

sys/vfs/devfs/devfs_vnops.c

1050

vinitvmio(vp, IDX_TO_OFF(INT_MAX), PAGE_SIZE, -1);

sys/vfs/devfs/devfs_vnops.c

1469

sb->st_blksize = PAGE_SIZE;

sys/vfs/devfs/devfs_vnops.c

2120

pcount = round_page(ap->a_count) / PAGE_SIZE;

sys/vfs/devfs/devfs_vnops.c

2198

nextoff = toff + PAGE_SIZE;

sys/vfs/ext2fs/ext2_vnops.c

1173

vinitvmio(tvp, 0, PAGE_SIZE, -1);

sys/vfs/ext2fs/ext2_vnops.c

1332

vinitvmio(vp, 0, PAGE_SIZE, -1);

sys/vfs/ext2fs/ext2_vnops.c

1650

*ap->a_retval = PAGE_SIZE;

sys/vfs/ext2fs/ext2_vnops.c

1686

vinitvmio(vp, ip->i_size, PAGE_SIZE, -1); /* XXX */

sys/vfs/ext2fs/ext2_vnops.c

1691

vinitvmio(vp, ip->i_size, PAGE_SIZE, -1);

sys/vfs/ext2fs/ext2_vnops.c

1775

vinitvmio(tvp, 0, PAGE_SIZE, -1);

sys/vfs/fuse/fuse.h

68

#define FUSE_BLKSIZE PAGE_SIZE

sys/vfs/fuse/fuse_util.c

106

res = (len <= PAGE_SIZE);

sys/vfs/hammer/hammer_blockmap.c

603

if (!vm_paging_min_dnc(HAMMER_BUFSIZE / PAGE_SIZE)) {

sys/vfs/isofs/cd9660/cd9660_vfsops.c

894

vinitvmio(vp, ip->i_size, PAGE_SIZE, -1);

sys/vfs/mfs/mfs_vfsops.c

554

int n = PAGE_SIZE - ((vm_offset_t)base & PAGE_MASK);

sys/vfs/msdosfs/msdosfs_denode.c

420

vinitvmio(nvp, ldep->de_FileSize, PAGE_SIZE, -1);

sys/vfs/msdosfs/msdosfs_vfsops.c

495

pmp->pm_fatblocksize = PAGE_SIZE;

sys/vfs/nfs/nfs_serv.c

3663

vm_object_page_clean(vp->v_object, off / PAGE_SIZE,

sys/vfs/nfs/nfs_serv.c

3664

(cnt + PAGE_MASK) / PAGE_SIZE, OBJPC_SYNC);

sys/vfs/nfs/nfs_subs.c

1424

vinitvmio(vp, 0, PAGE_SIZE, -1);

sys/vfs/nfs/nfs_vfsops.c

204

if (iosize < PAGE_SIZE)

sys/vfs/nfs/nfs_vfsops.c

205

iosize = PAGE_SIZE;

sys/vfs/nfs/nfs_vfsops.c

219

iosize = (iosize & ~PAGE_MASK) + PAGE_SIZE;

sys/vfs/ntfs/ntfs_subr.c

1001

vinitvmio(nvp, nfp->f_size, PAGE_SIZE, -1);

sys/vfs/ntfs/ntfs_vfsops.c

782

vinitvmio(vp, fp->f_size, PAGE_SIZE, -1);

sys/vfs/procfs/procfs_map.c

130

addr += PAGE_SIZE;

sys/vfs/procfs/procfs_mem.c

101

kva = kmem_alloc_pageable(kernel_map, PAGE_SIZE, VM_SUBSYS_PROC);

sys/vfs/procfs/procfs_mem.c

125

len = szmin(PAGE_SIZE - page_offset, uio->uio_resid);

sys/vfs/procfs/procfs_mem.c

161

kmem_free(kernel_map, kva, PAGE_SIZE);

sys/vfs/procfs/procfs_vfsops.c

130

sbp->f_bsize = PAGE_SIZE;

sys/vfs/procfs/procfs_vfsops.c

131

sbp->f_iosize = PAGE_SIZE;

sys/vfs/procfs/procfs_vnops.c

558

vap->va_blocksize = PAGE_SIZE;

sys/vfs/smbfs/smbfs_io.c

481

nextoff = toff + PAGE_SIZE;

sys/vfs/smbfs/smbfs_io.c

618

int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE;

sys/vfs/tmpfs/tmpfs_subr.c

1003

oldpages = round_page64(oldsize) / PAGE_SIZE;

sys/vfs/tmpfs/tmpfs_subr.c

1005

newpages = round_page64(newsize) / PAGE_SIZE;

sys/vfs/tmpfs/tmpfs_subr.c

1076

nblksize += PAGE_SIZE;

sys/vfs/tmpfs/tmpfs_vfsops.c

161

} else if (size_max < PAGE_SIZE) {

sys/vfs/tmpfs/tmpfs_vfsops.c

176

nodes = 3 + pages * PAGE_SIZE / 1024;

sys/vfs/tmpfs/tmpfs_vfsops.c

483

sbp->f_iosize = PAGE_SIZE;

sys/vfs/tmpfs/tmpfs_vfsops.c

484

sbp->f_bsize = PAGE_SIZE;

sys/vfs/tmpfs/tmpfs_vfsops.c

83

node->tn_blksize = PAGE_SIZE; /* start small */

sys/vfs/tmpfs/tmpfs_vnops.c

1952

*retval = max(32, flsll(tmp->tm_pages_max * PAGE_SIZE) + 1);

sys/vfs/tmpfs/tmpfs_vnops.c

382

vap->va_blocksize = PAGE_SIZE;

sys/vfs/tmpfs/tmpfs_vnops.c

425

vap->va_blocksize = PAGE_SIZE;

sys/vfs/ufs/ffs_vfsops.c

755

if (maxfilesize > (uint64_t)0x80000000u * PAGE_SIZE - 1)

sys/vfs/ufs/ffs_vfsops.c

756

maxfilesize = (uint64_t)0x80000000u * PAGE_SIZE - 1;

sys/vfs/ufs/ufs_vnops.c

1573

vinitvmio(vp, 0, PAGE_SIZE, -1);

sys/vfs/ufs/ufs_vnops.c

2102

vinitvmio(tvp, 0, PAGE_SIZE, -1);

sys/vm/device_pager.c

328

for (off = foff; npages--; off += PAGE_SIZE) {

sys/vm/swap_pager.c

1034

count = howmany(bp->b_bcount, PAGE_SIZE);

sys/vm/swap_pager.c

1143

bzero(data, PAGE_SIZE);

sys/vm/swap_pager.c

1144

bp->b_resid -= PAGE_SIZE;

sys/vm/swap_pager.c

1161

bufx->b_bcount += PAGE_SIZE;

sys/vm/swap_pager.c

1165

data += PAGE_SIZE;

sys/vm/swap_pager.c

1454

bp->b_bcount = PAGE_SIZE * i;

sys/vm/swap_pager.c

1736

bp->b_bcount = PAGE_SIZE * n;

sys/vm/swap_pager.c

420

nsw_cluster_max = min((MAXPHYS/PAGE_SIZE), MAX_PAGEOUT_CLUSTER);

sys/vm/vm_contig.c

377

for (i = start + 1; i < (start + size / PAGE_SIZE); i++) {

sys/vm/vm_contig.c

381

(VM_PAGE_TO_PHYS(&m[-1]) + PAGE_SIZE)) ||

sys/vm/vm_contig.c

398

for (i = start; i < (start + size / PAGE_SIZE); i++) {

sys/vm/vm_contig.c

403

(i - start) * PAGE_SIZE);

sys/vm/vm_contig.c

423

(i - start) * PAGE_SIZE);

sys/vm/vm_contig.c

530

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

sys/vm/vm_contig.c

598

pmap_qremove((vm_offset_t)addr, size / PAGE_SIZE);

sys/vm/vm_fault.c

1454

(vaddr & ~PAGE_MASK) + PAGE_SIZE);

sys/vm/vm_fault.c

2623

start += PAGE_SIZE;

sys/vm/vm_fault.c

2631

for (va = start; va < end; va += PAGE_SIZE) {

sys/vm/vm_fault.c

2683

start += PAGE_SIZE;

sys/vm/vm_fault.c

2741

scan += PAGE_SIZE;

sys/vm/vm_fault.c

2757

scan += PAGE_SIZE;

sys/vm/vm_fault.c

2820

vaddr += PAGE_SIZE, dst_offset += PAGE_SIZE) {

sys/vm/vm_fault.c

2993

addr = addra - ((i + 1) >> 1) * PAGE_SIZE;

sys/vm/vm_fault.c

2997

addr = addra + ((i + 2) >> 1) * PAGE_SIZE;

sys/vm/vm_fault.c

3266

addr = addra - ((i + 1) >> 1) * PAGE_SIZE;

sys/vm/vm_fault.c

3270

addr = addra + ((i + 2) >> 1) * PAGE_SIZE;

sys/vm/vm_fault.c

3329

0, PAGE_SIZE);

sys/vm/vm_fault.c

550

vaddr < fs.entry->ba.start + PAGE_SIZE) {

sys/vm/vm_fault.c

710

vm_map_interlock(fs.map, &ilock, vaddr, vaddr + PAGE_SIZE);

sys/vm/vm_kern.c

114

npages = size / PAGE_SIZE;

sys/vm/vm_kern.c

124

PAGE_SIZE, TRUE,

sys/vm/vm_kern.c

173

PAGE_SIZE, TRUE,

sys/vm/vm_kern.c

228

gstart = PAGE_SIZE;

sys/vm/vm_kern.c

243

if (vm_map_findspace(map, vm_map_min(map), size, PAGE_SIZE, 0, &addr)) {

sys/vm/vm_kern.c

285

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

sys/vm/vm_kern.c

347

PAGE_SIZE, TRUE,

sys/vm/vm_kern.c

384

size, PAGE_SIZE, 0, &addr) == 0) {

sys/vm/vm_kern.c

428

if (vm_map_findspace(map, vm_map_min(map), size, PAGE_SIZE,

sys/vm/vm_kern.c

446

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

sys/vm/vm_kern.c

447

m = vm_page_alloc_contig(low, high, PAGE_SIZE, 0,

sys/vm/vm_kern.c

448

PAGE_SIZE, memattr);

sys/vm/vm_map.c

4173

grow_amount = roundup (stack_entry->ba.start - addr, PAGE_SIZE);

sys/vm/vm_map.c

4382

if ((flags & MAP_32BIT) && dsiz > PAGE_SIZE) {

sys/vm/vm_map.c

4383

dsiz = PAGE_SIZE;

sys/vm/vm_map.c

573

n = (cur->ba.end - cur->ba.start) / PAGE_SIZE;

sys/vm/vm_mmap.c

1291

align = PAGE_SIZE;

sys/vm/vm_mmap.c

947

addr += PAGE_SIZE;

sys/vm/vm_object.c

1994

(VM_PAGE_TO_PHYS(m) == pa + rcount * PAGE_SIZE)) {

sys/vm/vm_object.c

1999

padiff = pa + rcount * PAGE_SIZE - VM_PAGE_TO_PHYS(m);

sys/vm/vm_object.c

2003

pa = VM_PAGE_TO_PHYS(m) - rcount * PAGE_SIZE;

sys/vm/vm_page.c

220

vmstats.v_page_size = PAGE_SIZE;

sys/vm/vm_page.c

2789

if (high == BUS_SPACE_MAXADDR && alignment <= PAGE_SIZE &&

sys/vm/vm_page.c

2790

boundary <= PAGE_SIZE && size == 1 &&

sys/vm/vm_page.c

3912

base + size <= PAGE_SIZE,

sys/vm/vm_page.c

398

page_range = phys_avail[i].phys_end / PAGE_SIZE;

sys/vm/vm_page.c

4026

if (base == 0 && size == PAGE_SIZE) {

sys/vm/vm_page.c

4063

if (base == 0 && size == PAGE_SIZE) {

sys/vm/vm_page.c

410

first_page = phys_avail[0].phys_beg / PAGE_SIZE;

sys/vm/vm_page.c

411

page_range = phys_avail[i].phys_end / PAGE_SIZE - first_page;

sys/vm/vm_page.c

412

npages = (total - (page_range * sizeof(struct vm_page))) / PAGE_SIZE;

sys/vm/vm_page.c

4136

for (b = i = 0; i <= PAGE_SIZE / DEV_BSIZE; ++i) {

sys/vm/vm_page.c

4137

if (i == (PAGE_SIZE / DEV_BSIZE) ||

sys/vm/vm_page.c

456

pa += PAGE_SIZE) {

sys/vm/vm_page.c

476

pa += PAGE_SIZE;

sys/vm/vm_page.c

496

pa += PAGE_SIZE;

sys/vm/vm_page.c

599

scan_beg += PAGE_SIZE;

sys/vm/vm_page.c

782

if (bfree <= vm_dma_reserved / PAGE_SIZE)

sys/vm/vm_page.c

791

bfree -= vm_dma_reserved / PAGE_SIZE;

sys/vm/vm_page.c

845

(PAGE_SIZE / 1024),

sys/vm/vm_page.c

846

(intmax_t)vm_contig_alist.bl_free * (PAGE_SIZE / 1024));

sys/vm/vm_page.h

458

#if PAGE_SIZE == 4096

sys/vm/vm_page2.h

579

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

sys/vm/vm_pager.c

277

for (j = 0; j < MAXPHYS / PAGE_SIZE; ++j) {

sys/vm/vm_pager.c

284

pmap_kenter_noinval(pg * PAGE_SIZE, VM_PAGE_TO_PHYS(m));

sys/vm/vm_pager.c

285

cpu_invlpg((void *)(pg * PAGE_SIZE));

sys/vm/vm_swap.c

101

sz = howmany(bp->b_bcount, PAGE_SIZE);

sys/vm/vm_swap.c

620

xs.xsw_blksize = PAGE_SIZE;

sys/vm/vm_swapcache.c

649

vm_swapcache_write_count += count * PAGE_SIZE;

sys/vm/vm_swapcache.c

650

vm_swapcache_curburst -= count * PAGE_SIZE;

sys/vm/vm_swapcache.c

815

marker->save_off += n * PAGE_SIZE;

sys/vm/vm_unix.c

139

PAGE_SIZE, FALSE,

sys/vm/vm_unix.c

225

PAGE_SIZE, FALSE,

sys/vm/vm_zone.c

387

z->zpagemax = totsize / PAGE_SIZE;

sys/vm/vm_zone.c

412

if (z->zsize > PAGE_SIZE)

sys/vm/vm_zone.c

415

z->zfreemin = PAGE_SIZE / z->zsize;

sys/vm/vm_zone.c

536

(size_t)z->zalloc * PAGE_SIZE);

sys/vm/vm_zone.c

631

noffset = (size_t)z->zpagecount * PAGE_SIZE;

sys/vm/vm_zone.c

645

nitems = ((size_t)(savezpc + npages) * PAGE_SIZE - noffset) /

sys/vm/vm_zone.c

662

zkva = z->zkva + (size_t)(savezpc + i) * PAGE_SIZE;

sys/vm/vm_zone.c

664

bzero((void *)zkva, PAGE_SIZE);

sys/vm/vm_zone.c

678

nbytes = (size_t)z->zalloc * PAGE_SIZE;

sys/vm/vm_zone.c

696

nbytes = (size_t)z->zalloc * PAGE_SIZE;

sys/vm/vnode_pager.c

349

int size = PAGE_SIZE - base;

sys/vm/vnode_pager.c

444

rtval = VOP_GETPAGES(vp, mpp, PAGE_SIZE, 0, 0, seqaccess);

sys/vm/vnode_pager.c

484

count = bytecount / PAGE_SIZE;

sys/vm/vnode_pager.c

515

i = round_page(bytecount) / PAGE_SIZE;

sys/vm/vnode_pager.c

533

KASSERT(secmask < PAGE_SIZE, ("vnode_pager_generic_getpages: sector size %d too large", secmask + 1));

sys/vm/vnode_pager.c

638

int bytes = count * PAGE_SIZE;

sys/vm/vnode_pager.c

690

count = bytecount / PAGE_SIZE;

sys/vm/vnode_pager.c

702

maxsize = count * PAGE_SIZE;

test/debug/buserr.c

29

size = PAGE_SIZE * i;

test/debug/buserr.c

44

if (munmap(mapping, PAGE_SIZE * i) != 0) {

test/debug/vmobjinfo.c

204

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

test/debug/vmobjinfo.c

243

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

test/debug/vmobjinfo.c

287

off = blkno * PAGE_SIZE;

test/debug/vmobjinfo.c

84

char pgbuf[PAGE_SIZE];

test/debug/vmpagehash.c

354

u_long addr = (m->pindex * PAGE_SIZE) & ~131071L;

test/debug/vmpageinfo.c

265

(intmax_t)m.pindex * PAGE_SIZE,

test/debug/vmpageinfo.c

542

u_long addr = (m->pindex * PAGE_SIZE) & ~131071L;

test/debug/vmpqinactive.c

284

(intmax_t)m.pindex * PAGE_SIZE,

test/debug/vmpqinactive.c

574

u_long addr = (m->pindex * PAGE_SIZE) & ~131071L;

test/nvmm/calc-vm.c

102

if (nvmm_hva_map(&mach, hva, PAGE_SIZE) == -1)

test/nvmm/calc-vm.c

107

if (nvmm_gpa_map(&mach, hva, gpa, PAGE_SIZE, PROT_READ|PROT_EXEC) == -1)

test/nvmm/calc-vm.c

98

hva = (uintptr_t)mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE,

test/nvmm/demo/smallkern/main.c

111

static uint8_t idtstore[PAGE_SIZE] __aligned(PAGE_SIZE);

test/nvmm/demo/smallkern/main.c

112

static uint8_t faultstack[PAGE_SIZE] __aligned(PAGE_SIZE);

test/nvmm/demo/smallkern/main.c

119

memset(&idtstore, 0, PAGE_SIZE);

test/nvmm/demo/smallkern/main.c

220

smallkern_tss.tss_ist[0] = (uintptr_t)(&faultstack[PAGE_SIZE-1]) & ~0xf;

test/nvmm/demo/smallkern/main.c

222

smallkern_tss.tss_ist1 = (uintptr_t)(&faultstack[PAGE_SIZE-1]) & ~0xf;

test/nvmm/demo/smallkern/main.c

245

setregion(&region, &idtstore, PAGE_SIZE - 1);

test/nvmm/demo/smallkern/pdir.h

32

#ifndef PAGE_SIZE

test/nvmm/demo/toyvirt/elf.c

86

roundup(phdr[i].p_filesz, PAGE_SIZE));

test/nvmm/demo/toyvirt/elf.c

90

roundup(phdr[i].p_filesz, PAGE_SIZE);

test/nvmm/demo/toyvirt/elf.c

94

toyvirt_mem_add(mach, lastgpa, 128 * PAGE_SIZE);

test/sysperf/pipe2.c

10

#define PAGE_MASK (PAGE_SIZE - 1)

test/sysperf/pipe2.c

49

buf = mmap(NULL, bytes * 2 + PAGE_SIZE,

test/sysperf/pipe2.c

56

bzero(buf, bytes * 2 + PAGE_SIZE);

test/sysperf/socketpair.c

11

#define PAGE_MASK (PAGE_SIZE - 1)

test/sysperf/socketpair.c

50

buf = mmap(NULL, bytes * 2 + PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);

test/sysperf/socketpair.c

56

bzero(buf, bytes * 2 + PAGE_SIZE);

test/testcases/libnvmm/h_io_assist.c

140

instbuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_io_assist.c

144

databuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_io_assist.c

149

if (nvmm_hva_map(mach, (uintptr_t)instbuf, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_io_assist.c

151

if (nvmm_hva_map(mach, (uintptr_t)databuf, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_io_assist.c

153

ret = nvmm_gpa_map(mach, (uintptr_t)instbuf, 0x2000, PAGE_SIZE,

test/testcases/libnvmm/h_io_assist.c

157

ret = nvmm_gpa_map(mach, (uintptr_t)databuf, 0x1000, PAGE_SIZE,

test/testcases/libnvmm/h_io_assist.c

162

L4 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_io_assist.c

166

L3 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_io_assist.c

170

L2 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_io_assist.c

174

L1 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_io_assist.c

179

if (nvmm_hva_map(mach, (uintptr_t)L4, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_io_assist.c

181

if (nvmm_hva_map(mach, (uintptr_t)L3, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_io_assist.c

183

if (nvmm_hva_map(mach, (uintptr_t)L2, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_io_assist.c

185

if (nvmm_hva_map(mach, (uintptr_t)L1, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_io_assist.c

188

ret = nvmm_gpa_map(mach, (uintptr_t)L4, 0x3000, PAGE_SIZE,

test/testcases/libnvmm/h_io_assist.c

192

ret = nvmm_gpa_map(mach, (uintptr_t)L3, 0x4000, PAGE_SIZE,

test/testcases/libnvmm/h_io_assist.c

196

ret = nvmm_gpa_map(mach, (uintptr_t)L2, 0x5000, PAGE_SIZE,

test/testcases/libnvmm/h_io_assist.c

200

ret = nvmm_gpa_map(mach, (uintptr_t)L1, 0x6000, PAGE_SIZE,

test/testcases/libnvmm/h_io_assist.c

205

memset(L4, 0, PAGE_SIZE);

test/testcases/libnvmm/h_io_assist.c

206

memset(L3, 0, PAGE_SIZE);

test/testcases/libnvmm/h_io_assist.c

207

memset(L2, 0, PAGE_SIZE);

test/testcases/libnvmm/h_io_assist.c

208

memset(L1, 0, PAGE_SIZE);

test/testcases/libnvmm/h_io_assist.c

213

L1[0x2000 / PAGE_SIZE] = PTE_P | PTE_W | 0x2000;

test/testcases/libnvmm/h_io_assist.c

214

L1[0x1000 / PAGE_SIZE] = PTE_P | PTE_W | 0x1000;

test/testcases/libnvmm/h_io_assist.c

306

memset(databuf, 0, PAGE_SIZE);

test/testcases/libnvmm/h_mem_assist.c

154

memset(mmiobuf, 0, PAGE_SIZE);

test/testcases/libnvmm/h_mem_assist.c

292

instbuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_mem_assist.c

297

if (nvmm_hva_map(mach, (uintptr_t)instbuf, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_mem_assist.c

299

ret = nvmm_gpa_map(mach, (uintptr_t)instbuf, 0x2000, PAGE_SIZE,

test/testcases/libnvmm/h_mem_assist.c

304

L4 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_mem_assist.c

308

L3 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_mem_assist.c

312

L2 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_mem_assist.c

316

L1 = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_mem_assist.c

321

if (nvmm_hva_map(mach, (uintptr_t)L4, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_mem_assist.c

323

if (nvmm_hva_map(mach, (uintptr_t)L3, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_mem_assist.c

325

if (nvmm_hva_map(mach, (uintptr_t)L2, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_mem_assist.c

327

if (nvmm_hva_map(mach, (uintptr_t)L1, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_mem_assist.c

330

ret = nvmm_gpa_map(mach, (uintptr_t)L4, 0x3000, PAGE_SIZE,

test/testcases/libnvmm/h_mem_assist.c

334

ret = nvmm_gpa_map(mach, (uintptr_t)L3, 0x4000, PAGE_SIZE,

test/testcases/libnvmm/h_mem_assist.c

338

ret = nvmm_gpa_map(mach, (uintptr_t)L2, 0x5000, PAGE_SIZE,

test/testcases/libnvmm/h_mem_assist.c

342

ret = nvmm_gpa_map(mach, (uintptr_t)L1, 0x6000, PAGE_SIZE,

test/testcases/libnvmm/h_mem_assist.c

347

memset(L4, 0, PAGE_SIZE);

test/testcases/libnvmm/h_mem_assist.c

348

memset(L3, 0, PAGE_SIZE);

test/testcases/libnvmm/h_mem_assist.c

349

memset(L2, 0, PAGE_SIZE);

test/testcases/libnvmm/h_mem_assist.c

350

memset(L1, 0, PAGE_SIZE);

test/testcases/libnvmm/h_mem_assist.c

355

L1[0x2000 / PAGE_SIZE] = PTE_P | PTE_W | 0x2000;

test/testcases/libnvmm/h_mem_assist.c

356

L1[0x1000 / PAGE_SIZE] = PTE_P | PTE_W | 0x1000;

test/testcases/libnvmm/h_mem_assist.c

438

instbuf = mmap(NULL, PAGE_SIZE, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE,

test/testcases/libnvmm/h_mem_assist.c

443

if (nvmm_hva_map(mach, (uintptr_t)instbuf, PAGE_SIZE) == -1)

test/testcases/libnvmm/h_mem_assist.c

445

ret = nvmm_gpa_map(mach, (uintptr_t)instbuf, 0x2000, PAGE_SIZE,

test/testcases/libnvmm/h_mem_assist.c

59

static uint8_t mmiobuf[PAGE_SIZE];

test/testcases/libnvmm/h_mem_assist.c

69

if (mem->gpa < 0x1000 || mem->gpa + mem->size > 0x1000 + PAGE_SIZE) {

usr.bin/gcore/elfcore.c

180

phdr->p_align = PAGE_SIZE;

usr.bin/systat/vmstat.c

431

put64((int64_t)((float)s.fld/etime + 0.5) * PAGE_SIZE, l, c, w, 0)