headers/build/private/app/MessagePrivate.h

19

#define MAX_DATA_PREALLOCATION B_PAGE_SIZE * 10

headers/private/app/MessagePrivate.h

19

#define MAX_DATA_PREALLOCATION B_PAGE_SIZE * 10

headers/private/debugger/model/TeamMemoryBlock.h

59

uint8 fData[B_PAGE_SIZE];

headers/private/drivers/ata_adapter.h

62

#define ATA_ADAPTER_MAX_SG_COUNT (B_PAGE_SIZE / sizeof( prd_entry ))

headers/private/fs_shell/fssh_kernel_priv.h

32

# define KERNEL_STACK_SIZE (B_PAGE_SIZE * 2) // 8 kB

headers/private/fs_shell/fssh_kernel_priv.h

34

# define KERNEL_STACK_SIZE (B_PAGE_SIZE * 3) // 8 kB + one guard page

headers/private/fs_shell/fssh_kernel_priv.h

44

#define ENV_SIZE (B_PAGE_SIZE * 8)

headers/private/graphics/intel_extreme/utility.h

11

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

headers/private/graphics/radeon_hd/utility.h

12

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

headers/private/graphics/vesa/utility.h

8

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

headers/private/interface/DirectWindowPrivate.h

12

#define DIRECT_BUFFER_INFO_AREA_SIZE B_PAGE_SIZE

headers/private/kernel/arch/cpu.h

15

#define PAGE_ALIGN(x) (((x) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1))

headers/private/kernel/arch/m68k/arch_030_mmu.h

139

#define NUM_DIRTBL_PER_PAGE (B_PAGE_SIZE / SIZ_DIRTBL)

headers/private/kernel/arch/m68k/arch_030_mmu.h

140

#define NUM_PAGETBL_PER_PAGE (B_PAGE_SIZE / SIZ_PAGETBL)

headers/private/kernel/arch/m68k/arch_030_mmu.h

198

#define VADDR_TO_PRENT(va) (((va) / B_PAGE_SIZE) / (64*128))

headers/private/kernel/arch/m68k/arch_030_mmu.h

199

#define VADDR_TO_PDENT(va) ((((va) / B_PAGE_SIZE) / 64) % 128)

headers/private/kernel/arch/m68k/arch_030_mmu.h

200

#define VADDR_TO_PTENT(va) (((va) / B_PAGE_SIZE) % 64)

headers/private/kernel/arch/m68k/arch_040_mmu.h

137

#define NUM_DIRTBL_PER_PAGE (B_PAGE_SIZE / SIZ_DIRTBL)

headers/private/kernel/arch/m68k/arch_040_mmu.h

138

#define NUM_PAGETBL_PER_PAGE (B_PAGE_SIZE / SIZ_PAGETBL)

headers/private/kernel/arch/m68k/arch_040_mmu.h

183

#define VADDR_TO_PRENT(va) (((va) / B_PAGE_SIZE) / (64*128))

headers/private/kernel/arch/m68k/arch_040_mmu.h

184

#define VADDR_TO_PDENT(va) ((((va) / B_PAGE_SIZE) / 64) % 128)

headers/private/kernel/arch/m68k/arch_040_mmu.h

185

#define VADDR_TO_PTENT(va) (((va) / B_PAGE_SIZE) % 64)

headers/private/kernel/kernel.h

71

#define KERNEL_STACK_SIZE (B_PAGE_SIZE * 4) // 16 kB

headers/private/kernel/kernel.h

73

#define KERNEL_STACK_SIZE (B_PAGE_SIZE * 3) // 12 kB

headers/private/kernel/kernel.h

83

#define ENV_SIZE (B_PAGE_SIZE * 8)

headers/private/kernel/vm/VMCache.h

401

ASSERT_PRINT(fWiredCount > 0, "page: %#" B_PRIx64, physical_page_number * B_PAGE_SIZE);

headers/private/kernel/vm/VMTranslationMap.h

155

return Protect(address, address + B_PAGE_SIZE - 1, attributes,

headers/private/kernel/vm/vm.h

46

#define VM_MEMORY_RESERVE_USER (VM_PAGE_RESERVE_USER * B_PAGE_SIZE)

headers/private/kernel/vm/vm.h

47

#define VM_MEMORY_RESERVE_SYSTEM (VM_PAGE_RESERVE_SYSTEM * B_PAGE_SIZE)

headers/private/kernel/vm/vm_types.h

238

page->physical_page_number * B_PAGE_SIZE, previousThread, page, previousThread);

headers/private/kernel/vm/vm_types.h

252

"sc %" B_PRId32 "; cache _cache", page->physical_page_number * B_PAGE_SIZE,

headers/private/kernel/vm/vm_types.h

265

page->physical_page_number * B_PAGE_SIZE, thread, page, thread);

headers/private/media/MediaMisc.h

42

#define ROUND_UP_TO_PAGE(size) (((size) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1))

headers/private/system/thread_defs.h

15

#define USER_STACK_GUARD_SIZE (4 * B_PAGE_SIZE) // 16 kB

headers/private/system/thread_defs.h

16

#define MIN_USER_STACK_SIZE (2 * B_PAGE_SIZE) // 8 kB

headers/private/system/thread_defs.h

17

#define MAX_USER_STACK_SIZE (4096 * B_PAGE_SIZE) // 16 MB

headers/private/system/thread_defs.h

19

#define USER_STACK_SIZE (64 * B_PAGE_SIZE) // 256 kB

src/add-ons/accelerants/common/create_display_modes.cpp

521

size_t size = (sizeof(display_mode) * modes.Count() + B_PAGE_SIZE - 1)

src/add-ons/accelerants/common/create_display_modes.cpp

522

& ~(B_PAGE_SIZE - 1);

src/add-ons/accelerants/et6x00/ProposeDisplayMode.c

99

maxSize = (((MODE_COUNT * 3) * sizeof(display_mode)) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/accelerants/intel_extreme/engine.cpp

184

((ringBuffer.size - B_PAGE_SIZE) & INTEL_RING_BUFFER_SIZE_MASK)

src/add-ons/accelerants/matrox/ProposeDisplayMode.c

488

max_size = (((MODE_COUNT * 4) * sizeof(display_mode)) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/accelerants/neomagic/ProposeDisplayMode.c

356

max_size = (((MODE_COUNT * 4) * sizeof(display_mode)) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/accelerants/nvidia/ProposeDisplayMode.c

630

max_size = (((MODE_COUNT * 4 * 3) * sizeof(display_mode)) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/accelerants/radeon/ProposeDisplayMode.c

600

max_size = (max_num_modes * sizeof(display_mode) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/accelerants/skeleton/ProposeDisplayMode.c

538

max_size = (((MODE_COUNT * 4) * sizeof(display_mode)) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/accelerants/via/ProposeDisplayMode.c

540

max_size = (((MODE_COUNT * 4) * sizeof(display_mode)) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

100

{ return (memory->base - fInfo.base) / B_PAGE_SIZE; }

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

1040

size = ROUNDUP(size, B_PAGE_SIZE);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

1059

= (phys_addr_t)memory->page->physical_page_number * B_PAGE_SIZE;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

1062

status = get_memory_map((void *)memory->base, B_PAGE_SIZE, &entry, 1);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

1126

|| (base & (B_PAGE_SIZE - 1)) != 0

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

1130

size = ROUNDUP(size, B_PAGE_SIZE);

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

535

uint32 count = size / B_PAGE_SIZE;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

622

for (addr_t offset = 0; offset < memory->size; offset += B_PAGE_SIZE) {

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

661

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

667

status = get_memory_map((void *)(address + offset), B_PAGE_SIZE,

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

715

uint32 count = size / B_PAGE_SIZE;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

777

if (alignment < B_PAGE_SIZE)

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

778

alignment = B_PAGE_SIZE;

src/add-ons/kernel/bus_managers/agp_gart/agp_gart.cpp

98

{ return (base - fInfo.base) / B_PAGE_SIZE; }

src/add-ons/kernel/bus_managers/ata/ATAChannel.cpp

1018

ASSERT(physicalAddress % B_PAGE_SIZE == virtualAddress % B_PAGE_SIZE);

src/add-ons/kernel/bus_managers/ata/ATAChannel.cpp

1022

size_t pageLeft = B_PAGE_SIZE - physicalAddress % B_PAGE_SIZE;

src/add-ons/kernel/bus_managers/firewire/fwdma.cpp

152

if (esize > B_PAGE_SIZE) {

src/add-ons/kernel/bus_managers/firewire/fwdma.cpp

154

esize = ssize = roundup2(esize, B_PAGE_SIZE);

src/add-ons/kernel/bus_managers/firewire/fwdma.cpp

161

ssize = rounddown(B_PAGE_SIZE, esize);

src/add-ons/kernel/bus_managers/firewire/fwohci.cpp

625

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

src/add-ons/kernel/bus_managers/firewire/fwohci.cpp

626

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

src/add-ons/kernel/bus_managers/firewire/fwohci.cpp

627

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

src/add-ons/kernel/bus_managers/firewire/fwohci.cpp

628

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

src/add-ons/kernel/bus_managers/firewire/util.c

32

return (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/firewire/util.c

86

offset = (intptr_t)phy & (B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/scsi/busses.cpp

218

if (bus->dma_params.alignment > B_PAGE_SIZE) {

src/add-ons/kernel/bus_managers/scsi/busses.cpp

232

if (bus->dma_params.dma_boundary < B_PAGE_SIZE - 1) {

src/add-ons/kernel/bus_managers/scsi/devices.cpp

218

total_size = (total_size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/scsi/devices.cpp

222

B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_32_BIT_FULL_LOCK,

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

169

size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

173

if (size / B_PAGE_SIZE > dma_params->max_sg_blocks

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

174

|| size / B_PAGE_SIZE > MAX_TEMP_SG_FRAGMENTS) {

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

230

size_t sg_list_size = buffer->size / B_PAGE_SIZE * sizeof( physical_entry );

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

232

sg_list_size = (sg_list_size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/scsi/dma_buffer.cpp

292

size = (size * sizeof(physical_entry) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

68

total_size = (buffer_size + sizeof(physical_entry) + B_PAGE_SIZE - 1)

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

69

& ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/scsi/emulation.cpp

88

get_memory_map(address, B_PAGE_SIZE, map, 1);

src/add-ons/kernel/bus_managers/scsi/scsi_internal.h

38

#define MAX_TEMP_SG_FRAGMENTS (128*1024 / B_PAGE_SIZE + 1)

src/add-ons/kernel/bus_managers/usb/PhysicalMemoryAllocator.cpp

76

roundedSize = (roundedSize + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

315

size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/bus_managers/usb/Stack.cpp

52

8, B_PAGE_SIZE * 32, 64);

src/add-ons/kernel/bus_managers/usb/usbspec_private.h

18

#define USB_MAX_FRAGMENT_SIZE B_PAGE_SIZE * 96

src/add-ons/kernel/bus_managers/virtio/VirtioQueue.cpp

13

return (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

711

&scratchAddress, B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_FULL_LOCK,

src/add-ons/kernel/busses/agp_gart/intel_gart.cpp

719

if (get_memory_map(scratchAddress, B_PAGE_SIZE, &entry, 1) != B_OK)

src/add-ons/kernel/busses/ata/silicon_image_3112/silicon_image_3112.c

455

prdtSize = (ATA_ADAPTER_MAX_SG_COUNT * sizeof(prd_entry) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/busses/scsi/ahci/util.cpp

20

return (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/busses/scsi/ahci/util.cpp

70

offset = phy & (B_PAGE_SIZE - 1);

src/add-ons/kernel/busses/usb/ehci.cpp

1268

offset -= B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

1269

currentPhy += B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

2569

pagesCount += (transferVec[vecI].length + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

2574

&& ((transferVec[0].base + transferVec[0].length) % B_PAGE_SIZE) == 0;

src/add-ons/kernel/busses/usb/ehci.cpp

2578

&& (transferVec[vecI].base % B_PAGE_SIZE) == 0

src/add-ons/kernel/busses/usb/ehci.cpp

2579

&& (transferVec[vecI].length % B_PAGE_SIZE) == 0;

src/add-ons/kernel/busses/usb/ehci.cpp

2583

&& ((transferVec[vecI - 1].base) % B_PAGE_SIZE) == 0;

src/add-ons/kernel/busses/usb/ehci.cpp

2612

uint32 bufferLength = B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

2613

if ((current->buffer_phy[i] % B_PAGE_SIZE) != 0)

src/add-ons/kernel/busses/usb/ehci.cpp

2614

bufferLength -= (current->buffer_phy[i] % B_PAGE_SIZE);

src/add-ons/kernel/busses/usb/ehci.cpp

2689

physicalBase += B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

2703

size_t packetSize = B_PAGE_SIZE * 4;

src/add-ons/kernel/busses/usb/ehci.cpp

428

uint32 offset = fPCIInfo->u.h0.base_registers[0] & (B_PAGE_SIZE - 1);

src/add-ons/kernel/busses/usb/ehci.cpp

431

+ B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/busses/usb/ehci.cpp

616

/ (B_PAGE_SIZE / sizeof(itd_entry)) * B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

618

/ (B_PAGE_SIZE / sizeof(sitd_entry)) * B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

619

size_t frameListSize = B_PAGE_SIZE + B_PAGE_SIZE + itdListSize

src/add-ons/kernel/busses/usb/ehci.cpp

640

uint32_t physicalBase = physicalAddress + B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

641

uint8 *logicalBase = (uint8 *)fPeriodicFrameList + B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

642

memset(logicalBase, 0, B_PAGE_SIZE);

src/add-ons/kernel/busses/usb/ehci.cpp

670

uint32_t itdPhysicalBase = physicalAddress + B_PAGE_SIZE + B_PAGE_SIZE;

src/add-ons/kernel/busses/usb/ehci.cpp

671

itd_entry* itds = (itd_entry *)((uint8 *)fPeriodicFrameList + B_PAGE_SIZE

src/add-ons/kernel/busses/usb/ehci.cpp

672

+ B_PAGE_SIZE);

src/add-ons/kernel/busses/usb/ehci.cpp

676

sitd_entry* sitds = (sitd_entry *)((uint8 *)fPeriodicFrameList + B_PAGE_SIZE

src/add-ons/kernel/busses/usb/ehci.cpp

677

+ B_PAGE_SIZE + itdListSize);

src/add-ons/kernel/busses/usb/ohci.cpp

319

offset, B_PAGE_SIZE, B_ANY_KERNEL_BLOCK_ADDRESS,

src/add-ons/kernel/busses/usb/xhci.cpp

1408

if (totalSize < (32 * B_PAGE_SIZE)) {

src/add-ons/kernel/busses/usb/xhci.cpp

1467

if (totalSize < (32 * B_PAGE_SIZE)) {

src/add-ons/kernel/busses/usb/xhci.cpp

1596

ASSERT((((addr_t)device->input_ctx) % B_PAGE_SIZE) == 0);

src/add-ons/kernel/busses/usb/xhci.cpp

3327

uint32 offset = p & ((B_PAGE_SIZE - 1) & ~31U);

src/add-ons/kernel/busses/usb/xhci.cpp

723

&scratchDmaAddress, B_PAGE_SIZE, "Scratchpad Area");

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

112

uint32_t pfn = pe.address / B_PAGE_SIZE;

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

113

fDev->fRegs->queueAlign = B_PAGE_SIZE;

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

60

queueMemSize += ROUNDUP(sizeof(VirtioDesc) * fDescCount, B_PAGE_SIZE);

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

63

queueMemSize += ROUNDUP(sizeof(VirtioAvail) + sizeof(uint16) * fQueueLen, B_PAGE_SIZE);

src/add-ons/kernel/busses/virtio/virtio_mmio/VirtioDevice.cpp

66

queueMemSize += ROUNDUP(sizeof(VirtioUsed) + sizeof(VirtioUsedItem) * fQueueLen, B_PAGE_SIZE);

src/add-ons/kernel/busses/virtio/virtio_mmio/virtio_mmio.cpp

391

dev->fRegs->guestPageSize = B_PAGE_SIZE;

src/add-ons/kernel/console/vga_text/vga_text.c

50

i += B_PAGE_SIZE) {

src/add-ons/kernel/cpu/x86/generic_x86.cpp

168

*_base = base & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/cpu/x86/generic_x86.cpp

169

*_length = (~mask & gPhysicalMask) + B_PAGE_SIZE;

src/add-ons/kernel/cpu/x86/generic_x86.cpp

222

gPhysicalMask = ((1ULL << bits) - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/cpu/x86/generic_x86.cpp

91

(base & ~(B_PAGE_SIZE - 1)) | type);

src/add-ons/kernel/cpu/x86/via.cpp

48

gPhysicalMask = ((1ULL << 36) - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/audio/ac97/geode/geode_controller.cpp

13

#define PAGE_ALIGN(size) (((size) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1))

src/add-ons/kernel/drivers/audio/ac97/sis7018/Stream.cpp

72

fBuffersAreaSize = (fBuffersAreaSize + (B_PAGE_SIZE - 1)) &~ (B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/audio/cmedia/cm.c

315

size_t low_size = (MIN_MEMORY_SIZE + (B_PAGE_SIZE - 1))

src/add-ons/kernel/drivers/audio/cmedia/cm.c

316

&~ (B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/audio/echo/generic/OsSupportBeOS.h

102

#define PAGE_SIZE B_PAGE_SIZE

src/add-ons/kernel/drivers/audio/generic/util.c

119

offset = (uint32)phy & (B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/audio/generic/util.c

62

return (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/audio/null/null_hardware.c

25

area_size = (area_size + B_PAGE_SIZE - 1) & (~(B_PAGE_SIZE -1));

src/add-ons/kernel/drivers/audio/usb/Stream.cpp

186

fAreaSize = (fAreaSize + (B_PAGE_SIZE - 1)) &~ (B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/bus/firewire/fw_raw.c

349

xfer->recv.pay_len = B_PAGE_SIZE;

src/add-ons/kernel/drivers/bus/firewire/fw_raw.c

488

B_PAGE_SIZE/*XXX*/)) == NULL)

src/add-ons/kernel/drivers/bus/firewire/fw_raw.c

766

xfer = gFirewire->fw_xfer_alloc_buf(pay_len, B_PAGE_SIZE/*XXX*/);

src/add-ons/kernel/drivers/bus/firewire/fw_raw.c

868

B_PAGE_SIZE, B_PAGE_SIZE, 5,

src/add-ons/kernel/drivers/disk/nvme/compat/libnvme_haiku.cpp

46

size = ROUNDUP(size, B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/nvme/compat/nvme_arch.h

19

#define PAGE_SIZE B_PAGE_SIZE

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

401

restrictions.alignment = B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

409

err = info->dma_resource.Init(restrictions, B_PAGE_SIZE, buffers, buffers);

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

752

const int32 vtophysLength = (request->Length() / B_PAGE_SIZE) + 2;

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

800

if ((nvme_request.iovecs[i].address % B_PAGE_SIZE) != 0)

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

802

if ((nvme_request.iovecs[i].size % B_PAGE_SIZE) != 0)

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

812

if (!bounceAll && (((entry->address + entry->size) % B_PAGE_SIZE) != 0

src/add-ons/kernel/drivers/disk/nvme/nvme_disk.cpp

817

if (!bounceAll && ((entry->address % B_PAGE_SIZE) != 0

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

106

size_t numBlocks = B_PAGE_SIZE / blockSize;

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

124

(kBufferSize - 1 + B_PAGE_SIZE) / B_PAGE_SIZE, VM_PRIORITY_SYSTEM);

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

128

size_t bytes = std::min(left, (size_t)B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

133

entries[numEntries].address = page->physical_page_number * B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

183

vm_page_free(NULL, vm_lookup_page(entries[i].address / B_PAGE_SIZE));

src/add-ons/kernel/drivers/disk/scsi/scsi_cd/scsi_cd.cpp

927

if (freeMemory > 180 * 1024 * 1024 / B_PAGE_SIZE) {

src/add-ons/kernel/drivers/disk/virtual/ram_disk/cache_support.h

16

size_t pageCount = length / B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/cache_support.h

33

offset += B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/cache_support.h

34

length -= B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/cache_support.h

84

offset += B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/cache_support.h

85

length -= B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

1375

geometry.bytes_per_sector = B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

1377

geometry.cylinder_count = device->DeviceSize() / B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

1385

geometry.bytes_per_physical_sector = B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

245

fMaxOperationLength(B_PAGE_SIZE * 128)

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

278

fDeviceSize = (deviceSize + B_PAGE_SIZE - 1) / B_PAGE_SIZE

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

279

* B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

281

if (fDeviceSize < B_PAGE_SIZE

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

282

|| (uint64)fDeviceSize / B_PAGE_SIZE

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

349

error = fDMAResource->Init(restrictions, B_PAGE_SIZE,

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

392

uint8* buffer = (uint8*)malloc(kPageCountPerIteration * B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

407

= fCache->pages.GetIterator(offset / B_PAGE_SIZE, true, true);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

424

offset = firstPageIndex * B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

465

error = vm_memcpy_from_physical(buffer + i * B_PAGE_SIZE,

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

466

page->physical_page_number * B_PAGE_SIZE, B_PAGE_SIZE,

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

475

memset(buffer + i * B_PAGE_SIZE, 0, B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

481

pagesToWrite * B_PAGE_SIZE, offset);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

487

else if ((size_t)bytesWritten != pagesToWrite * B_PAGE_SIZE) {

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

490

pagesToWrite * B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

510

offset += pagesToWrite * B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

548

offset = (offset + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

553

length &= ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

562

for (uint64 j = 0; j < length / B_PAGE_SIZE; j++) {

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

563

vm_page* page = fCache->LookupPage(offset + j * B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

573

trimmedSize += B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

649

ASSERT(offset % B_PAGE_SIZE == 0);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

650

ASSERT(length % B_PAGE_SIZE == 0);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

656

BStackOrHeapArray<vm_page*, 16> pages(length / B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

675

offset += B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

676

length -= B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

703

page->physical_page_number * B_PAGE_SIZE, &virtualAddress,

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

714

size_t length = B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

760

new(std::nothrow) uint8[kPageCountPerIteration * B_PAGE_SIZE]);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

776

size_t(sizeRemaining / B_PAGE_SIZE));

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

793

size_t bytesToRead = pagesToRead * B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

800

size_t pagesRead = (bytesRead + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

807

if ((size_t)bytesRead < pagesRead * B_PAGE_SIZE) {

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

809

pagesRead * B_PAGE_SIZE - bytesRead);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

816

page->physical_page_number * B_PAGE_SIZE,

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

817

buffer.Get() + i * B_PAGE_SIZE, B_PAGE_SIZE, false);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

832

uint64* pageData = (uint64*)(buffer.Get() + i * B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

834

for (size_t k = 0; isClear && k < B_PAGE_SIZE / 8; k++)

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

840

fCache->InsertPage(pages[i], offset + i * B_PAGE_SIZE);

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

857

offset += pagesRead * B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/ram_disk/ram_disk.cpp

858

sizeRemaining -= pagesRead * B_PAGE_SIZE;

src/add-ons/kernel/drivers/disk/virtual/virtio_block/virtio_block.cpp

566

B_ANY_KERNEL_BLOCK_ADDRESS, B_PAGE_SIZE,

src/add-ons/kernel/drivers/disk/virtual/virtio_block/virtio_block.cpp

576

status_t status = get_memory_map((void*)info->bufferAddr, B_PAGE_SIZE, &entry, 1);

src/add-ons/kernel/drivers/dvb/cx23882/util.c

51

offset = (uint32)phy & (B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/dvb/cx23882/util.c

53

size = ROUNDUP(size + offset, B_PAGE_SIZE);

src/add-ons/kernel/drivers/dvb/cx23882/util.c

84

size = ROUNDUP(size, B_PAGE_SIZE);

src/add-ons/kernel/drivers/graphics/3dfx/driver.cpp

33

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

src/add-ons/kernel/drivers/graphics/ati/driver.cpp

32

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

src/add-ons/kernel/drivers/graphics/common/memory_manager.c

130

size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/graphics/et6x00/driver.c

468

di->sharedArea = create_area(shared_name, (void **)&(di->si), B_ANY_KERNEL_ADDRESS, ((sizeof(ET6000SharedInfo) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1)), B_FULL_LOCK,

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

315

B_PAGE_SIZE, &entry, 1);

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

34

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

340

for (uint32 offset = 0; offset < si.videoMemSize; offset += B_PAGE_SIZE) {

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

342

B_PAGE_SIZE, &entry, 1);

src/add-ons/kernel/drivers/graphics/intel_810/driver.cpp

352

OUTREG32(PTE_BASE + ((offset / B_PAGE_SIZE) * 4),

src/add-ons/kernel/drivers/graphics/intel_extreme/intel_extreme.cpp

45

user_memset(_registers, 0, B_PAGE_SIZE);

src/add-ons/kernel/drivers/graphics/intel_extreme/intel_extreme.cpp

614

ROUND_TO_PAGE_SIZE(sizeof(intel_shared_info)) + 3 * B_PAGE_SIZE,

src/add-ons/kernel/drivers/graphics/intel_extreme/intel_extreme.cpp

726

if (intel_allocate_memory(info, 16 * B_PAGE_SIZE, 0, 0,

src/add-ons/kernel/drivers/graphics/intel_extreme/intel_extreme.cpp

729

primary.size = 16 * B_PAGE_SIZE;

src/add-ons/kernel/drivers/graphics/intel_extreme/intel_extreme.cpp

824

status_t status = intel_allocate_memory(info, B_PAGE_SIZE, 0,

src/add-ons/kernel/drivers/graphics/intel_extreme/intel_extreme.cpp

845

if (intel_allocate_memory(info, B_PAGE_SIZE, 0, B_APERTURE_NEED_PHYSICAL,

src/add-ons/kernel/drivers/graphics/intel_extreme/intel_extreme.cpp

851

intel_allocate_memory(info, B_PAGE_SIZE, 0, B_APERTURE_NEED_PHYSICAL,

src/add-ons/kernel/drivers/graphics/matrox/driver.c

771

((sizeof(shared_info) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1)), B_FULL_LOCK,

src/add-ons/kernel/drivers/graphics/neomagic/driver.c

699

di->shared_area = create_area(shared_name, (void **)&(di->si), B_ANY_KERNEL_ADDRESS, ((sizeof(shared_info) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1)), B_FULL_LOCK,

src/add-ons/kernel/drivers/graphics/nvidia/driver.c

922

((sizeof(shared_info) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1)), B_FULL_LOCK,

src/add-ons/kernel/drivers/graphics/nvidia/driver.c

936

net_buf_size = ((1 * 1024 * 1024) + (B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/kernel/drivers/graphics/nvidia/driver.c

957

get_memory_map(unaligned_dma_buffer, B_PAGE_SIZE, map, 1);

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

144

num_pages = (gart->buffer.size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

149

(num_pages * sizeof( uint32 ) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1),

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

162

get_memory_map(gart->GATT.ptr, B_PAGE_SIZE, PTB_map, 1);

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

174

if ((map_area_size / B_PAGE_SIZE) * B_PAGE_SIZE != map_area_size)

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

175

map_area_size = ((map_area_size / B_PAGE_SIZE) + 1) * B_PAGE_SIZE;

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

35

gart->buffer.size = size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

78

gart->buffer.size = size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/graphics/radeon/PCI_GART.c

96

get_memory_map( unaligned_addr, B_PAGE_SIZE, map, 1 );

src/add-ons/kernel/drivers/graphics/radeon/init.c

218

(sizeof(shared_info) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1),

src/add-ons/kernel/drivers/graphics/radeon/init.c

285

(sizeof(virtual_card) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1),

src/add-ons/kernel/drivers/graphics/s3/driver.cpp

413

((sizeof(SharedInfo) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1)),

src/add-ons/kernel/drivers/graphics/skeleton/driver.c

651

di->shared_area = create_area(shared_name, (void **)&(di->si), B_ANY_KERNEL_ADDRESS, ((sizeof(shared_info) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1)), B_FULL_LOCK,

src/add-ons/kernel/drivers/graphics/via/driver.c

660

di->shared_area = create_area(shared_name, (void **)&(di->si), B_ANY_KERNEL_ADDRESS, ((sizeof(shared_info) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1)), B_FULL_LOCK,

src/add-ons/kernel/drivers/graphics/virtio/virtio_gpu.cpp

499

B_ANY_KERNEL_BLOCK_ADDRESS, B_PAGE_SIZE,

src/add-ons/kernel/drivers/graphics/virtio/virtio_gpu.cpp

507

status = get_memory_map((void*)info->commandBuffer, B_PAGE_SIZE, &entry, 1);

src/add-ons/kernel/drivers/graphics/virtio/virtio_gpu.cpp

70

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

src/add-ons/kernel/drivers/input/virtio_input/virtio_input.cpp

167

size_t size = ROUNDUP(sizeof(Packet)*count, B_PAGE_SIZE);

src/add-ons/kernel/drivers/midi/usb_midi/usb_midi.cpp

105

B_PAGE_SIZE, B_CONTIGUOUS, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA);

src/add-ons/kernel/drivers/midi/usb_midi/usb_midi.cpp

114

(usb_midi_event_packet*)((uint8*)midiDevice->buffer + B_PAGE_SIZE / 2);

src/add-ons/kernel/drivers/midi/usb_midi/usb_midi.cpp

137

midiDevice->inMaxPkt = midiDevice->outMaxPkt = B_PAGE_SIZE / 2;

src/add-ons/kernel/drivers/misc/mem.c

174

if (length > SSIZE_MAX - B_PAGE_SIZE)

src/add-ons/kernel/drivers/misc/mem.c

178

physicalAddress = (phys_addr_t)position & ~((off_t)B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/misc/mem.c

184

size = (offset + length + B_PAGE_SIZE - 1) & ~((size_t)B_PAGE_SIZE - 1);

src/add-ons/kernel/drivers/network/ether/etherpci/etherpci.c

1192

base = base & ~(B_PAGE_SIZE-1);

src/add-ons/kernel/drivers/network/ether/etherpci/etherpci.c

1197

size = (size +(B_PAGE_SIZE-1)) & ~(B_PAGE_SIZE-1);

src/add-ons/kernel/drivers/network/ether/virtio/virtio_net.cpp

280

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

src/add-ons/kernel/drivers/network/ether/wb840/wb840.c

19

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

src/add-ons/kernel/drivers/ports/usb_serial/SerialDevice.cpp

93

B_ANY_KERNEL_ADDRESS, ROUNDUP(totalBuffers, B_PAGE_SIZE), B_CONTIGUOUS,

src/add-ons/kernel/drivers/timer/hpet.cpp

374

B_PAGE_SIZE,

src/add-ons/kernel/file_systems/btrfs/btrfs_disk_system.cpp

29

uint32 sectorSize = B_PAGE_SIZE;

src/add-ons/kernel/file_systems/btrfs/btrfs_disk_system.cpp

35

uint32 blockSize = max_c(16384, B_PAGE_SIZE);

src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp

438

if (static_cast<uint64>(pos) > ROUNDUP(fMaxFileSize, B_PAGE_SIZE)

src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp

443

size_t pageOffset = pos % B_PAGE_SIZE;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

168

page_num_t firstPageOffset = lineOffset / B_PAGE_SIZE;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

169

page_num_t linePageCount = (lineSize + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

254

fCache->InsertPage(pages[index], (off_t)pageOffset * B_PAGE_SIZE);

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

266

B_PRIuSIZE ")\n", (off_t)firstMissing * B_PAGE_SIZE,

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

267

(size_t)missingPages * B_PAGE_SIZE, requestOffset,

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

362

size_t firstPage = pagesRelativeOffset / B_PAGE_SIZE;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

363

size_t endPage = (pagesRelativeOffset + requestLength + B_PAGE_SIZE - 1)

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

364

/ B_PAGE_SIZE;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

367

size_t inPageOffset = pagesRelativeOffset % B_PAGE_SIZE;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

373

pages[i]->physical_page_number * B_PAGE_SIZE, &address,

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

379

size_t toCopy = std::min(B_PAGE_SIZE - inPageOffset, requestLength);

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

403

* B_PAGE_SIZE;

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

405

firstPageOffset + (off_t)pageCount * B_PAGE_SIZE,

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

50

B_PAGE_SIZE - fInPageOffset);

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

52

fPages[0]->physical_page_number * B_PAGE_SIZE + fInPageOffset,

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.cpp

58

if (fInPageOffset == B_PAGE_SIZE) {

src/add-ons/kernel/file_systems/packagefs/package/CachedDataReader.h

139

= kCacheLineSize / B_PAGE_SIZE;

src/add-ons/kernel/file_systems/ramfs/DataContainer.cpp

332

const off_t rounded_offset = ROUNDDOWN(offset, B_PAGE_SIZE);

src/add-ons/kernel/file_systems/ramfs/DataContainer.cpp

334

B_PAGE_SIZE);

src/add-ons/kernel/file_systems/ramfs/DataContainer.cpp

335

BStackOrHeapArray<vm_page*, 16> pages(rounded_len / B_PAGE_SIZE);

src/add-ons/kernel/file_systems/ramfs/DataContainer.cpp

348

? (page->physical_page_number * B_PAGE_SIZE) : 0;

src/add-ons/kernel/file_systems/ramfs/DataContainer.cpp

349

ssize_t bytes = B_PAGE_SIZE;

src/add-ons/kernel/file_systems/ramfs/DataContainer.cpp

351

const uint32 pageoffset = (offset % B_PAGE_SIZE);

src/add-ons/kernel/file_systems/ramfs/DataContainer.cpp

48

static const off_t kMaximumSmallBufferSize = (B_PAGE_SIZE / 4);

src/add-ons/kernel/file_systems/ramfs/kernel_interface.cpp

134

info->block_size = B_PAGE_SIZE;

src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp

237

int32 areaSize = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE;

src/add-ons/kernel/file_systems/userlandfs/server/ServerDefs.h

26

static const int32 kRequestPortSize = B_PAGE_SIZE;

src/add-ons/kernel/file_systems/userlandfs/server/fuse/FUSEVolume.cpp

1038

BStackOrHeapArray<char, B_PAGE_SIZE> buffer(requestInfo.length);

src/add-ons/kernel/generic/ata_adapter/ata_adapter.cpp

415

prdt_size = (ATA_ADAPTER_MAX_SG_COUNT * sizeof( prd_entry ) + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1);

src/add-ons/media/media-add-ons/usb_webcam/CamDevice.cpp

68

fBufferLen = 1*B_PAGE_SIZE;

src/apps/aboutsystem/AboutSystem.cpp

2227

return (int)round(sysInfo->ignored_pages * B_PAGE_SIZE / 1048576.0);

src/apps/aboutsystem/AboutSystem.cpp

2234

return (int)round(sysInfo->max_pages * B_PAGE_SIZE / 1048576.0);

src/apps/aboutsystem/AboutSystem.cpp

2248

return (int)round(sysInfo->used_pages * B_PAGE_SIZE / 1048576.0);

src/apps/activitymonitor/SystemInfo.cpp

53

return fSystemInfo.cached_pages * B_PAGE_SIZE;

src/apps/activitymonitor/SystemInfo.cpp

63

return fSystemInfo.block_cache_pages * B_PAGE_SIZE;

src/apps/activitymonitor/SystemInfo.cpp

70

return fSystemInfo.used_pages * B_PAGE_SIZE;

src/apps/activitymonitor/SystemInfo.cpp

77

return fSystemInfo.max_pages * B_PAGE_SIZE;

src/apps/activitymonitor/SystemInfo.cpp

92

* B_PAGE_SIZE;

src/apps/activitymonitor/SystemInfo.cpp

99

return fSystemInfo.max_swap_pages * B_PAGE_SIZE;

src/apps/diskprobe/TypeEditors.cpp

190

return uint64(fEditor.FileSize()) / B_PAGE_SIZE < info.max_pages / 2;

src/apps/processcontroller/KernelMemoryBarMenuItem.cpp

28

fPhysicalMemory = (int64)systemInfo.max_pages * B_PAGE_SIZE / 1024LL;

src/apps/processcontroller/KernelMemoryBarMenuItem.cpp

29

fCommittedMemory = (int64)systemInfo.used_pages * B_PAGE_SIZE / 1024LL;

src/apps/processcontroller/KernelMemoryBarMenuItem.cpp

30

fCachedMemory = (int64)systemInfo.cached_pages * B_PAGE_SIZE / 1024LL;

src/apps/processcontroller/MemoryBarMenu.cpp

78

int64 committedMemory = (int64)sinfo.used_pages * B_PAGE_SIZE / 1024;

src/apps/processcontroller/MemoryBarMenu.cpp

79

int64 cachedMemory = (int64)sinfo.cached_pages * B_PAGE_SIZE / 1024;

src/apps/processcontroller/MemoryBarMenuItem.cpp

249

lwram_size -= info.block_cache_pages * B_PAGE_SIZE;

src/apps/processcontroller/ProcessController.cpp

808

int64 committedMemory = (int64)systemInfo.used_pages * B_PAGE_SIZE / 1024;

src/apps/showimage/ImageCache.cpp

72

fMaxBytes = info.max_pages * B_PAGE_SIZE / 5;

src/bin/ps.c

229

(systemInfo.max_pages * B_PAGE_SIZE / 1024),

src/bin/ps.c

230

(systemInfo.max_pages * B_PAGE_SIZE));

src/bin/ps.c

232

(systemInfo.used_pages * B_PAGE_SIZE / 1024),

src/bin/ps.c

233

(systemInfo.used_pages * B_PAGE_SIZE));

src/bin/ps.c

235

(systemInfo.max_pages - systemInfo.used_pages) * B_PAGE_SIZE / 1024,

src/bin/ps.c

236

(systemInfo.max_pages - systemInfo.used_pages) * B_PAGE_SIZE);

src/bin/ramdisk.cpp

155

if (deviceSize / B_PAGE_SIZE > (int64)info.max_pages * 2 / 3) {

src/bin/sysinfo.cpp

773

B_PAGE_SIZE * (uint64)(info->max_pages - info->used_pages),

src/bin/sysinfo.cpp

774

B_PAGE_SIZE * (uint64)info->used_pages,

src/bin/sysinfo.cpp

775

B_PAGE_SIZE * (uint64)info->max_pages);

src/bin/sysinfo.cpp

777

B_PAGE_SIZE * (uint64)info->cached_pages);

src/bin/vmstat.cpp

100

- (lastInfo.max_pages * B_PAGE_SIZE - lastInfo.free_memory);

src/bin/vmstat.cpp

104

* B_PAGE_SIZE;

src/bin/vmstat.cpp

107

* B_PAGE_SIZE;

src/bin/vmstat.cpp

77

printf("max memory:\t\t%" B_PRIu64 "\n", info.max_pages * B_PAGE_SIZE);

src/bin/vmstat.cpp

81

info.block_cache_pages * B_PAGE_SIZE);

src/bin/vmstat.cpp

83

info.max_swap_pages * B_PAGE_SIZE);

src/bin/vmstat.cpp

85

info.free_swap_pages * B_PAGE_SIZE);

src/bin/vmstat.cpp

99

= (info.max_pages * B_PAGE_SIZE - info.free_memory)

src/kits/app/LinkReceiver.cpp

201

bufferSize = (bufferSize + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/kits/app/LinkSender.cpp

191

off_t alignedSize = (passedSize + B_PAGE_SIZE) & ~(B_PAGE_SIZE - 1);

src/kits/app/LinkSender.cpp

367

newSize = (newSize + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/kits/app/Looper.cpp

1418

if (((addr_t)&stack & ~(B_PAGE_SIZE - 1)) == fCachedStack

src/kits/app/Looper.cpp

628

return ((addr_t)&stack & ~(B_PAGE_SIZE - 1)) == fCachedStack

src/kits/app/Looper.cpp

987

looper->fCachedStack = (addr_t)&err & ~(B_PAGE_SIZE - 1);

src/kits/app/Message.cpp

1155

size = (size + B_PAGE_SIZE) & ~(B_PAGE_SIZE - 1);

src/kits/app/Message.cpp

2167

} else if (fHeader->data_size > B_PAGE_SIZE * 10) {

src/kits/debugger/controllers/DebugReportGenerator.cpp

304

BPrivate::string_for_size((int64)info.max_pages * B_PAGE_SIZE,

src/kits/debugger/controllers/DebugReportGenerator.cpp

306

BPrivate::string_for_size((int64)info.used_pages * B_PAGE_SIZE,

src/kits/debugger/debug_managers/TeamMemoryBlockManager.cpp

125

address &= ~(B_PAGE_SIZE - 1);

src/kits/debugger/model/TeamMemory.cpp

24

char buffer[B_PAGE_SIZE];

src/kits/debugger/model/TeamMemory.cpp

30

B_PAGE_SIZE - size_t(address % B_PAGE_SIZE));

src/kits/media/BufferGroup.cpp

68

= ((allocSize * count) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/kits/media/MediaRoster.cpp

2426

int32 requestsize[] = {B_PAGE_SIZE, 4 * B_PAGE_SIZE, 16 * B_PAGE_SIZE,

src/kits/media/MediaRoster.cpp

2427

64 * B_PAGE_SIZE, 128 * B_PAGE_SIZE, 256 * B_PAGE_SIZE, 0};

src/kits/media/MediaRoster.cpp

2995

size_t size = (needSize + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1);

src/kits/media/MediaRoster.cpp

3296

size_t size = (totalSize + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1);

src/kits/media/RealtimeAlloc.cpp

289

pool->max_size = (totalSize + sizeof(FreeChunk) - 1 + B_PAGE_SIZE)

src/kits/media/RealtimeAlloc.cpp

290

& ~(B_PAGE_SIZE - 1);

src/kits/media/SharedBufferList.cpp

42

size_t size = (sizeof(SharedBufferList) + (B_PAGE_SIZE - 1))

src/kits/media/SharedBufferList.cpp

43

& ~(B_PAGE_SIZE - 1);

src/kits/media/TimeSource.cpp

36

#define TS_AREA_SIZE B_PAGE_SIZE

src/kits/media/TimedEventQueue.cpp

165

const size_t chunkSize = B_PAGE_SIZE;

src/kits/media/legacy/OldBufferStreamManager.h

24

#define B_DEFAULT_BSTREAM_SIZE B_PAGE_SIZE

src/kits/tracker/EntryIterator.h

95

const int32 kDirentBufferSize = B_PAGE_SIZE * 2;

src/kits/tracker/FSUtils.cpp

1426

(sinfo.max_pages - sinfo.used_pages) * B_PAGE_SIZE);

src/libs/compat/freebsd_network/bus.cpp

56

uint32 offset = _phy & (B_PAGE_SIZE - 1);

src/libs/compat/freebsd_network/bus.cpp

60

size = roundup(size + offset, B_PAGE_SIZE);

src/libs/compat/freebsd_network/bus_dma.cpp

233

if (dmat->lowaddr > B_PAGE_SIZE) {

src/libs/compat/freebsd_network/bus_dma.cpp

322

reqsize = roundup(reqsize, B_PAGE_SIZE);

src/libs/compat/freebsd_network/compat/sys/param.h

26

#define PAGE_MASK (B_PAGE_SIZE - 1)

src/libs/compat/freebsd_network/compat/sys/param.h

43

#define MJUMPAGESIZE B_PAGE_SIZE

src/libs/compat/freebsd_network/malloc.cpp

54

size = ROUNDUP(size, B_PAGE_SIZE);

src/preferences/virtualmemory/Settings.cpp

44

fDefaultSettings.size = (off_t)sysInfo.max_pages * B_PAGE_SIZE;

src/preferences/virtualmemory/SettingsWindow.cpp

454

off_t minSize = B_PAGE_SIZE + kMegaByte;

src/preferences/virtualmemory/SettingsWindow.cpp

493

off_t currentSwapSize = info.max_swap_pages * B_PAGE_SIZE;

src/preferences/virtualmemory/SettingsWindow.cpp

495

= (info.max_swap_pages - info.free_swap_pages) * B_PAGE_SIZE;

src/servers/app/ClientMemoryAllocator.cpp

230

size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/servers/app/ClientMemoryAllocator.cpp

250

if (size < B_PAGE_SIZE * 32)

src/servers/app/ClientMemoryAllocator.cpp

251

size = B_PAGE_SIZE * 32;

src/servers/app/EventStream.cpp

62

B_PAGE_SIZE, B_LAZY_LOCK, B_READ_AREA | B_WRITE_AREA | B_CLONEABLE_AREA);

src/servers/media/MediaFilesManager.cpp

163

size_t size = (count * B_MEDIA_NAME_LENGTH + B_PAGE_SIZE - 1)

src/servers/media/MediaFilesManager.cpp

164

& ~(B_PAGE_SIZE - 1);

src/servers/media/MediaFilesManager.cpp

204

size_t size = (count * B_MEDIA_NAME_LENGTH + B_PAGE_SIZE - 1)

src/servers/media/MediaFilesManager.cpp

205

& ~(B_PAGE_SIZE - 1);

src/servers/media/media_server.cpp

384

+ B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/system/boot/arch/m68k/mmu.cpp

129

return get_next_virtual_address(B_PAGE_SIZE);

src/system/boot/arch/m68k/mmu.cpp

137

return get_next_physical_address(B_PAGE_SIZE);

src/system/boot/arch/m68k/mmu.cpp

153

sNextPageTableAddress += B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

226

sMaxVirtualAddress += B_PAGE_SIZE * 64;

src/system/boot/arch/m68k/mmu.cpp

233

physicalAddress &= ~(B_PAGE_SIZE - 1);

src/system/boot/arch/m68k/mmu.cpp

311

addr_t pageOffset = physicalAddress & (B_PAGE_SIZE - 1);

src/system/boot/arch/m68k/mmu.cpp

315

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/boot/arch/m68k/mmu.cpp

329

size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

341

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/arch/m68k/mmu.cpp

347

address += B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

376

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

378

size = (size + pageOffset + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

387

for (size_t i = 0; i < size; i += B_PAGE_SIZE) {

src/system/boot/arch/m68k/mmu.cpp

389

address += B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

608

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE);

src/system/boot/arch/m68k/mmu.cpp

610

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/arch/m68k/mmu.cpp

632

video_base &= ~(B_PAGE_SIZE-1);

src/system/boot/arch/m68k/mmu.cpp

670

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/arch/m68k/mmu_040.cpp

326

physicalAddress &= ~(B_PAGE_SIZE - 1);

src/system/boot/arch/x86/arch_hpet.cpp

56

gKernelArgs.arch_args.hpet_phys, B_PAGE_SIZE, kDefaultPageFlags);

src/system/boot/loader/elf.cpp

278

region->start = ROUNDDOWN(header.p_vaddr, B_PAGE_SIZE);

src/system/boot/loader/elf.cpp

279

region->size = ROUNDUP(header.p_memsz + (header.p_vaddr % B_PAGE_SIZE),

src/system/boot/loader/elf.cpp

280

B_PAGE_SIZE);

src/system/boot/loader/elf.cpp

363

Class::Map(region->start + (header.p_vaddr % B_PAGE_SIZE)),

src/system/boot/loader/elf.cpp

374

uint32 offset = (header.p_vaddr % B_PAGE_SIZE) + header.p_filesz;

src/system/boot/loader/kernel_args.cpp

147

uint64 end = ROUNDUP(start + size, B_PAGE_SIZE);

src/system/boot/loader/kernel_args.cpp

148

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/boot/loader/kernel_args.cpp

19

static const size_t kChunkSize = 16 * B_PAGE_SIZE;

src/system/boot/loader/kernel_args.cpp

69

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/boot/loader/kernel_args.cpp

70

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/amiga_m68k/mmu.cpp

129

return get_next_virtual_address(B_PAGE_SIZE);

src/system/boot/platform/amiga_m68k/mmu.cpp

137

return get_next_physical_address(B_PAGE_SIZE);

src/system/boot/platform/amiga_m68k/mmu.cpp

153

sNextPageTableAddress += B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

226

sMaxVirtualAddress += B_PAGE_SIZE * 64;

src/system/boot/platform/amiga_m68k/mmu.cpp

233

physicalAddress &= ~(B_PAGE_SIZE - 1);

src/system/boot/platform/amiga_m68k/mmu.cpp

311

addr_t pageOffset = physicalAddress & (B_PAGE_SIZE - 1);

src/system/boot/platform/amiga_m68k/mmu.cpp

315

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/boot/platform/amiga_m68k/mmu.cpp

329

size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

341

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/platform/amiga_m68k/mmu.cpp

347

address += B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

376

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

378

size = (size + pageOffset + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

387

for (size_t i = 0; i < size; i += B_PAGE_SIZE) {

src/system/boot/platform/amiga_m68k/mmu.cpp

389

address += B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

609

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE);

src/system/boot/platform/amiga_m68k/mmu.cpp

611

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/amiga_m68k/mmu.cpp

633

video_base &= ~(B_PAGE_SIZE-1);

src/system/boot/platform/amiga_m68k/mmu.cpp

668

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/atari_m68k/mmu.cpp

130

return get_next_virtual_address(B_PAGE_SIZE);

src/system/boot/platform/atari_m68k/mmu.cpp

138

return get_next_physical_address(B_PAGE_SIZE);

src/system/boot/platform/atari_m68k/mmu.cpp

154

sNextPageTableAddress += B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

227

sMaxVirtualAddress += B_PAGE_SIZE * 64;

src/system/boot/platform/atari_m68k/mmu.cpp

234

physicalAddress &= ~(B_PAGE_SIZE - 1);

src/system/boot/platform/atari_m68k/mmu.cpp

312

addr_t pageOffset = physicalAddress & (B_PAGE_SIZE - 1);

src/system/boot/platform/atari_m68k/mmu.cpp

316

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/boot/platform/atari_m68k/mmu.cpp

330

size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

342

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/platform/atari_m68k/mmu.cpp

348

address += B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

377

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

379

size = (size + pageOffset + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

388

for (size_t i = 0; i < size; i += B_PAGE_SIZE) {

src/system/boot/platform/atari_m68k/mmu.cpp

390

address += B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

611

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE);

src/system/boot/platform/atari_m68k/mmu.cpp

613

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/atari_m68k/mmu.cpp

635

video_base &= ~(B_PAGE_SIZE-1);

src/system/boot/platform/atari_m68k/mmu.cpp

673

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/debug.cpp

190

= (void*)ROUNDDOWN((addr_t)sDebugSyslogBuffer, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

140

memset(pml4, 0, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

155

memset(pdpt, 0, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

161

memset(pageDir, 0, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

168

mmu_free(pageDir, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

171

mmu_free(pdpt, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

175

memset(pdpt, 0, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

179

memset(pageDir, 0, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

186

/ B_PAGE_SIZE; i++) {

src/system/boot/platform/bios_ia32/long.cpp

189

mmu_free(pageTable, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

192

memset(pageTable, 0, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

197

if (!mmu_get_virtual_mapping(KERNEL_LOAD_BASE + (i * B_PAGE_SIZE),

src/system/boot/platform/bios_ia32/long.cpp

205

mmu_free(pageTable, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

206

mmu_free(pageDir, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

207

mmu_free(pdpt, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

209

mmu_free(pml4, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/long.cpp

96

memset(pmlTop, 0, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

117

if ((size % B_PAGE_SIZE) != 0)

src/system/boot/platform/bios_ia32/mmu.cpp

147

return allocate_virtual(B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

154

return allocate_physical(B_PAGE_SIZE, false);

src/system/boot/platform/bios_ia32/mmu.cpp

167

return (uint32 *)allocate_physical(B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

169

sNextPageTableAddress += B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

183

base = ROUNDDOWN(base, B_PAGE_SIZE * 1024);

src/system/boot/platform/bios_ia32/mmu.cpp

206

base += B_PAGE_SIZE * 1024;

src/system/boot/platform/bios_ia32/mmu.cpp

226

/ (B_PAGE_SIZE * 1024)] & 0xfffff000);

src/system/boot/platform/bios_ia32/mmu.cpp

227

pageTable[(virtualAddress % (B_PAGE_SIZE * 1024)) / B_PAGE_SIZE] = 0;

src/system/boot/platform/bios_ia32/mmu.cpp

250

/ (B_PAGE_SIZE * 1024)] & 0xfffff000);

src/system/boot/platform/bios_ia32/mmu.cpp

263

physicalAddress &= ~(B_PAGE_SIZE - 1);

src/system/boot/platform/bios_ia32/mmu.cpp

266

uint32 tableEntry = (virtualAddress % (B_PAGE_SIZE * 1024)) / B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

340

sPageDirectory = (uint32 *)allocate_physical(B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

393

addr_t pageOffset = physicalAddress & (B_PAGE_SIZE - 1);

src/system/boot/platform/bios_ia32/mmu.cpp

398

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/boot/platform/bios_ia32/mmu.cpp

412

size = HOWMANY(size, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

424

if (address < KERNEL_LOAD_BASE || address + size * B_PAGE_SIZE

src/system/boot/platform/bios_ia32/mmu.cpp

430

address += B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

501

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

504

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

513

for (size_t i = 0; i < size; i += B_PAGE_SIZE) {

src/system/boot/platform/bios_ia32/mmu.cpp

515

address += B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

540

uint32 dirEntry = sPageDirectory[virtualAddress / (B_PAGE_SIZE * 1024)];

src/system/boot/platform/bios_ia32/mmu.cpp

545

uint32 tableEntry = pageTable[(virtualAddress % (B_PAGE_SIZE * 1024))

src/system/boot/platform/bios_ia32/mmu.cpp

546

/ B_PAGE_SIZE];

src/system/boot/platform/bios_ia32/mmu.cpp

672

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

674

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/mmu.cpp

699

base = ROUNDUP(base, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

700

end = ROUNDDOWN(end, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

742

uint64 end = ROUNDUP(base + extMemoryBlock[i].length, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

743

base = ROUNDDOWN(base, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/mmu.cpp

834

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/smp.cpp

365

gKernelArgs.arch_args.apic_phys, B_PAGE_SIZE, kDefaultPageFlags);

src/system/boot/platform/bios_ia32/smp.cpp

375

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE);

src/system/boot/platform/bios_ia32/smp.cpp

377

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/bios_ia32/smp.cpp

418

memset((uint8*)finalStack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE, 0,

src/system/boot/platform/bios_ia32/smp.cpp

421

+ (KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE)

src/system/boot/platform/bios_ia32/smp.cpp

426

tempStack = (uint32 *)(trampolineStack + B_PAGE_SIZE - 4);

src/system/boot/platform/bios_ia32/smp.cpp

429

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE - sizeof(uint32);

src/system/boot/platform/efi/arch/arm/arch_mmu.cpp

118

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/boot/platform/efi/arch/arm/arch_mmu.cpp

148

phys_addr_t physAddr = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/arm/arch_mmu.cpp

149

size_t alignedSize = ROUNDUP(size + (start - physAddr), B_PAGE_SIZE);

src/system/boot/platform/efi/arch/arm/arch_mmu.cpp

169

uint64_t size = entry->NumberOfPages * B_PAGE_SIZE;

src/system/boot/platform/efi/arch/arm/arch_mmu.cpp

246

if (platform_allocate_region(&vectorTable, B_PAGE_SIZE, 0) != B_OK)

src/system/boot/platform/efi/arch/arm/arch_mmu.cpp

251

memset(vectorTable, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/arm/arch_mmu.cpp

93

physAddr &= ~(B_PAGE_SIZE - 1);

src/system/boot/platform/efi/arch/arm/arch_start.cpp

106

memcpy(trampolinePage, (void *)arch_enter_kernel, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/arm/arch_start.cpp

151

entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/arm/arch_start.cpp

153

entry->VirtualStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/arm/arch_start.cpp

154

entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/arm/arch_start.cpp

61

if (platform_allocate_region_below(&trampolinePage, B_PAGE_SIZE,

src/system/boot/platform/efi/arch/arm/arch_start.cpp

62

KERNEL_LOAD_BASE - B_PAGE_SIZE) == B_OK) {

src/system/boot/platform/efi/arch/arm/arch_start.cpp

68

if (platform_free_region(trampolinePage, B_PAGE_SIZE) != B_OK)

src/system/boot/platform/efi/arch/arm/arch_start.cpp

73

if (platform_allocate_region(&trampolinePage, B_PAGE_SIZE, 0) == B_OK) {

src/system/boot/platform/efi/arch/arm/arch_start.cpp

80

if (platform_free_region(trampolinePage, B_PAGE_SIZE) != B_OK)

src/system/boot/platform/efi/arch/arm64/arch_acpi.cpp

42

uart.regs.size = B_PAGE_SIZE;

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

355

entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/arm64/arch_mmu.cpp

381

uint64 regs_size = ROUNDUP(gKernelArgs.arch_args.uart.regs.size, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/arm64/arch_smp.cpp

93

const size_t size = KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/efi/arch/arm64/arch_start.cpp

120

entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/arm64/arch_start.cpp

122

entry->VirtualStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/arm64/arch_start.cpp

123

entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/generic/generic_mmu.cpp

31

uint64_t end = entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE;

src/system/boot/platform/efi/arch/generic/generic_mmu.cpp

65

uint64_t size = entry->NumberOfPages * B_PAGE_SIZE;

src/system/boot/platform/efi/arch/generic/generic_mmu.cpp

90

uint64_t size = entry->NumberOfPages * B_PAGE_SIZE;

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

115

DumpPageTableInt((Pte*)VirtFromPhys(B_PAGE_SIZE*pte[i].ppn),

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

121

pte[i].ppn * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

135

Pte* root = (Pte*)VirtFromPhys(satpReg.ppn * B_PAGE_SIZE);

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

159

uint64 ppn = mmu_allocate_page() / B_PAGE_SIZE;

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

162

memset((Pte*)VirtFromPhys(B_PAGE_SIZE * ppn), 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

170

pte = (Pte*)VirtFromPhys(B_PAGE_SIZE * pte->ppn);

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

189

.ppn = physAdr / B_PAGE_SIZE,

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

202

for (size_t i = 0; i < size; i += B_PAGE_SIZE)

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

247

uint64 ppn = mmu_allocate_page() / B_PAGE_SIZE;

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

249

memset(VirtFromPhys(B_PAGE_SIZE * ppn), 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

264

.ppn = sPageTable / B_PAGE_SIZE,

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

365

memset(VirtFromPhys(sPageTable), 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

396

MapRange(entry->VirtualStart, entry->PhysicalStart, entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/riscv64/arch_mmu.cpp

412

MapRange(entry->VirtualStart, entry->PhysicalStart, entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/riscv64/arch_smp.cpp

191

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/efi/arch/riscv64/arch_start.cpp

101

entry->VirtualStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/riscv64/arch_start.cpp

99

entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

147

physAddr &= ~(B_PAGE_SIZE - 1);

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

174

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

227

B_PAGE_SIZE + ALIGN_PAGEDIR, 0) != B_OK)

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

230

memset(sPageDirectory, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

254

entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

38

#define VADDR_TO_PDENT(va) (((va) / B_PAGE_SIZE) / 1024)

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

39

#define VADDR_TO_PTENT(va) (((va) / B_PAGE_SIZE) % 1024)

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

43

#define ALIGN_PAGEDIR B_PAGE_SIZE

src/system/boot/platform/efi/arch/x86/arch_mmu.cpp

89

memset(pageTable, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86/arch_smp.cpp

234

gKernelArgs.arch_args.apic_phys, B_PAGE_SIZE, kDefaultPageFlags);

src/system/boot/platform/efi/arch/x86/arch_smp.cpp

244

const size_t size = KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/efi/arch/x86/arch_start.cpp

112

entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/x86/arch_start.cpp

114

entry->VirtualStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/x86/arch_start.cpp

62

memcpy((void *)enter_kernel, (void *)arch_enter_kernel, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

205

if (platform_allocate_region_below((void**)&pml4, B_PAGE_SIZE, UINT32_MAX) != B_OK)

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

208

memset(pml4, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

262

memset(pdpt, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

268

memset(pageDir, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

279

memset(pdpt, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

283

memset(pageDir, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

290

/ B_PAGE_SIZE; i++) {

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

293

memset(pageTable, 0, B_PAGE_SIZE);

src/system/boot/platform/efi/arch/x86_64/arch_mmu.cpp

300

KERNEL_LOAD_BASE + (i * B_PAGE_SIZE), &phys) != B_OK) {

src/system/boot/platform/efi/arch/x86_64/arch_start.cpp

87

entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/arch/x86_64/arch_start.cpp

89

entry->VirtualStart + entry->NumberOfPages * B_PAGE_SIZE,

src/system/boot/platform/efi/heap.cpp

16

size_t pages = HOWMANY(_size, B_PAGE_SIZE);

src/system/boot/platform/efi/heap.cpp

22

return pages * B_PAGE_SIZE;

src/system/boot/platform/efi/heap.cpp

29

kBootServices->FreePages((efi_physical_addr)base, size / B_PAGE_SIZE);

src/system/boot/platform/efi/mmu.cpp

100

size_t pages = ROUNDUP(size, B_PAGE_SIZE) / B_PAGE_SIZE;

src/system/boot/platform/efi/mmu.cpp

155

size_t pages = ROUNDUP(size, B_PAGE_SIZE) / B_PAGE_SIZE;

src/system/boot/platform/efi/mmu.cpp

190

addr_t pageOffset = physicalAddress & (B_PAGE_SIZE - 1);

src/system/boot/platform/efi/mmu.cpp

196

ROUNDUP(size, B_PAGE_SIZE)) != B_OK)

src/system/boot/platform/efi/mmu.cpp

322

ROUNDUP(size, B_PAGE_SIZE) / B_PAGE_SIZE);

src/system/boot/platform/efi/mmu.cpp

73

sNextVirtualAddress += ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/efi/start.cpp

200

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE, 0) != B_OK) {

src/system/boot/platform/efi/start.cpp

205

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/ppc/cpu.cpp

109

cpuCount * (KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE),

src/system/boot/platform/openfirmware/arch/ppc/cpu.cpp

119

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/ppc/cpu.cpp

120

stack += KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

211

= (((uint32)physicalAddress / B_PAGE_SIZE) << 12) | mode;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

277

for (uint32 offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

489

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

561

address += B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

664

physicalAddress = (int)(entry->physical_page_number * B_PAGE_SIZE);

src/system/boot/platform/openfirmware/arch/ppc/mmu.cpp

922

gKernelArgs.arch_args.exception_handlers.size = B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/sparc/cpu.cpp

103

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/sparc/cpu.cpp

104

stack += KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/openfirmware/arch/sparc/cpu.cpp

93

cpuCount * (KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE),

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

371

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/openfirmware/arch/sparc/mmu.cpp

630

gKernelArgs.arch_args.exception_handlers.size = B_PAGE_SIZE;

src/system/boot/platform/riscv/mmu.cpp

106

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

107

phys_addr_t adr = ROUNDUP(gFreeVirtMem, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

145

uint64 ppn = AllocPhysPage() / B_PAGE_SIZE;

src/system/boot/platform/riscv/mmu.cpp

148

memset((Pte*)VirtFromPhys(B_PAGE_SIZE * ppn), 0, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

156

pte = (Pte*)VirtFromPhys(B_PAGE_SIZE * pte->ppn);

src/system/boot/platform/riscv/mmu.cpp

176

.ppn = physAdr / B_PAGE_SIZE

src/system/boot/platform/riscv/mmu.cpp

191

for (size_t i = 0; i < size; i += B_PAGE_SIZE)

src/system/boot/platform/riscv/mmu.cpp

229

uint64 ppn = AllocPhysPage() / B_PAGE_SIZE;

src/system/boot/platform/riscv/mmu.cpp

231

memset(VirtFromPhys(B_PAGE_SIZE * ppn), 0, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

246

memset(VirtFromPhys(sPageTable), 0, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

290

.ppn = sPageTable / B_PAGE_SIZE,

src/system/boot/platform/riscv/mmu.cpp

302

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

415

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE,

src/system/boot/platform/riscv/mmu.cpp

421

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/riscv/mmu.cpp

76

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

77

phys_addr_t adr = ROUNDUP((addr_t)gFreeMem, B_PAGE_SIZE);

src/system/boot/platform/riscv/mmu.cpp

91

return AllocPhysPages(B_PAGE_SIZE);

src/system/boot/platform/u-boot/arch/ppc/arch_cpu.cpp

137

cpuCount * (KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE),

src/system/boot/platform/u-boot/arch/ppc/arch_cpu.cpp

147

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/u-boot/arch/ppc/arch_cpu.cpp

148

stack += KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

322

= tlbSize + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

334

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/boot/platform/u-boot/arch/ppc/arch_mmu.cpp

358

size = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE * B_PAGE_SIZE;

src/system/kernel/arch/arm/arch_cpu.cpp

102

start += B_PAGE_SIZE;

src/system/kernel/arch/arm/arch_cpu.cpp

98

int32 num_pages = end / B_PAGE_SIZE - start / B_PAGE_SIZE;

src/system/kernel/arch/arm/arch_int.cpp

150

B_PAGE_SIZE, B_ALREADY_WIRED, B_READ_AREA | B_EXECUTE_AREA);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

101

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

111

_EarlyPreparePageTables(pageTable, virtualBase, 1024 * B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

125

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

141

1024 * B_PAGE_SIZE, 0);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

165

for (int32 i = 0; i < 1024; i++, slotAddress += B_PAGE_SIZE) {

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

182

(virtualAddress - fVirtualBase) / B_PAGE_SIZE];

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

204

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

220

&virtualBase, B_ANY_KERNEL_BLOCK_ADDRESS, 1024 * B_PAGE_SIZE,

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

228

memset(data, 0, B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

389

memset((void*)pgtable_virt, 0, B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

529

memset(pageTables, 0, 256 * (size / (B_PAGE_SIZE * 256)));

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

537

for (size_t i = 0; i < (size / (B_PAGE_SIZE * 256));

src/system/kernel/arch/arm/paging/32bit/ARMPagingMethod32Bit.cpp

92

addr_t virtualBase = vm_allocate_early(args, 1024 * B_PAGE_SIZE, 0, 0,

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

150

start = 1023 * B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

151

end += 1023 * B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

186

pgtable = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

232

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

256

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

286

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

343

PageUnmapped(area, (oldEntry & ARM_PTE_ADDRESS_MASK) / B_PAGE_SIZE,

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

394

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

411

page_num_t page = (oldEntry & ARM_PTE_ADDRESS_MASK) / B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

43

#define PAGEDIR_ALIGN (4 * B_PAGE_SIZE)

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

511

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

539

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

644

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

69

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/ARMVMTranslationMap32Bit.cpp

720

(oldEntry & ARM_PTE_ADDRESS_MASK) / B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/32bit/paging.h

24

B_PAGE_SIZE * ARM_MMU_L2_COARSE_ENTRY_COUNT)))

src/system/kernel/arch/arm/paging/32bit/paging.h

29

static const size_t kPageTableAlignment = ARM_MMU_L2_COARSE_ENTRY_COUNT * B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

386

phys_addr_t off = physicalAddress & (B_PAGE_SIZE -1);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

387

physicalAddress &= ~(B_PAGE_SIZE -1);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

399

slot.slot->address + B_PAGE_SIZE);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

488

phys_addr_t off = physicalAddress & (B_PAGE_SIZE -1);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

489

physicalAddress &= ~(B_PAGE_SIZE -1);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

509

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

536

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

562

*virtualAddress = fDebugSlot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

578

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

590

size_t toSet = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

609

addr_t pageOffset = from % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

620

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

649

addr_t pageOffset = to % B_PAGE_SIZE;

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

660

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/arm/paging/arm_physical_page_mapper_large_memory.cpp

700

memcpy((void*)toSlot->address, (void*)fromSlot->address, B_PAGE_SIZE);

src/system/kernel/arch/arm/soc_omap3.cpp

101

B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,

src/system/kernel/arch/arm/soc_omap3.cpp

191

B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,

src/system/kernel/arch/arm/soc_pxa.cpp

149

B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,

src/system/kernel/arch/arm/soc_pxa.cpp

48

B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,

src/system/kernel/arch/arm/soc_sun4i.cpp

77

B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,

src/system/kernel/arch/arm64/PMAPPhysicalPageMapper.cpp

73

reinterpret_cast<void*>(KERNEL_PMAP_BASE + from), B_PAGE_SIZE);

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

256

constexpr uint64_t level3Range = B_PAGE_SIZE * 512;

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

262

start = level3Range - B_PAGE_SIZE;

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

583

ProcessRange(fPageTable, fInitialLevel, va, B_PAGE_SIZE, reservation,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

640

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

652

ProcessRange(fPageTable, fInitialLevel, address, B_PAGE_SIZE, nullptr,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

752

ProcessRange(fPageTable, fInitialLevel, va, B_PAGE_SIZE, nullptr,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

862

ProcessRange(fPageTable, fInitialLevel, va, B_PAGE_SIZE, nullptr,

src/system/kernel/arch/arm64/VMSAv8TranslationMap.cpp

910

ProcessRange(fPageTable, fInitialLevel, address, B_PAGE_SIZE, nullptr,

src/system/kernel/arch/arm64/arch_vm_translation_map.cpp

109

ROUNDUP(args->arch_args.uart.regs.size, B_PAGE_SIZE), 0);

src/system/kernel/arch/arm64/arch_vm_translation_map.cpp

55

memset((void*) READ_SPECIALREG(TTBR0_EL1), 0, B_PAGE_SIZE);

src/system/kernel/arch/generic/generic_vm_physical_page_mapper.cpp

184

int32 max = vm_page_num_pages() / (sIOSpaceChunkSize / B_PAGE_SIZE);

src/system/kernel/arch/generic/generic_vm_physical_page_mapper.cpp

296

ROUNDUP(sizeof(paddr_chunk_desc) * 1024, B_PAGE_SIZE),

src/system/kernel/arch/generic/generic_vm_physical_page_mapper.cpp

301

ROUNDUP(sizeof(paddr_chunk_desc *) * num_virtual_chunks, B_PAGE_SIZE),

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

145

memcpy((void*)toVirtual, (const void*)fromVirtual, B_PAGE_SIZE);

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

20

phys_addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

28

size_t toSet = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

46

phys_addr_t pageOffset = from % B_PAGE_SIZE;

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

51

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

86

phys_addr_t pageOffset = to % B_PAGE_SIZE;

src/system/kernel/arch/generic/generic_vm_physical_page_ops.cpp

91

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/m68k/arch_cpu.cpp

131

int32 num_pages = end / B_PAGE_SIZE - start / B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_cpu.cpp

136

start += B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_int.cpp

600

addr_t inPageOffset = (addr_t)context & (B_PAGE_SIZE - 1);

src/system/kernel/arch/m68k/arch_thread.cpp

156

memset((void *)((addr_t)kstack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE), 0,

src/system/kernel/arch/m68k/arch_thread.cpp

207

if ((newPageDirectory % B_PAGE_SIZE) != 0)

src/system/kernel/arch/m68k/arch_vm.cpp

91

vm_free_unused_boot_loader_range(0, 0xffffffff - B_PAGE_SIZE + 1);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1073

pa &= ~(B_PAGE_SIZE - 1); // make sure it's page aligned

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1074

va &= ~(B_PAGE_SIZE - 1); // make sure it's page aligned

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1078

pt = &iospace_pgtables[(va - sIOSpaceBase) / B_PAGE_SIZE];

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1079

for (i = 0; i < NUM_PAGEENT_PER_TBL; i++, pa += B_PAGE_SIZE) {

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1093

arch_cpu_invalidate_tlb_range(0, va, va + (IOSPACE_CHUNK_SIZE - B_PAGE_SIZE));

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

113

#define NUM_USER_PGROOT_ENTS (VADDR_TO_PRENT(ROUNDUP(USER_SIZE, B_PAGE_SIZE * 64 * 128)))

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

114

#define NUM_USER_PGDIR_ENTS (VADDR_TO_PDENT(ROUNDUP(USER_SIZE, B_PAGE_SIZE * 64)))

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1248

page_hole_pgdir = (page_directory_entry *)(((unsigned int)args->arch_args.page_hole) + (B_PAGE_SIZE * 1024 - B_PAGE_SIZE));

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1267

B_PAGE_SIZE * (IOSPACE_SIZE / (B_PAGE_SIZE * NUM_PAGEENT_PER_TBL * NUM_PAGETBL_PER_PAGE)), ~0L,

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1279

memset(iospace_pgtables, 0, B_PAGE_SIZE * (IOSPACE_SIZE / (B_PAGE_SIZE * NUM_PAGEENT_PER_TBL * NUM_PAGETBL_PER_PAGE)));

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1300

for (i = 0; i < (IOSPACE_SIZE / (B_PAGE_SIZE * NUM_PAGEENT_PER_TBL));

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1346

area = create_area("kernel_pgdir", &temp, B_EXACT_ADDRESS, B_PAGE_SIZE,

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1353

B_PAGE_SIZE * (IOSPACE_SIZE / (B_PAGE_SIZE * 1024)),

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1369

B_PAGE_SIZE, 0);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1401

physicalIndirectDesc += ((addr_t)&sQueryDesc) % B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1466

tbl = vm_allocate_early_physical_page(args) * B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1471

memset((void *)tbl, 0, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1490

tbl = vm_allocate_early_physical_page(args) * B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

1495

memset((void *)tbl, 0, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

260

*_physicalAddress += va % B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

499

start = (1023) * B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

553

pgdir = page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

598

pgtable = page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

658

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

659

end = ROUNDUP(end, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

670

start = ROUNDUP(start + 1, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

685

start = ROUNDUP(start + 1, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

700

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

72

#define IOSPACE_CHUNK_SIZE (NUM_PAGEENT_PER_TBL*B_PAGE_SIZE)

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

763

*_physical += va % B_PAGE_SIZE;

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

880

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

881

end = ROUNDUP(end, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

892

start = ROUNDUP(start + 1, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

907

start = ROUNDUP(start + 1, B_PAGE_SIZE);

src/system/kernel/arch/m68k/arch_vm_translation_map_impl.cpp

922

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

164

addr_t virtualBase = vm_allocate_early(args, SLOTS_PER_POOL * B_PAGE_SIZE,

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

173

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[SLOTS_PER_POOL]);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

179

SLOTS_PER_POOL * B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

194

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[SLOTS_PER_POOL]);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

210

SLOTS_PER_POOL * B_PAGE_SIZE, 0);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

234

for (int32 i = 0; i < SLOTS_PER_POOL; i++, slotAddress += B_PAGE_SIZE) {

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

251

(virtualAddress - fVirtualBase) / B_PAGE_SIZE];

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

271

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[SLOTS_PER_POOL]);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

287

&virtualBase, B_ANY_KERNEL_BLOCK_ADDRESS, SLOTS_PER_POOL * B_PAGE_SIZE,

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

295

memset(data, 0, B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

310

int32 index = (addr_t)virtualBase / (B_PAGE_SIZE * SLOTS_PER_POOL);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

358

+ (B_PAGE_SIZE * 1024 - B_PAGE_SIZE));

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

418

area = create_area("kernel_pgdir", &temp, B_EXACT_ADDRESS, B_PAGE_SIZE,

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

435

B_PAGE_SIZE, 0);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

496

tbl = vm_allocate_early_physical_page(args) * B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

501

memset((void *)tbl, 0, B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

520

tbl = vm_allocate_early_physical_page(args) * B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

525

memset((void *)tbl, 0, B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

559

pgtable *= B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

570

+ (virtualAddress / B_PAGE_SIZE / 1024) * B_PAGE_SIZE),

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

571

0, B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

575

(fPageHole[virtualAddress / B_PAGE_SIZE] & M68K_PTE_PRESENT) == 0,

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

578

fPageHole[virtualAddress / B_PAGE_SIZE]);

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

669

memset(pageTables, 0, B_PAGE_SIZE *

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

670

(size / (B_PAGE_SIZE * NUM_PAGEENT_PER_TBL * NUM_PAGETBL_PER_PAGE)));

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

686

for (size_t i = 0; i < (size / (B_PAGE_SIZE * NUM_PAGEENT_PER_TBL));

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

750

*_physicalAddress += virtualAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KPagingMethod040.cpp

766

page_table_entry* entry = method->PageHole() + virtualAddress / B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

118

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

191

start = 1023 * B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

192

end += 1023 * B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

246

pgdir = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

297

pgtable = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

351

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

395

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

425

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

498

PageUnmapped(area, (oldEntry & M68K_PTE_ADDRESS_MASK) / B_PAGE_SIZE,

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

562

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

588

page_num_t page = (oldEntry & M68K_PTE_ADDRESS_MASK) / B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

697

->InterruptGetPageTableAt(ppr & ~(B_PAGE_SIZE-1))

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

698

+ (ppr % B_PAGE_SIZE));

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

709

->InterruptGetPageTableAt(ppd & ~(B_PAGE_SIZE-1))

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

710

+ (ppd % B_PAGE_SIZE));

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

717

->InterruptGetPageTableAt(ppt & ~(B_PAGE_SIZE-1))

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

718

+ (ppt % B_PAGE_SIZE));

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

746

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

782

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

862

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

940

(oldEntry & M68K_PTE_ADDRESS_MASK) / B_PAGE_SIZE);

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

959

uint32 offset = physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/M68KVMTranslationMap040.cpp

961

physicalAddress &= ~(B_PAGE_SIZE-1);

src/system/kernel/arch/m68k/paging/040/paging.h

114

B_PAGE_SIZE * 1024)))

src/system/kernel/arch/m68k/paging/040/paging.h

119

static const size_t kPageTableAlignment = 1024 * B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/040/paging.h

54

#define NUM_USER_PGROOT_ENTS (VADDR_TO_PRENT(ROUNDUP(USER_SIZE, B_PAGE_SIZE * 64 * 128)))

src/system/kernel/arch/m68k/paging/040/paging.h

55

#define NUM_USER_PGDIR_ENTS (VADDR_TO_PDENT(ROUNDUP(USER_SIZE, B_PAGE_SIZE * 64)))

src/system/kernel/arch/m68k/paging/040/paging.h

64

static const size_t kPageTableAlignment = B_PAGE_SIZE

src/system/kernel/arch/m68k/paging/040/paging.h

67

static const size_t kPageDirAlignment = B_PAGE_SIZE

src/system/kernel/arch/m68k/paging/040/paging.h

75

#define VADDR_TO_PDENT(va) (((va) / B_PAGE_SIZE) / 1024)

src/system/kernel/arch/m68k/paging/040/paging.h

76

#define VADDR_TO_PTENT(va) (((va) / B_PAGE_SIZE) % 1024)

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

391

ASSERT(physicalAddress % B_PAGE_SIZE == 0);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

487

ASSERT(physicalAddress % B_PAGE_SIZE == 0);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

507

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

534

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

560

*virtualAddress = fDebugSlot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

576

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

588

size_t toSet = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

607

addr_t pageOffset = from % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

618

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

647

addr_t pageOffset = to % B_PAGE_SIZE;

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

658

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/m68k/paging/m68k_physical_page_mapper_large_memory.cpp

698

memcpy((void*)toSlot->address, (void*)fromSlot->address, B_PAGE_SIZE);

src/system/kernel/arch/ppc/arch_cpu.cpp

120

start += B_PAGE_SIZE;

src/system/kernel/arch/ppc/arch_cpu.cpp

160

address += B_PAGE_SIZE;

src/system/kernel/arch/ppc/arch_int.cpp

561

addr_t inPageOffset = (addr_t)context & (B_PAGE_SIZE - 1);

src/system/kernel/arch/ppc/arch_thread.cpp

128

memset((void *)((addr_t)kstack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE), 0,

src/system/kernel/arch/ppc/arch_vm.cpp

140

vm_free_unused_boot_loader_range(0, 0xffffffff - B_PAGE_SIZE + 1);

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

313

addr_t virtualEnd = ROUNDUP(virtualAddress + size, B_PAGE_SIZE);

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

314

virtualAddress = ROUNDDOWN(virtualAddress, B_PAGE_SIZE);

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

315

physicalAddress = ROUNDDOWN(physicalAddress, B_PAGE_SIZE);

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

327

virtualAddress += B_PAGE_SIZE, physicalAddress += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

341

addr_t virtualEnd = ROUNDUP(virtualAddress + size, B_PAGE_SIZE);

src/system/kernel/arch/ppc/arch_vm_translation_map.cpp

342

virtualAddress = ROUNDDOWN(virtualAddress, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

204

area = create_area("kernel_pgdir", &temp, B_EXACT_ADDRESS, B_PAGE_SIZE,

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

306

entry->physical_page_number = physicalAddress / B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

377

memset(pageTables, 0, B_PAGE_SIZE * (size / (B_PAGE_SIZE * 1024)));

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

388

for (size_t i = 0; i < (size / (B_PAGE_SIZE * 1024));

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

389

i++, virtualTable += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

393

(address / (B_PAGE_SIZE * 1024)) + i];

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

413

page_table_entry* entry = method->PageHole() + virtualAddress / B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

47

#define IOSPACE_CHUNK_SIZE (16 * B_PAGE_SIZE)

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

55

pa &= ~(B_PAGE_SIZE - 1); // make sure it's page aligned

src/system/kernel/arch/ppc/paging/460/PPCPagingMethod460.cpp

56

va &= ~(B_PAGE_SIZE - 1); // make sure it's page aligned

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1038

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1072

vm_page* page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

112

#define MAX_VSID_BASES (B_PAGE_SIZE * 8)

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

1156

(oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

158

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

232

B_PAGE_SIZE, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

428

pgtable = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

479

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

480

end = ROUNDUP(end, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

493

start += B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

500

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

524

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

555

addr_t virtualAddress = ROUNDDOWN(*_virtualAddress, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

556

size = ROUNDUP(*_virtualAddress + size - virtualAddress, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

592

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

635

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

687

PageUnmapped(area, (oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE,

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

733

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

750

page_num_t page = (oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

803

*_outPhysical = entry->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

898

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/460/PPCVMTranslationMap460.cpp

932

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

204

area = create_area("kernel_pgdir", &temp, B_EXACT_ADDRESS, B_PAGE_SIZE,

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

306

entry->physical_page_number = physicalAddress / B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

377

memset(pageTables, 0, B_PAGE_SIZE * (size / (B_PAGE_SIZE * 1024)));

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

388

for (size_t i = 0; i < (size / (B_PAGE_SIZE * 1024));

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

389

i++, virtualTable += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

393

(address / (B_PAGE_SIZE * 1024)) + i];

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

413

page_table_entry* entry = method->PageHole() + virtualAddress / B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

47

#define IOSPACE_CHUNK_SIZE (16 * B_PAGE_SIZE)

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

55

pa &= ~(B_PAGE_SIZE - 1); // make sure it's page aligned

src/system/kernel/arch/ppc/paging/classic/PPCPagingMethodClassic.cpp

56

va &= ~(B_PAGE_SIZE - 1); // make sure it's page aligned

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1038

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1072

vm_page* page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

112

#define MAX_VSID_BASES (B_PAGE_SIZE * 8)

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

1156

(oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

158

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

232

B_PAGE_SIZE, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

428

pgtable = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

479

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

480

end = ROUNDUP(end, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

493

start += B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

500

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

524

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

555

addr_t virtualAddress = ROUNDDOWN(*_virtualAddress, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

556

size = ROUNDUP(*_virtualAddress + size - virtualAddress, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

592

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

635

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

687

PageUnmapped(area, (oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE,

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

733

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

750

page_num_t page = (oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

803

*_outPhysical = entry->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

898

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/ppc/paging/classic/PPCVMTranslationMapClassic.cpp

932

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

137

pte = (std::atomic<Pte>*)VirtFromPhys(B_PAGE_SIZE * pte->load().ppn);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

155

return pteVal.ppn * B_PAGE_SIZE;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

163

fPageTableSize(GetPageTableSize(pageTable / B_PAGE_SIZE, kernel)),

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

178

GetPageTableSize(fPageTable / B_PAGE_SIZE, fIsKernel));

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

185

FreePageTable(&reservation, fPageTable / B_PAGE_SIZE, fIsKernel);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

223

level0Range = (uint64_t)B_PAGE_SIZE * pteCount,

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

229

start = (level2Range) - B_PAGE_SIZE;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

258

.ppn = physicalAddress / B_PAGE_SIZE

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

301

for (addr_t page = start; page < end; page += B_PAGE_SIZE) {

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

318

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

380

for (addr_t start = base; start < end; start += B_PAGE_SIZE) {

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

41

Pte* pte = (Pte*)VirtFromPhys(ppn * B_PAGE_SIZE);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

437

*_physicalAddress = pteVal.ppn * B_PAGE_SIZE;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

481

for (addr_t page = base; page < top; page += B_PAGE_SIZE) {

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

70

Pte* pte = (Pte*)VirtFromPhys(ppn * B_PAGE_SIZE);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

708

uint64 va0 = ROUNDDOWN(to, B_PAGE_SIZE);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

718

uint64 n = B_PAGE_SIZE - (to - va0);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

726

to = va0 + B_PAGE_SIZE;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

740

uint64 va0 = ROUNDDOWN(from, B_PAGE_SIZE);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

756

uint64 n = B_PAGE_SIZE - (from - va0);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

764

from = va0 + B_PAGE_SIZE;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

778

uint64 va0 = ROUNDDOWN(to, B_PAGE_SIZE);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

796

uint64 n = B_PAGE_SIZE - (to - va0);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

803

to = va0 + B_PAGE_SIZE;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

935

user_memcpy(VirtFromPhys(to), VirtFromPhys(from), B_PAGE_SIZE);

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.cpp

97

fPageTable = page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/riscv64/RISCV64VMTranslationMap.h

119

satp.ppn = fPageTable / B_PAGE_SIZE;

src/system/kernel/arch/riscv64/arch_cpu.cpp

114

int64 numPages = kernelStart / B_PAGE_SIZE - kernelEnd / B_PAGE_SIZE;

src/system/kernel/arch/riscv64/arch_cpu.cpp

117

start += B_PAGE_SIZE;

src/system/kernel/arch/riscv64/arch_cpu.cpp

122

int64 numPages = userStart / B_PAGE_SIZE - userEnd / B_PAGE_SIZE;

src/system/kernel/arch/riscv64/arch_cpu.cpp

125

start += B_PAGE_SIZE;

src/system/kernel/arch/riscv64/arch_vm.cpp

149

DumpPageTableInt((Pte*)VirtFromPhys(B_PAGE_SIZE*pte[i].ppn),

src/system/kernel/arch/riscv64/arch_vm.cpp

155

pte[i].ppn * B_PAGE_SIZE, 1 << (pageBits + pteIdxBits * level),

src/system/kernel/arch/riscv64/arch_vm.cpp

212

Pte* root = (Pte*)VirtFromPhys(satp.ppn * B_PAGE_SIZE);

src/system/kernel/arch/riscv64/arch_vm.cpp

215

for (; size > 0; base += B_PAGE_SIZE, size -= B_PAGE_SIZE) {

src/system/kernel/arch/riscv64/arch_vm.cpp

216

Pte* pte = LookupPte(satp.ppn * B_PAGE_SIZE, base);

src/system/kernel/arch/riscv64/arch_vm.cpp

220

dumper.Write(base, pte->ppn * B_PAGE_SIZE, B_PAGE_SIZE, pte->val & 0xff);

src/system/kernel/arch/riscv64/arch_vm.cpp

258

virt = ROUNDDOWN(virt, B_PAGE_SIZE);

src/system/kernel/arch/riscv64/arch_vm.cpp

260

Pte* pte = LookupPte(satp.ppn * B_PAGE_SIZE, virt);

src/system/kernel/arch/riscv64/arch_vm.cpp

267

dumper.Write(virt, pte->ppn * B_PAGE_SIZE, B_PAGE_SIZE, pte->val & 0xff);

src/system/kernel/arch/riscv64/arch_vm.cpp

343

vm_free_unused_boot_loader_range(0, 0xffffffff - B_PAGE_SIZE + 1);

src/system/kernel/arch/riscv64/arch_vm.cpp

43

pte = (Pte*)VirtFromPhys(B_PAGE_SIZE * pte->ppn);

src/system/kernel/arch/riscv64/arch_vm_translation_map.cpp

131

sPageTable = SatpReg{.val = Satp()}.ppn * B_PAGE_SIZE;

src/system/kernel/arch/riscv64/arch_vm_translation_map.cpp

56

memset((Pte*)VirtFromPhys(B_PAGE_SIZE * ppn), 0, B_PAGE_SIZE);

src/system/kernel/arch/riscv64/arch_vm_translation_map.cpp

64

pte = (Pte*)VirtFromPhys(B_PAGE_SIZE * pte->ppn);

src/system/kernel/arch/riscv64/arch_vm_translation_map.cpp

83

.ppn = physAdr / B_PAGE_SIZE

src/system/kernel/arch/sparc/arch_thread.cpp

55

memset((void *)((addr_t)kstack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE), 0,

src/system/kernel/arch/sparc/arch_vm.cpp

81

vm_free_unused_boot_loader_range(0, 0xffffffff - B_PAGE_SIZE + 1);

src/system/kernel/arch/x86/32/apm.cpp

323

B_PAGE_SIZE - biosData, DT_DATA_WRITEABLE, DPL_KERNEL);

src/system/kernel/arch/x86/32/apm.cpp

346

args->platform_args.apm.data_segment_length = B_PAGE_SIZE

src/system/kernel/arch/x86/32/thread.cpp

115

STATIC_ASSERT(MAX_RANDOM_VALUE >= B_PAGE_SIZE - 1);

src/system/kernel/arch/x86/32/thread.cpp

116

value -= random_value() & (B_PAGE_SIZE - 1);

src/system/kernel/arch/x86/64/thread.cpp

108

static_assert(MAX_RANDOM_VALUE >= B_PAGE_SIZE - 1,

src/system/kernel/arch/x86/64/thread.cpp

110

value -= random_value() & (B_PAGE_SIZE - 1);

src/system/kernel/arch/x86/apic.cpp

301

B_EXACT_ADDRESS, B_PAGE_SIZE,

src/system/kernel/arch/x86/arch_cpu.cpp

2016

start += B_PAGE_SIZE;

src/system/kernel/arch/x86/arch_vm.cpp

168

for (uint64 interval = B_PAGE_SIZE; size > 0; interval <<= 1) {

src/system/kernel/arch/x86/arch_vm.cpp

241

uint64 interval = B_PAGE_SIZE * 2;

src/system/kernel/arch/x86/arch_vm.cpp

723

vm_mark_page_range_inuse(0x0, 0xa0000 / B_PAGE_SIZE);

src/system/kernel/arch/x86/ioapic.cpp

336

: B_ANY_KERNEL_ADDRESS, B_PAGE_SIZE, B_KERNEL_READ_AREA

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

101

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

111

_EarlyPreparePageTables(pageTable, virtualBase, 1024 * B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

125

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

141

1024 * B_PAGE_SIZE, 0);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

165

for (int32 i = 0; i < 1024; i++, slotAddress += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

182

(virtualAddress - fVirtualBase) / B_PAGE_SIZE];

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

202

size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

218

&virtualBase, B_ANY_KERNEL_BLOCK_ADDRESS, 1024 * B_PAGE_SIZE,

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

226

memset(data, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

238

int32 index = (addr_t)virtualBase / (B_PAGE_SIZE * 1024);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

294

+ (B_PAGE_SIZE * 1024 - B_PAGE_SIZE));

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

358

area = create_area("kernel_pgdir", &temp, B_EXACT_ADDRESS, B_PAGE_SIZE,

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

412

pgtable *= B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

423

+ (virtualAddress / B_PAGE_SIZE / 1024) * B_PAGE_SIZE),

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

424

0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

428

(fPageHole[virtualAddress / B_PAGE_SIZE] & X86_PTE_PRESENT) == 0,

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

431

fPageHole[virtualAddress / B_PAGE_SIZE]);

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

434

PutPageTableEntryInTable(fPageHole + virtualAddress / B_PAGE_SIZE,

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

558

memset(pageTables, 0, B_PAGE_SIZE * (size / (B_PAGE_SIZE * 1024)));

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

569

for (size_t i = 0; i < (size / (B_PAGE_SIZE * 1024));

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

570

i++, virtualTable += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

574

(address / (B_PAGE_SIZE * 1024)) + i];

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

594

page_table_entry* entry = method->PageHole() + virtualAddress / B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/32bit/X86PagingMethod32Bit.cpp

92

addr_t virtualBase = vm_allocate_early(args, 1024 * B_PAGE_SIZE, 0, 0,

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

101

B_PAGE_SIZE, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

133

start = 1023 * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

134

end += 1023 * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

169

pgtable = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

217

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

241

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

270

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

329

PageUnmapped(area, (oldEntry & X86_PTE_ADDRESS_MASK) / B_PAGE_SIZE,

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

380

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

397

page_num_t page = (oldEntry & X86_PTE_ADDRESS_MASK) / B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

511

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

545

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

622

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

64

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/X86VMTranslationMap32Bit.cpp

699

(oldEntry & X86_PTE_ADDRESS_MASK) / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/32bit/paging.h

19

#define VADDR_TO_PDENT(va) (((va) / B_PAGE_SIZE) / 1024)

src/system/kernel/arch/x86/paging/32bit/paging.h

20

#define VADDR_TO_PTENT(va) (((va) / B_PAGE_SIZE) % 1024)

src/system/kernel/arch/x86/paging/32bit/paging.h

58

B_PAGE_SIZE * 1024)))

src/system/kernel/arch/x86/paging/32bit/paging.h

63

static const size_t kPageTableAlignment = 1024 * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

102

B_EXACT_ADDRESS, B_PAGE_SIZE, B_ALREADY_WIRED,

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

155

phys_addr_t physicalPageDir = vm_allocate_early_physical_page(args) * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

169

memset(virtualPageDir, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

179

phys_addr_t physicalPageTable = vm_allocate_early_physical_page(args) * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

193

memset(virtualPageTable, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

246

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

277

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

307

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86PagingMethod64Bit.cpp

370

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

109

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

120

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

132

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

186

uint64* virtualPMLTop = (uint64*)memalign(B_PAGE_SIZE, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

189

memset(virtualPMLTop, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

215

start = (fLA57 ? k64BitPML4TRange : k64BitPDPTRange) - B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

273

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

292

for (uint32 index = start / B_PAGE_SIZE % k64BitTableEntryCount;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

294

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

323

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

376

PageUnmapped(area, (oldEntry & X86_64_PTE_ADDRESS_MASK) / B_PAGE_SIZE,

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

420

for (uint32 index = start / B_PAGE_SIZE % k64BitTableEntryCount;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

422

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

439

page_num_t page = (oldEntry & X86_64_PTE_ADDRESS_MASK) / B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

533

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

565

for (uint32 index = start / B_PAGE_SIZE % k64BitTableEntryCount;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

567

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

636

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

705

(oldEntry & X86_64_PTE_ADDRESS_MASK) / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

784

+ l * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/64bit/X86VMTranslationMap64Bit.cpp

98

page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/64bit/paging.h

91

#define VADDR_TO_PTE(va) (((va) % k64BitPageTableRange) / B_PAGE_SIZE)

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

144

_TranslatePageTable((addr_t)i * 1024 * B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

145

_TranslatePageTable(((addr_t)i * 1024 + 512) * B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

166

_pageStructuresSize = (size_t)fUsedPagesCount * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

189

page_table_entry* entry = &fPageHole[virtualBase / B_PAGE_SIZE];

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

206

&& _IsVirtualAddressAllocated(virtualBase + i * B_PAGE_SIZE)) {

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

223

+ fFreeVirtualSlot / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

229

size_t virtualSize = ROUNDUP(pagesNeeded, 1024) * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

241

uint32 oldPageTableCount = virtualSize / B_PAGE_SIZE / 1024;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

248

virtualBase / B_PAGE_SIZE / 1024 + i];

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

254

+ (virtualBase / B_PAGE_SIZE / 1024 + i) * B_PAGE_SIZE),

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

255

0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

267

page_table_entry* entry = fPageHole + virtualBase / B_PAGE_SIZE + i;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

274

*(phys_addr_t*)(virtualBase + i * B_PAGE_SIZE) = physicalAddress;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

281

= (addr_t)(fAllocatedPages + pagesNeeded * B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

288

* B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

305

void* page = fAllocatedPages + (fUsedPagesCount++) * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

309

memset(page, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

400

size_t areaSize = B_PAGE_SIZE

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

411

memset(pageTable, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

433

size_t areaSize = B_PAGE_SIZE

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

475

i++, slotAddress += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

492

(virtualAddress - fVirtualBase) / B_PAGE_SIZE];

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

512

size_t areaSize = B_PAGE_SIZE

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

537

memset(data, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

685

phys_addr_t physicalPageTable = vm_allocate_early_physical_page(args) * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

695

memset(pageTable, 0, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

703

+ virtualAddress / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

72

+ (B_PAGE_SIZE * 1024 - B_PAGE_SIZE));

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

774

virtualAddress / B_PAGE_SIZE % kPAEPageTableEntryCount];

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

866

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

891

vm_page* page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86PagingMethodPAE.cpp

930

+ virtualAddress / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

1036

size_t pteIndex = virtualAddress / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

1106

+ pteIndex * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

259

vm_page* page = vm_lookup_page(address / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

317

virtualPageDirs[0] = (pae_page_directory_entry*)memalign(B_PAGE_SIZE,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

318

2 * B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

324

memset(virtualPageDirs[0], 0, 2 * B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

371

start = kPAEPageTableRange - B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

372

end += kPAEPageTableRange - B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

398

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

421

+ virtualAddress / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

446

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

471

uint32 index = start / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

473

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

506

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

527

&pageTable[address / B_PAGE_SIZE % kPAEPageTableEntryCount]);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

568

PageUnmapped(area, (oldEntry & X86_PAE_PTE_ADDRESS_MASK) / B_PAGE_SIZE,

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

619

uint32 index = start / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

621

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

640

page_num_t page = (oldEntry & X86_PAE_PTE_ADDRESS_MASK) / B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

693

= pageTable[virtualAddress / B_PAGE_SIZE % kPAEPageTableEntryCount];

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

744

= pageTable[virtualAddress / B_PAGE_SIZE % kPAEPageTableEntryCount];

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

774

start = ROUNDDOWN(start, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

813

uint32 index = start / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

815

index++, start += B_PAGE_SIZE) {

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

878

+ address / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

899

ASSERT(address % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

918

+ address / B_PAGE_SIZE % kPAEPageTableEntryCount;

src/system/kernel/arch/x86/paging/pae/X86VMTranslationMapPAE.cpp

981

(oldEntry & X86_PAE_PTE_ADDRESS_MASK) / B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/pae/paging.h

61

static const size_t kPAEPageTableRange = kPAEPageTableEntryCount * B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

384

ASSERT(physicalAddress % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

484

ASSERT(physicalAddress % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

504

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

531

*virtualAddress = slot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

557

*virtualAddress = fDebugSlot->address + physicalAddress % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

573

addr_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

585

size_t toSet = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

604

addr_t pageOffset = from % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

615

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

644

addr_t pageOffset = to % B_PAGE_SIZE;

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

655

size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_large_memory.cpp

695

memcpy((void*)toSlot->address, (void*)fromSlot->address, B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_mapped.h

191

B_PAGE_SIZE);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_mapped.h

49

ASSERT(physicalAddress % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/paging/x86_physical_page_mapper_mapped.h

75

ASSERT(physicalAddress % B_PAGE_SIZE == 0);

src/system/kernel/arch/x86/timers/x86_hpet.cpp

227

(void **)&sHPETRegs, B_EXACT_ADDRESS, B_PAGE_SIZE,

src/system/kernel/cache/block_cache.cpp

2935

if ((block_cache_used_memory() / B_PAGE_SIZE)

src/system/kernel/cache/file_cache.cpp

1060

offset = ROUNDDOWN(offset, B_PAGE_SIZE);

src/system/kernel/cache/file_cache.cpp

1061

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/kernel/cache/file_cache.cpp

1063

const size_t pagesCount = size / B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

1068

|| (3 * cache->page_count) > (2 * fileSize / B_PAGE_SIZE)) {

src/system/kernel/cache/file_cache.cpp

1086

offset += B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

1087

size -= B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

109

static const size_t kZeroVecSize = kZeroVecCount * B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

1090

bytesToRead += B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

1211

sZeroPage = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

1215

sZeroVecs[i].length = B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

127

fPageCount = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

158

for (generic_size_t pos = 0; pos < fSize; pos += B_PAGE_SIZE) {

src/system/kernel/cache/file_cache.cpp

167

page->physical_page_number * B_PAGE_SIZE, B_PAGE_SIZE);

src/system/kernel/cache/file_cache.cpp

194

= (bytesTransferred + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

203

&& (bytesTransferred % B_PAGE_SIZE) != 0) {

src/system/kernel/cache/file_cache.cpp

205

size_t bytesTouched = bytesTransferred % B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

209

0, B_PAGE_SIZE - bytesTouched);

src/system/kernel/cache/file_cache.cpp

404

for (generic_size_t pos = 0; pos < numBytes; pos += B_PAGE_SIZE) {

src/system/kernel/cache/file_cache.cpp

413

page->physical_page_number * B_PAGE_SIZE, B_PAGE_SIZE);

src/system/kernel/cache/file_cache.cpp

450

size_t bytes = min_c(bufferSize, (size_t)B_PAGE_SIZE - pageOffset);

src/system/kernel/cache/file_cache.cpp

453

pages[i]->physical_page_number * B_PAGE_SIZE + pageOffset,

src/system/kernel/cache/file_cache.cpp

537

for (generic_size_t pos = 0; pos < numBytes; pos += B_PAGE_SIZE) {

src/system/kernel/cache/file_cache.cpp

555

page->physical_page_number * B_PAGE_SIZE, B_PAGE_SIZE);

src/system/kernel/cache/file_cache.cpp

567

generic_io_vec readVec = { vecs[0].base, B_PAGE_SIZE };

src/system/kernel/cache/file_cache.cpp

568

generic_size_t bytesRead = B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

577

size_t lastPageOffset = (pageOffset + bufferSize) % B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

581

+ vecs[vecCount - 1].length - B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

586

B_PAGE_SIZE - lastPageOffset);

src/system/kernel/cache/file_cache.cpp

590

generic_io_vec readVec = { last, B_PAGE_SIZE };

src/system/kernel/cache/file_cache.cpp

591

generic_size_t bytesRead = B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

594

PAGE_ALIGN(offset + pageOffset + bufferSize) - B_PAGE_SIZE,

src/system/kernel/cache/file_cache.cpp

600

if (bytesRead < B_PAGE_SIZE) {

src/system/kernel/cache/file_cache.cpp

603

B_PAGE_SIZE - bytesRead);

src/system/kernel/cache/file_cache.cpp

675

if (length > B_PAGE_SIZE) {

src/system/kernel/cache/file_cache.cpp

676

length = ROUNDDOWN(length, B_PAGE_SIZE);

src/system/kernel/cache/file_cache.cpp

677

count = length / B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

744

+ lastPageOffset + B_PAGE_SIZE - 1) >> PAGE_SHIFT);

src/system/kernel/cache/file_cache.cpp

777

int32 pageOffset = offset & (B_PAGE_SIZE - 1);

src/system/kernel/cache/file_cache.cpp

784

const uint32 kMaxChunkSize = MAX_IO_VECS * B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

787

+ B_PAGE_SIZE - 1) >> PAGE_SHIFT);

src/system/kernel/cache/file_cache.cpp

840

size_t bytesInPage = min_c(size_t(B_PAGE_SIZE - pageOffset), bytesLeft);

src/system/kernel/cache/file_cache.cpp

857

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE

src/system/kernel/cache/file_cache.cpp

906

lastOffset = offset + B_PAGE_SIZE;

src/system/kernel/cache/file_cache.cpp

925

offset += B_PAGE_SIZE;

src/system/kernel/cache/vnode_store.cpp

52

return ROUNDUP(offset, B_PAGE_SIZE) >= virtual_base

src/system/kernel/debug/BreakpointManager.cpp

662

int32 maxRead = B_PAGE_SIZE - (addr_t)address % B_PAGE_SIZE;

src/system/kernel/debug/core_dump.cpp

1000

size_t ramSize = (size_t)cache->page_count * B_PAGE_SIZE;

src/system/kernel/debug/core_dump.cpp

1292

writer.Write((size_t)B_PAGE_SIZE);

src/system/kernel/debug/core_dump.cpp

1303

writer.Write(size_t(areaInfo->CacheOffset() / B_PAGE_SIZE));

src/system/kernel/debug/core_dump.cpp

686

size = size / B_PAGE_SIZE * B_PAGE_SIZE;

src/system/kernel/debug/core_dump.cpp

690

if (fBuffered + B_PAGE_SIZE > fCapacity) {

src/system/kernel/debug/core_dump.cpp

696

if (user_memcpy(fBuffer + fBuffered, data, B_PAGE_SIZE) != B_OK)

src/system/kernel/debug/core_dump.cpp

697

memset(fBuffer + fBuffered, 0, B_PAGE_SIZE);

src/system/kernel/debug/core_dump.cpp

699

fBuffered += B_PAGE_SIZE;

src/system/kernel/debug/core_dump.cpp

700

data += B_PAGE_SIZE;

src/system/kernel/debug/core_dump.cpp

701

size -= B_PAGE_SIZE;

src/system/kernel/debug/core_dump.cpp

861

fFirstAreaSegmentOffset = (notesEndOffset + B_PAGE_SIZE - 1)

src/system/kernel/debug/core_dump.cpp

862

/ B_PAGE_SIZE * B_PAGE_SIZE;

src/system/kernel/debug/debug.cpp

1392

void* base = (void*)ROUNDDOWN((addr_t)(void *)args->debug_output, B_PAGE_SIZE);

src/system/kernel/debug/debug.cpp

1393

size_t size = ROUNDUP(args->debug_size, B_PAGE_SIZE);

src/system/kernel/debug/debug.cpp

1895

addr_t endAddress = ROUNDUP(address + size, B_PAGE_SIZE);

src/system/kernel/debug/debug.cpp

1896

address = ROUNDDOWN(address, B_PAGE_SIZE);

src/system/kernel/debug/debug.cpp

1901

for (; address < endAddress; address += B_PAGE_SIZE) {

src/system/kernel/debug/debug.cpp

1980

if (((addr_t)from + toCopy) % B_PAGE_SIZE < toCopy)

src/system/kernel/debug/debug.cpp

1981

toCopy -= ((addr_t)from + toCopy) % B_PAGE_SIZE;

src/system/kernel/debug/debug.cpp

1982

if (((addr_t)to + toCopy) % B_PAGE_SIZE < toCopy)

src/system/kernel/debug/debug.cpp

1983

toCopy -= ((addr_t)to + toCopy) % B_PAGE_SIZE;

src/system/kernel/debug/debug.cpp

2045

if (((addr_t)from + toCopy) % B_PAGE_SIZE < toCopy)

src/system/kernel/debug/debug.cpp

2046

toCopy -= ((addr_t)from + toCopy) % B_PAGE_SIZE;

src/system/kernel/debug/debug.cpp

2047

if (((addr_t)to + toCopy) % B_PAGE_SIZE < toCopy)

src/system/kernel/debug/debug.cpp

2048

toCopy -= ((addr_t)to + toCopy) % B_PAGE_SIZE;

src/system/kernel/debug/debug_heap.cpp

15

#define INITIAL_DEBUG_HEAP_SIZE B_PAGE_SIZE

src/system/kernel/debug/guarded_heap.cpp

128

size_t growSize = ROUNDUP(((kernel_guarded_heap.grow_size / B_PAGE_SIZE) / 2)

src/system/kernel/debug/guarded_heap.cpp

130

B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

182

size_t growPages = kernel_guarded_heap.grow_size / B_PAGE_SIZE;

src/system/kernel/debug/guarded_heap.cpp

214

if (addressSpace->InsertArea(area, growPages * B_PAGE_SIZE,

src/system/kernel/debug/guarded_heap.cpp

225

chunk->pages_count = area->Size() / B_PAGE_SIZE;

src/system/kernel/debug/guarded_heap.cpp

242

< (chunk->base + chunk->pages_count * B_PAGE_SIZE))

src/system/kernel/debug/guarded_heap.cpp

259

if (heap.free_pages_count <= (kernel_guarded_heap.grow_size / B_PAGE_SIZE / 2))

src/system/kernel/debug/guarded_heap.cpp

274

const size_t neededPages = ((alignedSize + B_PAGE_SIZE - 1) / B_PAGE_SIZE) + guardPages;

src/system/kernel/debug/guarded_heap.cpp

311

freeChunk->base += neededPages * B_PAGE_SIZE;

src/system/kernel/debug/guarded_heap.cpp

324

+ (chunk->pages_count - guardPages) * B_PAGE_SIZE

src/system/kernel/debug/guarded_heap.cpp

349

if (vm_try_reserve_memory(mapPages * B_PAGE_SIZE, VM_PRIORITY_SYSTEM,

src/system/kernel/debug/guarded_heap.cpp

357

chunk->base + mapPages * B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

365

addr_t mapAddress = chunk->base + i * B_PAGE_SIZE;

src/system/kernel/debug/guarded_heap.cpp

369

map->Map(mapAddress, page->physical_page_number * B_PAGE_SIZE,

src/system/kernel/debug/guarded_heap.cpp

442

+ chunk->pages_count * B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

450

guarded_heap_free_page(heap, chunk->base + i * B_PAGE_SIZE, &reservation);

src/system/kernel/debug/guarded_heap.cpp

453

vm_unreserve_memory(reservation.count * B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

463

chunk->base + chunk->pages_count * B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

712

size_t metaSize = ROUNDUP(((size / B_PAGE_SIZE) / 2) * sizeof(GuardedHeapChunk), B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

722

chunk->pages_count = sGuardedHeapEarlySize / B_PAGE_SIZE;

src/system/kernel/debug/guarded_heap.cpp

780

addr_t unmap = chunk->base + (chunk->pages_count - 1) * B_PAGE_SIZE;

src/system/kernel/debug/guarded_heap.cpp

781

map->Unmap(unmap, unmap + B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

790

addr_t pageAddress = chunk->base + i * B_PAGE_SIZE;

src/system/kernel/debug/guarded_heap.cpp

791

map->Unmap(pageAddress, pageAddress + B_PAGE_SIZE);

src/system/kernel/debug/guarded_heap.cpp

824

vm_unreserve_memory(reservation.count * B_PAGE_SIZE);

src/system/kernel/debug/heap.cpp

1040

area->base = ROUNDUP(base, B_PAGE_SIZE);

src/system/kernel/debug/heap.cpp

1041

area->size = size & ~(B_PAGE_SIZE - 1);

src/system/kernel/debug/heap.cpp

1539

if (alignment < B_PAGE_SIZE) {

src/system/kernel/debug/heap.cpp

167

B_PAGE_SIZE / 8, /* max allocation size */

src/system/kernel/debug/heap.cpp

168

B_PAGE_SIZE, /* page size */

src/system/kernel/debug/heap.cpp

177

B_PAGE_SIZE * 2, /* max allocation size */

src/system/kernel/debug/heap.cpp

178

B_PAGE_SIZE * 8, /* page size */

src/system/kernel/debug/heap.cpp

179

B_PAGE_SIZE / 8, /* min bin size */

src/system/kernel/debug/heap.cpp

188

B_PAGE_SIZE * 16, /* page size */

src/system/kernel/debug/heap.cpp

189

B_PAGE_SIZE * 2, /* min bin size */

src/system/kernel/debug/heap.cpp

2085

B_PAGE_SIZE / 8, /* max allocation size */

src/system/kernel/debug/heap.cpp

2086

B_PAGE_SIZE, /* page size */

src/system/kernel/debug/heap.cpp

2202

+ alignment, B_PAGE_SIZE);

src/system/kernel/debug/heaps.cpp

118

kernel_guarded_heap.memalign(0, B_PAGE_SIZE, 0);

src/system/kernel/debug/heaps.cpp

119

memset(sGuardedHeapForObjectCaches, 0, B_PAGE_SIZE);

src/system/kernel/debug/heaps.cpp

55

while (heapSize > (vm_page_num_pages() * B_PAGE_SIZE) / 8)

src/system/kernel/debug/tracing.cpp

463

if (get_memory_map(metaData->fTraceOutputBuffer, B_PAGE_SIZE,

src/system/kernel/debug/tracing.cpp

503

physicalRestrictions.high_address = metaDataAddress + B_PAGE_SIZE;

src/system/kernel/debug/tracing.cpp

505

B_PAGE_SIZE, B_FULL_LOCK, B_KERNEL_READ_AREA | B_KERNEL_WRITE_AREA,

src/system/kernel/debug/tracing.cpp

575

+ ROUNDUP(kTraceOutputBufferSize + MAX_TRACE_SIZE, B_PAGE_SIZE);

src/system/kernel/device_manager/IOCache.cpp

277

page_num_t firstPageOffset = lineOffset / B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

278

page_num_t linePageCount = (lineSize + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

372

fCache->InsertPage(fPages[index], (off_t)pageOffset * B_PAGE_SIZE);

src/system/kernel/device_manager/IOCache.cpp

380

|| requestOffset < (off_t)firstMissing * B_PAGE_SIZE

src/system/kernel/device_manager/IOCache.cpp

382

> (off_t)(lastMissing + 1) * B_PAGE_SIZE) {

src/system/kernel/device_manager/IOCache.cpp

389

B_PRIuSIZE ")\n", (off_t)firstMissing * B_PAGE_SIZE,

src/system/kernel/device_manager/IOCache.cpp

390

(size_t)missingPages * B_PAGE_SIZE, requestOffset,

src/system/kernel/device_manager/IOCache.cpp

419

page_num_t firstPage = (requestOffset - lineOffset) / B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

421

+ B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

46

fPagesPerLine(cacheLineSize / B_PAGE_SIZE),

src/system/kernel/device_manager/IOCache.cpp

527

* B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

529

firstPageOffset + (off_t)pageCount * B_PAGE_SIZE, fDeviceCapacity)

src/system/kernel/device_manager/IOCache.cpp

538

= (phys_addr_t)fPages[i]->physical_page_number * B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

541

fVecs[vecCount++].length = B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

542

vecsEndAddress = pageAddress + B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

545

fVecs[vecCount - 1].length += B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

546

vecsEndAddress += B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

552

generic_size_t padLength = B_PAGE_SIZE - requestLength % B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

553

if (vecCount > 0 && padLength != B_PAGE_SIZE)

src/system/kernel/device_manager/IOCache.cpp

56

if (cacheLineSize < B_PAGE_SIZE

src/system/kernel/device_manager/IOCache.cpp

669

size_t firstPage = pagesRelativeOffset / B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

670

size_t endPage = (pagesRelativeOffset + requestLength + B_PAGE_SIZE - 1)

src/system/kernel/device_manager/IOCache.cpp

671

/ B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

680

size_t inPageOffset = pagesRelativeOffset % B_PAGE_SIZE;

src/system/kernel/device_manager/IOCache.cpp

686

fPages[i]->physical_page_number * B_PAGE_SIZE, &address,

src/system/kernel/device_manager/IOCache.cpp

692

size_t toCopy = std::min(B_PAGE_SIZE - inPageOffset, requestLength);

src/system/kernel/device_manager/IOCache.cpp

756

translationMap->Map((addr_t)fAreaBase + i * B_PAGE_SIZE,

src/system/kernel/device_manager/IOCache.cpp

757

page->physical_page_number * B_PAGE_SIZE,

src/system/kernel/device_manager/IOCache.cpp

785

translationMap->Unmap((addr_t)fAreaBase + firstPage * B_PAGE_SIZE,

src/system/kernel/device_manager/IOCache.cpp

786

(addr_t)fAreaBase + endPage * B_PAGE_SIZE - 1);

src/system/kernel/device_manager/IORequest.cpp

168

&& (fVecCount > 1 || fVecs[0].length > B_PAGE_SIZE)) {

src/system/kernel/device_manager/IORequest.cpp

191

const size_t pageOffset = address % B_PAGE_SIZE;

src/system/kernel/device_manager/IORequest.cpp

201

B_PAGE_SIZE - pageOffset);

src/system/kernel/device_manager/dma_resources.cpp

246

phys_size_t size = ROUNDUP(fBounceBufferSize, B_PAGE_SIZE);

src/system/kernel/device_manager/dma_resources.cpp

29

const phys_size_t kMaxBounceBufferSize = 4 * B_PAGE_SIZE;

src/system/kernel/elf.cpp

1939

B_PAGE_SIZE) + delta);

src/system/kernel/elf.cpp

1944

size_t memUpperBound = (programHeaders[i].p_vaddr % B_PAGE_SIZE)

src/system/kernel/elf.cpp

1946

size_t fileUpperBound = (programHeaders[i].p_vaddr % B_PAGE_SIZE)

src/system/kernel/elf.cpp

1949

memUpperBound = ROUNDUP(memUpperBound, B_PAGE_SIZE);

src/system/kernel/elf.cpp

1950

fileUpperBound = ROUNDUP(fileUpperBound, B_PAGE_SIZE);

src/system/kernel/elf.cpp

1958

ROUNDDOWN(programHeaders[i].p_offset, B_PAGE_SIZE));

src/system/kernel/elf.cpp

1974

+ (programHeaders[i].p_vaddr % B_PAGE_SIZE)

src/system/kernel/elf.cpp

1977

- (programHeaders[i].p_vaddr % B_PAGE_SIZE)

src/system/kernel/elf.cpp

2007

+ (programHeaders[i].p_vaddr % B_PAGE_SIZE), B_PAGE_SIZE);

src/system/kernel/elf.cpp

2013

ROUNDDOWN(programHeaders[i].p_offset, B_PAGE_SIZE));

src/system/kernel/elf.cpp

2207

+ (programHeaders[i].p_vaddr % B_PAGE_SIZE), B_PAGE_SIZE);

src/system/kernel/elf.cpp

2210

B_PAGE_SIZE);

src/system/kernel/elf.cpp

2306

programHeaders[i].p_vaddr, B_PAGE_SIZE);

src/system/kernel/elf.cpp

2308

+ (programHeaders[i].p_vaddr % B_PAGE_SIZE), B_PAGE_SIZE);

src/system/kernel/elf.cpp

2318

region->delta = -ROUNDDOWN(programHeaders[i].p_vaddr, B_PAGE_SIZE);

src/system/kernel/elf.cpp

2324

(void *)(region->start + (programHeaders[i].p_vaddr % B_PAGE_SIZE)),

src/system/kernel/fs/fd.cpp

43

static const size_t kMaxReadDirBufferSize = B_PAGE_SIZE * 2;

src/system/kernel/fs/vfs.cpp

3358

(vnode->cache->virtual_end + B_PAGE_SIZE - 1) / B_PAGE_SIZE,

src/system/kernel/low_resource_manager.cpp

374

if (requirements <= (kCriticalPagesLimit * B_PAGE_SIZE))

src/system/kernel/low_resource_manager.cpp

376

else if (requirements <= (kWarnPagesLimit * B_PAGE_SIZE))

src/system/kernel/low_resource_manager.cpp

423

off_t totalMemory = (off_t)vm_page_num_pages() * B_PAGE_SIZE;

src/system/kernel/messaging/MessagingService.cpp

33

static const int32 kMessagingAreaSize = B_PAGE_SIZE * 4;

src/system/kernel/slab/MemoryManager.cpp

1388

area->reserved_memory_for_mapping = pagesNeededToMap * B_PAGE_SIZE;

src/system/kernel/slab/MemoryManager.cpp

1512

size_t reservedPages = size / B_PAGE_SIZE

src/system/kernel/slab/MemoryManager.cpp

1531

offset += B_PAGE_SIZE) {

src/system/kernel/slab/MemoryManager.cpp

1540

page->physical_page_number * B_PAGE_SIZE,

src/system/kernel/slab/MemoryManager.cpp

1573

atomic_add(&gMappedPagesCount, -(size / B_PAGE_SIZE));

src/system/kernel/slab/MemoryManager.cpp

1578

addr_t areaPageOffset = (address - vmArea->Base()) / B_PAGE_SIZE;

src/system/kernel/slab/MemoryManager.cpp

1579

addr_t areaPageEndOffset = areaPageOffset + size / B_PAGE_SIZE;

src/system/kernel/slab/MemoryManager.h

217

= ROUNDUP(sizeof(Area), B_PAGE_SIZE);

src/system/kernel/slab/MemoryManager.h

27

#define SLAB_CHUNK_SIZE_SMALL B_PAGE_SIZE

src/system/kernel/slab/MemoryManager.h

28

#define SLAB_CHUNK_SIZE_MEDIUM (16 * B_PAGE_SIZE)

src/system/kernel/slab/MemoryManager.h

29

#define SLAB_CHUNK_SIZE_LARGE (128 * B_PAGE_SIZE)

src/system/kernel/slab/MemoryManager.h

30

#define SLAB_AREA_SIZE (2048 * B_PAGE_SIZE)

src/system/kernel/slab/MemoryManager.h

32

#define SLAB_AREA_STRUCT_OFFSET B_PAGE_SIZE

src/system/kernel/smp.cpp

1406

size_t size = ROUNDUP(sNumCPUs * MSG_ALLOCATE_PER_CPU * sizeof(smp_msg), B_PAGE_SIZE);

src/system/kernel/team.cpp

172

static const size_t kTeamUserDataReservedSize = 128 * B_PAGE_SIZE;

src/system/kernel/team.cpp

173

static const size_t kTeamUserDataInitialSize = 4 * B_PAGE_SIZE;

src/system/kernel/team.cpp

3583

team->user_data_size + B_PAGE_SIZE) != B_OK) {

src/system/kernel/team.cpp

3589

team->user_data_size += B_PAGE_SIZE;

src/system/kernel/thread.cpp

197

const addr_t stackStart = base + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/kernel/thread.cpp

228

KERNEL_STACK_SIZE + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE,

src/system/kernel/thread.cpp

230

| B_KERNEL_STACK_AREA, 0, KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE,

src/system/kernel/thread.cpp

236

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE;

src/system/kernel/thread.cpp

866

memset((void*)(stack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE), 0xcc,

src/system/kernel/vm/VMAnonymousCache.cpp

1014

off_t pos = (off_t)(slotIndex - swapFile->first_slot) * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

1036

return atomic_get64(&sAvailableSwapSpace) > B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

1070

if (fCommittedSize / B_PAGE_SIZE > page_count)

src/system/kernel/vm/VMAnonymousCache.cpp

1076

if (vm_try_reserve_memory_or_swap(B_PAGE_SIZE, priority, 0) != B_OK) {

src/system/kernel/vm/VMAnonymousCache.cpp

1078

"reserve %d bytes of RAM.\n", this, (int)B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousCache.cpp

1082

fCommittedSize += B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

1281

& ~(off_t)(B_PAGE_SIZE * SWAP_BLOCK_PAGES - 1);

src/system/kernel/vm/VMAnonymousCache.cpp

1283

offset += B_PAGE_SIZE * SWAP_BLOCK_PAGES) {

src/system/kernel/vm/VMAnonymousCache.cpp

1340

source->fAllocatedSwapSize -= B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

1345

const off_t adoptedSwapSize = B_PAGE_SIZE * (off_t)sourceSwapBlock->used;

src/system/kernel/vm/VMAnonymousCache.cpp

1456

if (st.st_size < B_PAGE_SIZE) {

src/system/kernel/vm/VMAnonymousCache.cpp

1506

sAvailableSwapSpace += (off_t)pageCount * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

1509

vm_unreserve_memory_or_swap((off_t)pageCount * B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousCache.cpp

1551

sAvailableSwapSpace -= swapFileSize * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

1671

swapSize = (off_t)vm_page_num_pages() * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

1680

if (!swapEnabled || swapSize < B_PAGE_SIZE) {

src/system/kernel/vm/VMAnonymousCache.cpp

1797

cache->fAllocatedSwapSize -= B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

253

kprintf("available: %9" B_PRIdOFF "\n", sAvailableSwapSpace / B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousCache.cpp

255

totalSwapPages - sAvailableSwapSpace / B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousCache.cpp

426

fCache->fAllocatedSwapSize -= B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

477

fGuardedSize = numGuardPages * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

549

vm_page* page = LookupPage(pageIndex * B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousCache.cpp

565

fAllocatedSwapSize -= B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

591

_FreeSwapPageRange(newSize + B_PAGE_SIZE - 1,

src/system/kernel/vm/VMAnonymousCache.cpp

592

virtual_end + B_PAGE_SIZE - 1);

src/system/kernel/vm/VMAnonymousCache.cpp

637

off_t sourceEndPageIndex = (offset + size + B_PAGE_SIZE - 1) >> PAGE_SHIFT;

src/system/kernel/vm/VMAnonymousCache.cpp

692

fAllocatedSwapSize += B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

693

fReservedSwapSize += B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

697

source->fAllocatedSwapSize -= B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

698

source->fReservedSwapSize -= B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

727

off_t pagesCommitment = newPages * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

756

ASSERT_PRINT(size >= (page_count * B_PAGE_SIZE),

src/system/kernel/vm/VMAnonymousCache.cpp

767

uint32 precommitted = (fPrecommittedPages * B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousCache.cpp

852

* B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

874

page_num_t pageCount = (vecs[i].length + B_PAGE_SIZE - 1) >> PAGE_SHIFT;

src/system/kernel/vm/VMAnonymousCache.cpp

879

fAllocatedSwapSize -= pageCount * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

885

off_t totalSize = totalPages * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

905

page_num_t pageCount = (vecs[i].length + B_PAGE_SIZE - 1) >> PAGE_SHIFT;

src/system/kernel/vm/VMAnonymousCache.cpp

925

off_t pos = (off_t)(slotIndex - swapFile->first_slot) * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

927

generic_size_t length = (phys_addr_t)n * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

936

fAllocatedSwapSize -= (off_t)pagesLeft * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

947

vectorBase = vectorBase + n * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

948

vectorLength -= n * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

969

ASSERT(numBytes <= B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousCache.cpp

978

if ((fAllocatedSwapSize + B_PAGE_SIZE) > fReservedSwapSize) {

src/system/kernel/vm/VMAnonymousCache.cpp

979

if (swap_space_reserve(B_PAGE_SIZE) != B_PAGE_SIZE) {

src/system/kernel/vm/VMAnonymousCache.cpp

983

fReservedSwapSize += B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

986

fAllocatedSwapSize += B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousCache.cpp

997

fAllocatedSwapSize -= B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

114

ASSERT(size >= (page_count * B_PAGE_SIZE));

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

124

uint32 precommitted = (fPrecommittedPages * B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

211

if (committed_size / B_PAGE_SIZE > page_count)

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

217

if (vm_try_reserve_memory(B_PAGE_SIZE, priority, 0) != B_OK) {

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

219

"reserve %d bytes of RAM.\n", this, (int)B_PAGE_SIZE);

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

223

committed_size += B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

56

fGuardedSize = numGuardPages * B_PAGE_SIZE;

src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

77

off_t pagesCommitment = newPages * B_PAGE_SIZE;

src/system/kernel/vm/VMCache.cpp

1180

page_num_t oldPageCount = (page_num_t)((virtual_end + B_PAGE_SIZE - 1)

src/system/kernel/vm/VMCache.cpp

1182

page_num_t newPageCount = (page_num_t)((newSize + B_PAGE_SIZE - 1)

src/system/kernel/vm/VMCache.cpp

1192

uint32 partialBytes = newSize % B_PAGE_SIZE;

src/system/kernel/vm/VMCache.cpp

1196

vm_memset_physical(page->physical_page_number * B_PAGE_SIZE

src/system/kernel/vm/VMCache.cpp

1197

+ partialBytes, 0, B_PAGE_SIZE - partialBytes);

src/system/kernel/vm/VMCache.cpp

1256

page_num_t endPage = (offset + size + B_PAGE_SIZE - 1) >> PAGE_SHIFT;

src/system/kernel/vm/VMCache.cpp

1277

page_num_t endPage = (offset + size + B_PAGE_SIZE - 1) >> PAGE_SHIFT;

src/system/kernel/vm/VMCache.cpp

1281

return (discarded * B_PAGE_SIZE);

src/system/kernel/vm/VMCache.cpp

1430

const page_num_t firstOffset = ROUNDDOWN(virtual_base, B_PAGE_SIZE) >> PAGE_SHIFT,

src/system/kernel/vm/VMCache.cpp

1431

endOffset = (page_num_t)((virtual_end + B_PAGE_SIZE - 1) >> PAGE_SHIFT);

src/system/kernel/vm/VMKernelAddressSpace.cpp

594

size = ROUNDUP(size, B_PAGE_SIZE);

src/system/kernel/vm/VMKernelAddressSpace.cpp

596

? addressRestrictions->alignment : B_PAGE_SIZE;

src/system/kernel/vm/VMKernelAddressSpace.cpp

601

if (address % B_PAGE_SIZE != 0)

src/system/kernel/vm/VMKernelAddressSpace.cpp

607

address = ROUNDUP(address, B_PAGE_SIZE);

src/system/kernel/vm/VMKernelAddressSpace.cpp

900

if (range->size % B_PAGE_SIZE != 0) {

src/system/kernel/vm/VMTranslationMap.cpp

119

+ ((page->cache_offset * B_PAGE_SIZE) - area->cache_offset);

src/system/kernel/vm/VMTranslationMap.cpp

43

ASSERT(base % B_PAGE_SIZE == 0);

src/system/kernel/vm/VMTranslationMap.cpp

44

ASSERT(size % B_PAGE_SIZE == 0);

src/system/kernel/vm/VMTranslationMap.cpp

49

for (; address != end; address += B_PAGE_SIZE) {

src/system/kernel/vm/VMTranslationMap.cpp

54

vm_page* page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/vm/VMTranslationMap.cpp

64

for (; address != end; address += B_PAGE_SIZE)

src/system/kernel/vm/VMUserAddressSpace.cpp

577

alignment = B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1040

const off_t areaCommit = compute_area_page_commitment(area) * B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1047

const off_t secondCommit = compute_area_page_commitment(secondArea) * B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1078

ssize_t secondAreaPagesShifted = secondAreaOffset / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1163

for (off_t pageAddress = address; pageAddress < endAddress; pageAddress += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

1170

commitmentChange -= B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1277

cache->GuardSize() / B_PAGE_SIZE, true, VM_PRIORITY_USER);

src/system/kernel/vm/vm.cpp

1581

guardPages = guardSize / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1671

if (wiring == B_CONTIGUOUS && size == B_PAGE_SIZE

src/system/kernel/vm/vm.cpp

1722

reservedPages += size / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1741

size / B_PAGE_SIZE, physicalAddressRestrictions, priority);

src/system/kernel/vm/vm.cpp

1766

isStack ? (min_c(2, size / B_PAGE_SIZE - guardPages)) : 0, guardPages,

src/system/kernel/vm/vm.cpp

1806

address += B_PAGE_SIZE, offset += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

1810

+ KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE)

src/system/kernel/vm/vm.cpp

1813

- KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE)

src/system/kernel/vm/vm.cpp

1843

virtualAddress += B_PAGE_SIZE, offset += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

1851

page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

1877

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

1884

+ (area->Size() - 1); virtualAddress += B_PAGE_SIZE,

src/system/kernel/vm/vm.cpp

1885

offset += B_PAGE_SIZE, physicalAddress += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

1886

page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

1924

for (i = size / B_PAGE_SIZE; i-- > 0; pageNumber++) {

src/system/kernel/vm/vm.cpp

1969

mapOffset = physicalAddress % B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

2037

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

2087

if (vecs[i].base % B_PAGE_SIZE != 0

src/system/kernel/vm/vm.cpp

2088

|| vecs[i].length % B_PAGE_SIZE != 0) {

src/system/kernel/vm/vm.cpp

2133

for (addr_t offset = 0; offset < size; offset += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

2145

vecOffset += B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

2229

page_num_t firstPage = cacheOffset / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

2230

page_num_t endPage = firstPage + area->Size() / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

2244

baseAddress + (page->cache_offset * B_PAGE_SIZE - cacheOffset),

src/system/kernel/vm/vm.cpp

2272

if ((offset % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

2403

* ((1 * 1024 * 1024) / B_PAGE_SIZE));

src/system/kernel/vm/vm.cpp

2415

if (cache->page_count < (prefetch / B_PAGE_SIZE))

src/system/kernel/vm/vm.cpp

2603

offset += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

2858

lowerCache->GuardSize() / B_PAGE_SIZE,

src/system/kernel/vm/vm.cpp

2873

lowerNewCommitment = (lowerCache->page_count * B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

2906

copiedPage->physical_page_number * B_PAGE_SIZE,

src/system/kernel/vm/vm.cpp

2907

page->physical_page_number * B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

2913

page->cache_offset * B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

3108

target->cache->Commit(newPageCommitment * B_PAGE_SIZE, VM_PRIORITY_USER);

src/system/kernel/vm/vm.cpp

3242

status = cache->Commit(cache->page_count * B_PAGE_SIZE,

src/system/kernel/vm/vm.cpp

3258

&& cache->page_count * 2 < area->Size() / B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

3296

page_num_t firstPageOffset = area->cache_offset / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

3298

= firstPageOffset + area->Size() / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

3623

void* lastPage = (void*)ROUNDDOWN(~(addr_t)0, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

3624

vm_block_address_range("overflow protection", lastPage, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

3631

(void *)ROUNDDOWN(blockAddress, B_PAGE_SIZE), B_PAGE_SIZE * 64);

src/system/kernel/vm/vm.cpp

3638

(void *)ROUNDDOWN(blockAddress, B_PAGE_SIZE), B_PAGE_SIZE * 64);

src/system/kernel/vm/vm.cpp

3647

(void *)ROUNDDOWN(blockAddress, B_PAGE_SIZE), B_PAGE_SIZE * 64);

src/system/kernel/vm/vm.cpp

3654

(void *)ROUNDDOWN(blockAddress, B_PAGE_SIZE), B_PAGE_SIZE * 64);

src/system/kernel/vm/vm.cpp

3731

addr_t pageAddress = ROUNDDOWN(address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

3943

vec.base = (phys_addr_t)page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

3944

generic_size_t bytesRead = vec.length = B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

4015

vm_memcpy_physical_page(page->physical_page_number * B_PAGE_SIZE,

src/system/kernel/vm/vm.cpp

4016

sourcePage->physical_page_number * B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

4054

addr_t address = ROUNDDOWN(originalAddress, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

4188

&& (mappedPage = vm_lookup_page(physicalAddress / B_PAGE_SIZE))

src/system/kernel/vm/vm.cpp

4212

if (area->AddWaiterIfWired(&waiter, address, B_PAGE_SIZE,

src/system/kernel/vm/vm.cpp

4412

ASSERT((amount % B_PAGE_SIZE) == 0);

src/system/kernel/vm/vm.cpp

4429

ASSERT((amount % B_PAGE_SIZE) == 0);

src/system/kernel/vm/vm.cpp

4444

ASSERT((amount % B_PAGE_SIZE) == 0);

src/system/kernel/vm/vm.cpp

4630

info->ram_size = cache->page_count * B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

4646

if ((newSize & (B_PAGE_SIZE - 1)) != 0)

src/system/kernel/vm/vm.cpp

4771

if ((oldSize / B_PAGE_SIZE) % 2 != 0) {

src/system/kernel/vm/vm.cpp

4933

addr_t pageAddress = ROUNDDOWN((addr_t)address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

4934

info->range.SetTo(pageAddress, B_PAGE_SIZE, writable, false);

src/system/kernel/vm/vm.cpp

4983

&& (page = vm_lookup_page(physicalAddress / B_PAGE_SIZE))

src/system/kernel/vm/vm.cpp

5015

= (phys_addr_t)page->physical_page_number * B_PAGE_SIZE

src/system/kernel/vm/vm.cpp

5016

+ address % B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

5083

addr_t lockBaseAddress = ROUNDDOWN((addr_t)address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5084

addr_t lockEndAddress = ROUNDUP((addr_t)address + numBytes, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5160

for (; nextAddress != areaEnd; nextAddress += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

5167

&& (page = vm_lookup_page(physicalAddress / B_PAGE_SIZE))

src/system/kernel/vm/vm.cpp

522

return (areaSize / B_PAGE_SIZE + 1) / 2;

src/system/kernel/vm/vm.cpp

5242

addr_t lockBaseAddress = ROUNDDOWN((addr_t)address, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5243

addr_t lockEndAddress = ROUNDUP((addr_t)address + numBytes, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5317

for (; nextAddress != areaEnd; nextAddress += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

5324

&& (page = vm_lookup_page(physicalAddress / B_PAGE_SIZE))

src/system/kernel/vm/vm.cpp

5386

addr_t pageOffset = virtualAddress & (B_PAGE_SIZE - 1);

src/system/kernel/vm/vm.cpp

5417

addr_t bytes = min_c(numBytes - offset, B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

5437

if (bytes > B_PAGE_SIZE - pageOffset)

src/system/kernel/vm/vm.cpp

5438

bytes = B_PAGE_SIZE - pageOffset;

src/system/kernel/vm/vm.cpp

561

addr_t pageIndex = (pageAddress - area->Base()) / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

576

uint32 pageIndex = (pageAddress - area->Base()) / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

5960

|| (addr_t)address % B_PAGE_SIZE != 0) {

src/system/kernel/vm/vm.cpp

5989

|| (addr_t)address % B_PAGE_SIZE != 0) {

src/system/kernel/vm/vm.cpp

6019

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

612

return area->cache->page_count * B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

6130

pageAddress < currentAddress; pageAddress += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

6142

commitmentChange += B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

6144

commitmentChange -= B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

6156

newCommitment = (compute_area_page_commitment(area) * B_PAGE_SIZE)

src/system/kernel/vm/vm.cpp

616

const bool oddPageCount = ((area->Size() / B_PAGE_SIZE) % 2) != 0;

src/system/kernel/vm/vm.cpp

6166

pageAddress < currentAddress; pageAddress += B_PAGE_SIZE) {

src/system/kernel/vm/vm.cpp

6180

vm_page* page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

620

const off_t pageOffset = area->cache_offset + (i * 2 * B_PAGE_SIZE);

src/system/kernel/vm/vm.cpp

6218

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

6294

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

630

if (area->cache->LookupPage(pageOffset + B_PAGE_SIZE) != NULL

src/system/kernel/vm/vm.cpp

631

|| area->cache->StoreHasPage(pageOffset + B_PAGE_SIZE))

src/system/kernel/vm/vm.cpp

6377

if ((address % B_PAGE_SIZE) != 0)

src/system/kernel/vm/vm.cpp

677

map->Map(address, page->physical_page_number * B_PAGE_SIZE, protection,

src/system/kernel/vm/vm.cpp

692

map->Map(address, page->physical_page_number * B_PAGE_SIZE, protection,

src/system/kernel/vm/vm.cpp

849

cache->Commit(newCommitmentPages * B_PAGE_SIZE, priority);

src/system/kernel/vm/vm.cpp

877

ssize_t pagesShifted = (oldSize - area->Size()) / B_PAGE_SIZE;

src/system/kernel/vm/vm.cpp

906

cache->Commit(newCommitmentPages * B_PAGE_SIZE, priority);

src/system/kernel/vm/vm_debug.cpp

101

int32 offset = address & (B_PAGE_SIZE - 1);

src/system/kernel/vm/vm_debug.cpp

102

if (num * itemSize + offset > B_PAGE_SIZE) {

src/system/kernel/vm/vm_debug.cpp

103

num = (B_PAGE_SIZE - offset) / itemSize;

src/system/kernel/vm/vm_debug.cpp

107

address = ROUNDDOWN(address, B_PAGE_SIZE);

src/system/kernel/vm/vm_debug.cpp

203

copyAddress = ROUNDDOWN(copyAddress, B_PAGE_SIZE);

src/system/kernel/vm/vm_debug.cpp

605

vm_available_memory_debug(), (phys_addr_t)vm_page_num_pages() * B_PAGE_SIZE);

src/system/kernel/vm/vm_debug.cpp

660

physicalAddress = page->physical_page_number * B_PAGE_SIZE;

src/system/kernel/vm/vm_debug.cpp

663

physicalAddress -= physicalAddress % B_PAGE_SIZE;

src/system/kernel/vm/vm_debug.cpp

720

virtualAddress -= virtualAddress % B_PAGE_SIZE;

src/system/kernel/vm/vm_debug.cpp

774

if (size > B_PAGE_SIZE || ROUNDDOWN((addr_t)unsafeMemory, B_PAGE_SIZE)

src/system/kernel/vm/vm_debug.cpp

775

!= ROUNDDOWN((addr_t)unsafeMemory + size - 1, B_PAGE_SIZE)) {

src/system/kernel/vm/vm_debug.cpp

822

phys_addr_t physicalAddress = page->physical_page_number * B_PAGE_SIZE

src/system/kernel/vm/vm_debug.cpp

823

+ (addr_t)unsafeMemory % B_PAGE_SIZE;

src/system/kernel/vm/vm_debug.cpp

840

if (vm_page_num_free_pages() >= 200 * 1024 * 1024 / B_PAGE_SIZE) {

src/system/kernel/vm/vm_debug.cpp

845

ROUNDUP(kCacheInfoTableCount * sizeof(cache_info), B_PAGE_SIZE),

src/system/kernel/vm/vm_init.cpp

141

address = (void*)ROUNDDOWN(image->text_region.start, B_PAGE_SIZE);

src/system/kernel/vm/vm_init.cpp

149

address = (void*)ROUNDDOWN(image->data_region.start, B_PAGE_SIZE);

src/system/kernel/vm/vm_init.cpp

192

if (alignment <= B_PAGE_SIZE) {

src/system/kernel/vm/vm_init.cpp

196

ASSERT((alignment % B_PAGE_SIZE) == 0);

src/system/kernel/vm/vm_init.cpp

288

if (memoryRange.size < (B_PAGE_SIZE * 128))

src/system/kernel/vm/vm_init.cpp

337

range.size += B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

338

return nextPage / B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

345

phys_addr_t nextPage = range.start - B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

360

range.start -= B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

361

range.size += B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

362

return nextPage / B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

37

for (addr_t current = start; current < end; current += B_PAGE_SIZE) {

src/system/kernel/vm/vm_init.cpp

376

if (range.start < lastAllocatedPage || range.size < (B_PAGE_SIZE * 128))

src/system/kernel/vm/vm_init.cpp

390

range.size = B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

391

return nextPage / B_PAGE_SIZE;

src/system/kernel/vm/vm_init.cpp

419

for (uint32 i = 0; i < HOWMANY(physicalSize, B_PAGE_SIZE); i++) {

src/system/kernel/vm/vm_init.cpp

427

virtualBase + i * B_PAGE_SIZE,

src/system/kernel/vm/vm_init.cpp

428

physicalAddress * B_PAGE_SIZE, attributes);

src/system/kernel/vm/vm_init.cpp

43

vm_page* page = vm_lookup_page(physicalAddress / B_PAGE_SIZE);

src/system/kernel/vm/vm_init.cpp

57

vm_unreserve_memory(reservation.count * B_PAGE_SIZE);

src/system/kernel/vm/vm_page.cpp

1596

B_PAGE_SIZE);

src/system/kernel/vm/vm_page.cpp

2398

sPhysicalPageOffset = args->physical_memory_range[0].start / B_PAGE_SIZE;

src/system/kernel/vm/vm_page.cpp

2400

+ args->physical_memory_range[0].size / B_PAGE_SIZE;

src/system/kernel/vm/vm_page.cpp

2403

sIgnoredPages = args->ignored_physical_memory / B_PAGE_SIZE;

src/system/kernel/vm/vm_page.cpp

2406

page_num_t start = args->physical_memory_range[i].start / B_PAGE_SIZE;

src/system/kernel/vm/vm_page.cpp

2410

+ args->physical_memory_range[i].size / B_PAGE_SIZE;

src/system/kernel/vm/vm_page.cpp

2415

if (available > LIMIT_AVAILABLE_MEMORY * (1024 * 1024 / B_PAGE_SIZE)) {

src/system/kernel/vm/vm_page.cpp

2417

+ LIMIT_AVAILABLE_MEMORY * (1024 * 1024 / B_PAGE_SIZE);

src/system/kernel/vm/vm_page.cpp

2473

mark_page_range_in_use(previousEnd / B_PAGE_SIZE,

src/system/kernel/vm/vm_page.cpp

2474

(base - previousEnd) / B_PAGE_SIZE, false);

src/system/kernel/vm/vm_page.cpp

2482

args->physical_allocated_range[i].start / B_PAGE_SIZE,

src/system/kernel/vm/vm_page.cpp

2483

args->physical_allocated_range[i].size / B_PAGE_SIZE, true);

src/system/kernel/vm/vm_page.cpp

2490

vm_unreserve_memory(vm_page_num_free_pages() * B_PAGE_SIZE);

src/system/kernel/vm/vm_page.cpp

2984

= std::max(restrictions->low_address / B_PAGE_SIZE, sPhysicalPageOffset)

src/system/kernel/vm/vm_page.cpp

2989

end = std::max(restrictions->high_address / B_PAGE_SIZE,

src/system/kernel/vm/vm_page.cpp

2998

= std::max(restrictions->alignment / B_PAGE_SIZE, (phys_addr_t)1) - 1;

src/system/kernel/vm/vm_page.cpp

3005

page_num_t boundary = restrictions->boundary / B_PAGE_SIZE;

src/system/kernel/vm/vm_page.cpp

3223

page_num_t blockCachePages = block_cache_used_memory() / B_PAGE_SIZE;

src/system/kernel/vm/vm_page.cpp

3268

return ((phys_addr_t)sPhysicalPageOffset + sNumPages) * B_PAGE_SIZE - 1;

src/system/kernel/vm/vm_page.cpp

667

(addr_t)(page->physical_page_number * B_PAGE_SIZE));

src/system/kernel/vm/vm_page.cpp

855

page = vm_lookup_page(pageAddress / B_PAGE_SIZE);

src/system/kernel/vm/vm_page.cpp

943

page->physical_page_number * B_PAGE_SIZE, callback);

src/system/kernel/vm/vm_page_writer.cpp

295

fVecs[0].length = B_PAGE_SIZE;

src/system/kernel/vm/vm_page_writer.cpp

315

fVecs[fVecCount - 1].length += B_PAGE_SIZE;

src/system/kernel/vm/vm_page_writer.cpp

320

nextBase = fVecs[0].base - B_PAGE_SIZE;

src/system/kernel/vm/vm_page_writer.cpp

325

fVecs[0].length += B_PAGE_SIZE;

src/system/kernel/vm/vm_page_writer.cpp

348

fVecs[vectorIndex].length = B_PAGE_SIZE;

src/system/kernel/vm/vm_page_writer.cpp

383

if (status == B_OK && transferred <= (fPageCount - 1) * B_PAGE_SIZE)

src/system/kernel/vm/vm_page_writer.cpp

864

(cache->virtual_end + B_PAGE_SIZE - 1) >> PAGE_SHIFT);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

240

guarded_heap_page_protect_raw(area.base + pageIndex * B_PAGE_SIZE,

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

241

B_PAGE_SIZE, protection);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

424

size_t offset = size & (B_PAGE_SIZE - 1);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

425

void* result = (void*)((area.base + pageIndex * B_PAGE_SIZE

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

426

+ (offset > 0 ? B_PAGE_SIZE - offset : 0)) & ~(alignment - 1));

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

448

area->page_count = area->size / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

453

+ B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

456

area->size = area->page_count * B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

457

area->base = (addr_t)baseAddress + pagesNeeded * B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

514

size_t infoSpace = alignment >= B_PAGE_SIZE ? B_PAGE_SIZE

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

517

size_t pagesNeeded = (size + infoSpace + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

519

if (alignment > B_PAGE_SIZE)

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

520

pagesNeeded += alignment / B_PAGE_SIZE - 1;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

524

B_ANY_ADDRESS, (pagesNeeded + 1) * B_PAGE_SIZE, B_NO_LOCK,

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

538

+ pagesNeeded * B_PAGE_SIZE - size) & ~(alignment - 1));

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

546

if (alignment <= B_PAGE_SIZE) {

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

549

(addr_t)address + pagesNeeded * B_PAGE_SIZE, B_PAGE_SIZE, 0);

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

552

addr_t protectedStart = (addr_t)address + B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

558

size_t allocatedPages = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

560

+ allocatedPages * B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

561

protectedSize = (addr_t)address + (pagesNeeded + 1) * B_PAGE_SIZE

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

578

size_t pagesNeeded = (size + B_PAGE_SIZE - 1) / B_PAGE_SIZE + 1;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

579

if (alignment > B_PAGE_SIZE

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

580

|| pagesNeeded * B_PAGE_SIZE >= GUARDED_HEAP_AREA_USE_THRESHOLD) {

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

637

size_t pageIndex = ((addr_t)address - area.base) / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/guarded_heap.cpp

863

size_t pageIndex = ((addr_t)address - area->base) / B_PAGE_SIZE;

src/system/libroot/posix/malloc/debug/heap.cpp

1127

if (alignment < B_PAGE_SIZE) {

src/system/libroot/posix/malloc/debug/heap.cpp

1723

size_t areaSize = ROUNDUP(size + sizeof(area_allocation_info) + B_PAGE_SIZE,

src/system/libroot/posix/malloc/debug/heap.cpp

1724

B_PAGE_SIZE);

src/system/libroot/posix/malloc/debug/heap.cpp

1739

if (mprotect((void *)((addr_t)address + areaSize - B_PAGE_SIZE),

src/system/libroot/posix/malloc/debug/heap.cpp

1740

B_PAGE_SIZE, PROT_NONE) != 0) {

src/system/libroot/posix/malloc/debug/heap.cpp

1757

address = (void *)((addr_t)address + areaSize - B_PAGE_SIZE - size);

src/system/libroot/posix/malloc/debug/heap.cpp

176

B_PAGE_SIZE / 8, /* max allocation size */

src/system/libroot/posix/malloc/debug/heap.cpp

177

B_PAGE_SIZE, /* page size */

src/system/libroot/posix/malloc/debug/heap.cpp

1840

if (alignment != 0 && alignment < B_PAGE_SIZE)

src/system/libroot/posix/malloc/debug/heap.cpp

1846

+ alignment, B_PAGE_SIZE);

src/system/libroot/posix/malloc/debug/heap.cpp

186

B_PAGE_SIZE * 2, /* max allocation size */

src/system/libroot/posix/malloc/debug/heap.cpp

187

B_PAGE_SIZE * 8, /* page size */

src/system/libroot/posix/malloc/debug/heap.cpp

188

B_PAGE_SIZE / 8, /* min bin size */

src/system/libroot/posix/malloc/debug/heap.cpp

1886

uint32 heapClass = alignment < B_PAGE_SIZE

src/system/libroot/posix/malloc/debug/heap.cpp

197

B_PAGE_SIZE * 16, /* page size */

src/system/libroot/posix/malloc/debug/heap.cpp

198

B_PAGE_SIZE * 2, /* min bin size */

src/system/libroot/posix/malloc/debug/heap.cpp

1987

size_t available = info->size - B_PAGE_SIZE

src/system/libroot/posix/malloc/debug/heap.cpp

672

area->base = ROUNDUP(base, B_PAGE_SIZE);

src/system/libroot/posix/malloc/debug/heap.cpp

673

area->size = size & ~(B_PAGE_SIZE - 1);

src/system/libroot/posix/malloc/debug/malloc_debug_api.cpp

296

return memalign(B_PAGE_SIZE, size);

src/system/libroot/posix/malloc/hoard2/arch-specific.cpp

47

static const size_t kInitialHeapSize = 64 * B_PAGE_SIZE;

src/system/libroot/posix/malloc/hoard2/arch-specific.cpp

51

static const size_t kHeapIncrement = 16 * B_PAGE_SIZE;

src/system/libroot/posix/malloc/hoard2/wrapper.cpp

500

return memalign(B_PAGE_SIZE, size);

src/system/libroot/posix/malloc/openbsd/PagesAllocator.cpp

23

static const size_t kPageSize = B_PAGE_SIZE;

src/system/libroot/posix/malloc/openbsd/wrapper.c

106

length = (length + (B_PAGE_SIZE - 1)) & ~(B_PAGE_SIZE - 1);;

src/system/libroot/posix/malloc/openbsd/wrapper.c

157

return memalign(B_PAGE_SIZE, size);

src/system/libroot/posix/malloc/openbsd/wrapper.c

20

#if B_PAGE_SIZE == 4096

src/system/libroot/posix/sys/mman.cpp

96

if (length == 0 || offset % B_PAGE_SIZE != 0) {

src/system/libroot/posix/unistd/brk.c

119

size_t new_size_aligned = (new_size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);

src/system/libroot/posix/unistd/conf.cpp

95

return B_PAGE_SIZE;

src/system/libroot/posix/unistd/getpagesize.c

12

return B_PAGE_SIZE;

src/system/runtime_loader/images.cpp

331

+ (loadAddress % B_PAGE_SIZE));

src/system/runtime_loader/images.cpp

41

# define MAX_PAGE_SIZE B_PAGE_SIZE

src/system/runtime_loader/utility.h

16

#define PAGE_MASK (B_PAGE_SIZE - 1)

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

183

allocate(aperture, 2 * B_PAGE_SIZE, 0, 0, base[0], physical[0]);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

184

allocate(aperture, 4 * B_PAGE_SIZE, 0, B_APERTURE_NON_RESERVED, base[1],

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

186

allocate(aperture, 1 * B_PAGE_SIZE, 0, B_APERTURE_NEED_PHYSICAL, base[2],

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

189

allocate(aperture, 1 * B_PAGE_SIZE, 4 * B_PAGE_SIZE, 0, base[2],

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

194

allocate(aperture, 5 * B_PAGE_SIZE, 0, 0, base[1], physical[1]);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

201

void *buffer = memalign(3 * B_PAGE_SIZE, B_PAGE_SIZE);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

203

3 * B_PAGE_SIZE, 0, false, 0, &base[3]);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

207

allocate(aperture, 25 * B_PAGE_SIZE, 0, 0, base[0], physical[0]);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

209

allocate(aperture, 4 * B_PAGE_SIZE, 0, 0, base[0], physical[0]);

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

212

area_id area = create_area("test", &address, B_ANY_ADDRESS, 2 * B_PAGE_SIZE,

src/tests/add-ons/kernel/bus_managers/agp_gart/gart_tester.cpp

57

sApertureBase = memalign(65536, B_PAGE_SIZE);

src/tests/add-ons/kernel/network/userland_ipc.c

75

#define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))

src/tests/add-ons/print/transports/main.cpp

156

uint8 buffer[B_PAGE_SIZE];

src/tests/servers/app/newerClipping/MultiLocker.cpp

347

stack_base = (uint32) &write_lock_holder/B_PAGE_SIZE;

src/tests/system/kernel/device_manager/dma_resource_test.cpp

1064

status_t status = context.Init(4 * B_PAGE_SIZE);

src/tests/system/kernel/device_manager/dma_resource_test.cpp

1079

status = context.Init(2 * B_PAGE_SIZE, false);

src/tests/system/kernel/device_manager/dma_resource_test.cpp

1162

B_PAGE_SIZE, // max segment size

src/tests/system/kernel/device_manager/dma_resource_test.cpp

238

if (size != B_PAGE_SIZE * 2)

src/tests/system/kernel/device_manager/dma_resource_test.cpp

251

get_memory_map((void*)fDataBase, 2 * B_PAGE_SIZE, entry, 2);

src/tests/system/kernel/device_manager/dma_resource_test.cpp

253

if (entry[0].size == B_PAGE_SIZE) {

src/tests/system/kernel/device_manager/dma_resource_test.cpp

274

get_memory_map((void*)fDataBase, B_PAGE_SIZE, &entry, 1);

src/tests/system/kernel/device_manager/dma_resource_test.cpp

315

|| address < B_PAGE_SIZE) {

src/tests/system/kernel/device_manager/dma_resource_test.cpp

361

if (!fSuite.IsContiguous() && source >= B_PAGE_SIZE)

src/tests/system/kernel/device_manager/dma_resource_test.cpp

375

if (!fSuite.IsContiguous() && source >= B_PAGE_SIZE) {

src/tests/system/kernel/device_manager/dma_resource_test.cpp

606

} else if (fSuite.IsContiguous() || target.address < B_PAGE_SIZE) {

src/tests/system/kernel/device_manager/dma_resource_test.cpp

609

address = target.address - B_PAGE_SIZE

src/tests/system/kernel/file_corruption/checksumfs.h

15

static const uint64 kCheckSumFSSuperBlockOffset = 16 * B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/checksumfs.h

17

= kCheckSumFSSuperBlockOffset + 16 * B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/disk_system/checksumfs.cpp

153

partition->SetBlockSize(B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/disk_system/checksumfs.cpp

154

partition->SetContentSize(partition->Size() / B_PAGE_SIZE * B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

1107

geometry.bytes_per_sector = B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

1109

geometry.cylinder_count = device->DeviceSize() / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

201

ssize_t written = pwrite(fFD, block->checkSums, B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

202

block->blockIndex * B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

205

if (written != B_PAGE_SIZE)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

217

ssize_t bytesRead = pread(fFD, block->checkSums, B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

218

blockIndex * B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

221

if (bytesRead != B_PAGE_SIZE)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

364

fFileSize = fFileSize / B_PAGE_SIZE * B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

365

fDeviceSize = fFileSize / (B_PAGE_SIZE + kCheckSumLength) * B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

402

status_t error = fCheckSumCache->Init(fFD, fDeviceSize / B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

418

error = fDMAResource->Init(restrictions, B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

439

fTransferBuffer = malloc(B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

48

static const uint32 kCheckSumsPerBlock = B_PAGE_SIZE / sizeof(CheckSum);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

495

ASSERT(offset % B_PAGE_SIZE == 0);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

496

ASSERT(length % B_PAGE_SIZE == 0);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

509

offset += B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

510

length -= B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

525

_CheckCheckSum(offset / B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

529

? pwrite(fFD, fTransferBuffer, B_PAGE_SIZE, offset)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

530

: pread(fFD, fTransferBuffer, B_PAGE_SIZE, offset);

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

534

if (transferred != B_PAGE_SIZE)

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

551

size_t length = B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/driver/checksum_device.cpp

594

fSHA256.Update(fTransferBuffer, B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

117

if (partialBitmapBlock <= B_PAGE_SIZE - 4)

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

118

memset(bits + offset, 0xff, B_PAGE_SIZE - offset * 4);

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

40

static const uint32 kBlocksPerBitmapBlock = B_PAGE_SIZE * 8;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

41

static const uint32 kBitmapBlocksPerGroup = B_PAGE_SIZE / 2;

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

50

fBitmapBlockCount((fTotalBlocks + B_PAGE_SIZE - 1) / B_PAGE_SIZE)

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

67

if (blockBitmap <= kCheckSumFSSuperBlockOffset / B_PAGE_SIZE

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

727

if (!block.GetWritable(fVolume, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/BlockAllocator.cpp

84

status_t error = Init(kCheckSumFSSuperBlockOffset / B_PAGE_SIZE + 1,

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1034

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1093

fRootEntryBlockSize = B_PAGE_SIZE

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1205

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1232

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1306

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1365

fDirectory->SetSize(fDirectory->Size() + B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1376

(checksumfs_dir_entry_block*)newInfo.block.Data(), B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1418

fDirectory->SetSize(fDirectory->Size() + B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1429

(checksumfs_dir_entry_block*)newBlock.Data(), B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

1493

(checksumfs_dir_entry_block*)childBlock.Data(), B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

523

if (blockIndices[-i] < kCheckSumFSSuperBlockOffset / B_PAGE_SIZE) {

src/tests/system/kernel/file_corruption/fs/Directory.cpp

608

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

681

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

721

(checksumfs_dir_entry_block*)info.block.Data(), B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

825

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

920

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Directory.cpp

961

fDirectory->SetSize(fDirectory->Size() - B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/File.cpp

145

uint64 blockCount = BLOCK_ROUND_UP(size) / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

146

uint64 newBlockCount = BLOCK_ROUND_UP(newSize) / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

28

static const size_t kFileRootBlockSize = B_PAGE_SIZE

src/tests/system/kernel/file_corruption/fs/File.cpp

31

static const uint32 kFileBlockMaxCount = B_PAGE_SIZE / 8;

src/tests/system/kernel/file_corruption/fs/File.cpp

313

uint32 inBlockOffset = offset % B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

315

uint64 firstBlock = offset / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

317

/ B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

318

uint64 fileBlockCount = BLOCK_ROUND_UP(Size()) / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

37

#define BLOCK_ROUND_UP(value) (((value) + B_PAGE_SIZE - 1) / B_PAGE_SIZE \

src/tests/system/kernel/file_corruption/fs/File.cpp

38

* B_PAGE_SIZE)

src/tests/system/kernel/file_corruption/fs/File.cpp

399

uint64 blockOffset = blockIndex * B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

406

vecs[countAdded - 1].length += B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

417

vecs[countAdded].length = B_PAGE_SIZE - inBlockOffset;

src/tests/system/kernel/file_corruption/fs/File.cpp

46

uint8 blockData[B_PAGE_SIZE];

src/tests/system/kernel/file_corruption/fs/File.cpp

737

uint32 inBlockOffset = offset % B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

738

uint64 blockCount = ((uint64)size + inBlockOffset + B_PAGE_SIZE - 1)

src/tests/system/kernel/file_corruption/fs/File.cpp

739

/ B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

754

uint64 firstBlockIndex = offset / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

757

status_t error = GetFileVecs((firstBlockIndex + i) * B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/File.cpp

758

size + inBlockOffset - i * B_PAGE_SIZE, tempData->fileVecs,

src/tests/system/kernel/file_corruption/fs/File.cpp

764

off_t vecBlockIndex = tempData->fileVecs[k].offset / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

768

vecLength -= B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

796

size_t bytesRead = B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

802

if (bytesRead < B_PAGE_SIZE) {

src/tests/system/kernel/file_corruption/fs/File.cpp

805

B_PAGE_SIZE - bytesRead);

src/tests/system/kernel/file_corruption/fs/File.cpp

809

size_t toCopy = std::min((size_t)B_PAGE_SIZE - inBlockOffset, size);

src/tests/system/kernel/file_corruption/fs/File.cpp

818

&& (size + inBlockOffset) % B_PAGE_SIZE != 0) {

src/tests/system/kernel/file_corruption/fs/File.cpp

820

size_t bytesRead = B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

822

offset - inBlockOffset + i * B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/File.cpp

827

if (bytesRead < B_PAGE_SIZE) {

src/tests/system/kernel/file_corruption/fs/File.cpp

830

B_PAGE_SIZE - bytesRead);

src/tests/system/kernel/file_corruption/fs/File.cpp

834

size_t toCopy = (size + inBlockOffset) % B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/File.cpp

838

(const uint8*)buffer + i * B_PAGE_SIZE - inBlockOffset,

src/tests/system/kernel/file_corruption/fs/File.cpp

848

(const uint8*)buffer + i * B_PAGE_SIZE - inBlockOffset,

src/tests/system/kernel/file_corruption/fs/File.cpp

849

B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/File.cpp

854

memset(tempData->blockData, 0, B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/File.cpp

861

tempData->sha256.Update(tempData->blockData, B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/SuperBlock.cpp

24

|| TotalBlocks() < kCheckSumFSMinSize / B_PAGE_SIZE

src/tests/system/kernel/file_corruption/fs/SymLink.cpp

16

static const size_t kMaxSymLinkSize = B_PAGE_SIZE - kSymLinkDataOffset;

src/tests/system/kernel/file_corruption/fs/Transaction.cpp

413

fSHA256->Update(info->data, B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Volume.cpp

113

return _Init(size / B_PAGE_SIZE);

src/tests/system/kernel/file_corruption/fs/Volume.cpp

135

if (!block.GetReadable(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE))

src/tests/system/kernel/file_corruption/fs/Volume.cpp

214

if (!block.GetZero(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/Volume.cpp

239

info.block_size = B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/Volume.cpp

240

info.io_size = B_PAGE_SIZE * 16; // random value

src/tests/system/kernel/file_corruption/fs/Volume.cpp

437

if (!block.GetWritable(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/Volume.cpp

465

if (fTotalBlocks * B_PAGE_SIZE < kCheckSumFSMinSize)

src/tests/system/kernel/file_corruption/fs/Volume.cpp

469

fBlockCache = block_cache_create(fFD, fTotalBlocks, B_PAGE_SIZE,

src/tests/system/kernel/file_corruption/fs/checksumfs.cpp

1053

B_PAGE_SIZE));

src/tests/system/kernel/file_corruption/fs/checksumfs.cpp

1412

st->st_blksize = B_PAGE_SIZE * 16; // random number

src/tests/system/kernel/file_corruption/fs/checksumfs.cpp

1418

st->st_blocks = 1 + (st->st_size + B_PAGE_SIZE - 1) / B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/checksumfs.cpp

806

if (!superBlock->Check((uint64)partition->size / B_PAGE_SIZE))

src/tests/system/kernel/file_corruption/fs/checksumfs.cpp

821

partition->content_size = superBlock->TotalBlocks() * B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/checksumfs.cpp

822

partition->block_size = B_PAGE_SIZE;

src/tests/system/kernel/file_corruption/fs/checksumfs.cpp

890

status_t error = volume.Init(fd, partitionSize / B_PAGE_SIZE);

src/tests/system/kernel/slab/Slab.h

108

static int PageSize() { return B_PAGE_SIZE; }

src/tests/system/kernel/vm/cow_bug113_test.cpp

18

B_ANY_ADDRESS, B_PAGE_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);

src/tests/system/kernel/vm/mlock_test.cpp

16

int result = mlock(space + B_PAGE_SIZE, B_PAGE_SIZE * 7);

src/tests/system/kernel/vm/mlock_test.cpp

19

result = munlock(space + 2 * B_PAGE_SIZE, B_PAGE_SIZE * 5);

src/tests/system/kernel/vm/mlock_test.cpp

22

result = mlock(space + 2 * B_PAGE_SIZE, B_PAGE_SIZE * 3);

src/tests/system/kernel/vm/mlock_test.cpp

25

result = mlock(space, B_PAGE_SIZE * 9);

src/tests/system/kernel/vm/mlock_test.cpp

28

result = munlock(space + 4 * B_PAGE_SIZE, B_PAGE_SIZE * 5);

src/tests/system/kernel/vm/mlock_test.cpp

31

result = munlock(space, B_PAGE_SIZE * 9);

src/tests/system/kernel/vm/mlock_test.cpp

6

#define SPACE_SIZE (B_PAGE_SIZE * 9)

src/tests/system/kernel/vm/mmap_cut_tests.cpp

100

ptr[B_PAGE_SIZE * 3] = 'b';

src/tests/system/kernel/vm/mmap_cut_tests.cpp

103

if (mprotect(ptr + B_PAGE_SIZE * 3, B_PAGE_SIZE, PROT_NONE) != 0)

src/tests/system/kernel/vm/mmap_cut_tests.cpp

107

set_area_protection(area_for(ptr + B_PAGE_SIZE * 3), B_READ_AREA | B_WRITE_AREA);

src/tests/system/kernel/vm/mmap_cut_tests.cpp

110

if (ptr[B_PAGE_SIZE * 3] != 'b') {

src/tests/system/kernel/vm/mmap_cut_tests.cpp

122

const size_t size = B_PAGE_SIZE * 4;

src/tests/system/kernel/vm/mmap_cut_tests.cpp

127

if (mmap(ptr + B_PAGE_SIZE, B_PAGE_SIZE, PROT_READ | PROT_WRITE,

src/tests/system/kernel/vm/mmap_cut_tests.cpp

132

mprotect(ptr + B_PAGE_SIZE * 3, B_PAGE_SIZE, PROT_READ | PROT_WRITE);

src/tests/system/kernel/vm/mmap_cut_tests.cpp

135

ptr[B_PAGE_SIZE * 3] = 'a';

src/tests/system/kernel/vm/mmap_cut_tests.cpp

156

ftruncate(fd, B_PAGE_SIZE * 4);

src/tests/system/kernel/vm/mmap_cut_tests.cpp

158

uint8* ptr = (uint8*)mmap(NULL, B_PAGE_SIZE * 4, PROT_NONE, MAP_PRIVATE,

src/tests/system/kernel/vm/mmap_cut_tests.cpp

166

mprotect(ptr, B_PAGE_SIZE, PROT_READ | PROT_WRITE);

src/tests/system/kernel/vm/mmap_cut_tests.cpp

172

mmap(ptr + B_PAGE_SIZE, B_PAGE_SIZE, PROT_NONE,

src/tests/system/kernel/vm/mmap_cut_tests.cpp

21

const size_t size = 16 * B_PAGE_SIZE;

src/tests/system/kernel/vm/mmap_cut_tests.cpp

25

memcpy(chunk, &ptr1[3 * B_PAGE_SIZE], sizeof(chunk));

src/tests/system/kernel/vm/mmap_cut_tests.cpp

28

uint8* ptr2 = (uint8*)mmap(&ptr1[B_PAGE_SIZE], B_PAGE_SIZE,

src/tests/system/kernel/vm/mmap_cut_tests.cpp

32

int status = memcmp(&ptr1[3 * B_PAGE_SIZE], chunk, sizeof(chunk));

src/tests/system/kernel/vm/mmap_cut_tests.cpp

45

const size_t size = B_PAGE_SIZE * 4;

src/tests/system/kernel/vm/mmap_cut_tests.cpp

46

uint8* ptr = (uint8*)mmap(NULL, B_PAGE_SIZE * 4, PROT_NONE,

src/tests/system/kernel/vm/mmap_cut_tests.cpp

50

mprotect(ptr + B_PAGE_SIZE * 3, B_PAGE_SIZE, PROT_READ | PROT_WRITE);

src/tests/system/kernel/vm/mmap_cut_tests.cpp

53

ptr[B_PAGE_SIZE * 3] = 'a';

src/tests/system/kernel/vm/mmap_cut_tests.cpp

56

if (mmap(ptr + B_PAGE_SIZE, B_PAGE_SIZE, PROT_READ | PROT_WRITE,

src/tests/system/kernel/vm/mmap_cut_tests.cpp

61

if (ptr[B_PAGE_SIZE * 3] != 'a') {

src/tests/system/kernel/vm/mmap_cut_tests.cpp

73

const size_t size = B_PAGE_SIZE * 4;

src/tests/system/kernel/vm/mmap_cut_tests.cpp

78

ptr[B_PAGE_SIZE * 3] = 'a';

src/tests/system/kernel/vm/mmap_cut_tests.cpp

81

if (mprotect(ptr + B_PAGE_SIZE * 3, B_PAGE_SIZE, PROT_NONE) != 0)

src/tests/system/kernel/vm/mmap_cut_tests.cpp

85

if (mmap(ptr + B_PAGE_SIZE, B_PAGE_SIZE, PROT_NONE,

src/tests/system/kernel/vm/mmap_cut_tests.cpp

90

if (mprotect(ptr + B_PAGE_SIZE * 3, B_PAGE_SIZE, PROT_READ | PROT_WRITE) != 0)

src/tests/system/kernel/vm/mmap_cut_tests.cpp

94

if (ptr[B_PAGE_SIZE * 3] != 'a') {

src/tests/system/kernel/vm/mmap_invalid_tests.cpp

17

static const size_t kFileSize = B_PAGE_SIZE * 2 + (B_PAGE_SIZE / 2);

src/tests/system/kernel/vm/mmap_invalid_tests.cpp

24

void* ptr = mmap(NULL, B_PAGE_SIZE, PROT_READ, MAP_PRIVATE, gTestFD, -4096);

src/tests/system/kernel/vm/mmap_invalid_tests.cpp

36

void* ptr = mmap(NULL, B_PAGE_SIZE, PROT_READ, MAP_SHARED, gTestFD, 0);

src/tests/system/kernel/vm/mmap_invalid_tests.cpp

45

if (resize_area(area, B_PAGE_SIZE * 2) == B_OK) {

src/tests/system/kernel/vm/mmap_invalid_tests.cpp

59

void* ptr = mmap(NULL, B_PAGE_SIZE, PROT_READ, MAP_PRIVATE, gTestFD, B_PAGE_SIZE * 4);

src/tests/system/kernel/vm/mmap_invalid_tests.cpp

65

ptr = mmap(NULL, B_PAGE_SIZE, PROT_READ, MAP_SHARED, gTestFD, B_PAGE_SIZE * 4);

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

20

kAreaPagesCount * B_PAGE_SIZE, B_NO_LOCK,

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

29

address[i * B_PAGE_SIZE] = 42;

src/tests/system/kernel/vm/page_fault_cache_merge_test.cpp

51

address[i * B_PAGE_SIZE] = 42;

src/tests/system/kernel/vm/reserved_areas_test.cpp

58

&base, addressSpec, B_PAGE_SIZE * 4, B_NO_LOCK,

src/tests/system/kernel/vm/resize_area_tests.cpp

103

B_EXACT_ADDRESS, B_PAGE_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);

src/tests/system/kernel/vm/resize_area_tests.cpp

121

addr_t reserve = newAreaBase + reserveSize + B_PAGE_SIZE;

src/tests/system/kernel/vm/resize_area_tests.cpp

122

status = _kern_reserve_address_range(&reserve, B_EXACT_ADDRESS, B_PAGE_SIZE);

src/tests/system/kernel/vm/resize_area_tests.cpp

126

reserve += B_PAGE_SIZE;

src/tests/system/kernel/vm/resize_area_tests.cpp

127

status = _kern_reserve_address_range(&reserve, B_EXACT_ADDRESS, B_PAGE_SIZE);

src/tests/system/kernel/vm/resize_area_tests.cpp

24

B_EXACT_ADDRESS, B_PAGE_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);

src/tests/system/kernel/vm/resize_area_tests.cpp

31

status = resize_area(area, B_PAGE_SIZE * 2);

src/tests/system/kernel/vm/resize_area_tests.cpp

36

addr_t past = (newAreaBase + B_PAGE_SIZE * 2);

src/tests/system/kernel/vm/resize_area_tests.cpp

37

status = _kern_reserve_address_range(&past, B_EXACT_ADDRESS, B_PAGE_SIZE);

src/tests/system/kernel/vm/resize_area_tests.cpp

43

status = area_for((void*)(newAreaBase + B_PAGE_SIZE * 1));

src/tests/system/kernel/vm/resize_area_tests.cpp

48

status = resize_area(area, B_PAGE_SIZE * 1);

src/tests/system/kernel/vm/resize_area_tests.cpp

53

past = (newAreaBase + B_PAGE_SIZE * 1);

src/tests/system/kernel/vm/resize_area_tests.cpp

54

status = _kern_reserve_address_range(&past, B_EXACT_ADDRESS, B_PAGE_SIZE);

src/tests/system/kernel/vm/resize_area_tests.cpp

61

past = (newAreaBase + reserveSize - B_PAGE_SIZE);

src/tests/system/kernel/vm/resize_area_tests.cpp

62

status = _kern_reserve_address_range(&past, B_EXACT_ADDRESS, B_PAGE_SIZE);

src/tests/system/kernel/vm/resize_area_tests.cpp

69

status = _kern_reserve_address_range(&past, B_EXACT_ADDRESS, B_PAGE_SIZE);

src/tests/system/kernel/vm/resize_area_tests.cpp

83

size_t reserveSize = 4 * B_PAGE_SIZE;

src/tests/system/kernel/vm/set_area_protection_test1.cpp

21

B_PAGE_SIZE, B_NO_LOCK, protection);

src/tests/system/kernel/vm/transfer_area_test.cpp

36

B_ANY_ADDRESS, B_PAGE_SIZE, B_NO_LOCK, B_READ_AREA | B_WRITE_AREA);

src/tests/system/libroot/posix/memalign_test.cpp

121

allocate_random_no_alignment(1024, B_PAGE_SIZE * 128);

src/tests/system/libroot/posix/memalign_test.cpp

122

allocate_random_random_alignment(1024, B_PAGE_SIZE * 128);