/haiku/headers/private/graphics/intel_extreme/ |
H A D | utility.h | 11 #define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))
|
/haiku/headers/private/graphics/radeon_hd/ |
H A D | utility.h | 12 #define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))
|
/haiku/headers/private/graphics/vesa/ |
H A D | utility.h | 8 #define ROUND_TO_PAGE_SIZE(x) (((x) + (B_PAGE_SIZE) - 1) & ~((B_PAGE_SIZE) - 1))
|
/haiku/src/tests/system/kernel/ |
H A D | mlock_test.cpp | 6 #define SPACE_SIZE (B_PAGE_SIZE * 9) 16 int result = mlock(space + B_PAGE_SIZE, B_PAGE_SIZE * 7); 19 result = munlock(space + 2 * B_PAGE_SIZE, B_PAGE_SIZE * 5); 22 result = mlock(space + 2 * B_PAGE_SIZE, B_PAGE_SIZE * 3); 25 result = mlock(space, B_PAGE_SIZE * 9); 28 result = munlock(space + 4 * B_PAGE_SIZE, B_PAGE_SIZE * [all...] |
H A D | mmap_cut_tests.cpp | 22 void* ptr = mmap(NULL, B_PAGE_SIZE, PROT_READ, MAP_PRIVATE, gTestFd, -4096); 34 uint8* ptr1 = (uint8*)mmap(NULL, 16 * B_PAGE_SIZE, PROT_READ, MAP_PRIVATE, gTestFd, 0); 36 memcpy(chunk, &ptr1[3 * B_PAGE_SIZE], sizeof(chunk)); 39 uint8* ptr2 = (uint8*)mmap(&ptr1[B_PAGE_SIZE], B_PAGE_SIZE, 43 int status = memcmp(&ptr1[3 * B_PAGE_SIZE], chunk, sizeof(chunk)); 55 uint8* ptr = (uint8*)mmap(NULL, B_PAGE_SIZE * 4, PROT_NONE, 59 mprotect(ptr + B_PAGE_SIZE * 3, B_PAGE_SIZE, PROT_READ | PROT_WRITE); 62 ptr[B_PAGE_SIZE * [all...] |
H A D | page_fault_cache_merge_test.cpp | 20 kAreaPagesCount * B_PAGE_SIZE, B_NO_LOCK, 29 address[i * B_PAGE_SIZE] = 42; 51 address[i * B_PAGE_SIZE] = 42;
|
/haiku/src/system/libroot/posix/unistd/ |
H A D | getpagesize.c | 12 return B_PAGE_SIZE;
|
/haiku/headers/private/interface/ |
H A D | DirectWindowPrivate.h | 12 #define DIRECT_BUFFER_INFO_AREA_SIZE B_PAGE_SIZE
|
/haiku/headers/private/system/ |
H A D | thread_defs.h | 15 #define USER_STACK_GUARD_SIZE (4 * B_PAGE_SIZE) // 16 kB 16 #define MIN_USER_STACK_SIZE (2 * B_PAGE_SIZE) // 8 kB 17 #define MAX_USER_STACK_SIZE (4096 * B_PAGE_SIZE) // 16 MB 19 #define USER_STACK_SIZE (64 * B_PAGE_SIZE) // 256 kB
|
/haiku/src/system/kernel/arch/arm/paging/32bit/ |
H A D | paging.h | 24 B_PAGE_SIZE * ARM_MMU_L2_COARSE_ENTRY_COUNT))) 29 static const size_t kPageTableAlignment = ARM_MMU_L2_COARSE_ENTRY_COUNT * B_PAGE_SIZE;
|
/haiku/src/system/kernel/arch/m68k/paging/040/ |
H A D | paging.h | 48 //#define IOSPACE_CHUNK_SIZE (NUM_PAGEENT_PER_TBL*B_PAGE_SIZE) 54 #define NUM_USER_PGROOT_ENTS (VADDR_TO_PRENT(ROUNDUP(USER_SIZE, B_PAGE_SIZE * 64 * 128))) 55 #define NUM_USER_PGDIR_ENTS (VADDR_TO_PDENT(ROUNDUP(USER_SIZE, B_PAGE_SIZE * 64))) 64 static const size_t kPageTableAlignment = B_PAGE_SIZE 67 static const size_t kPageDirAlignment = B_PAGE_SIZE 75 #define VADDR_TO_PDENT(va) (((va) / B_PAGE_SIZE) / 1024) 76 #define VADDR_TO_PTENT(va) (((va) / B_PAGE_SIZE) % 1024) 114 B_PAGE_SIZE * 1024))) 119 static const size_t kPageTableAlignment = 1024 * B_PAGE_SIZE;
|
/haiku/src/bin/ |
H A D | vmstat.cpp | 77 printf("max memory:\t\t%" B_PRIu64 "\n", info.max_pages * B_PAGE_SIZE); 81 info.block_cache_pages * B_PAGE_SIZE); 83 info.max_swap_pages * B_PAGE_SIZE); 85 info.free_swap_pages * B_PAGE_SIZE); 99 = (info.max_pages * B_PAGE_SIZE - info.free_memory) 100 - (lastInfo.max_pages * B_PAGE_SIZE - lastInfo.free_memory); 104 * B_PAGE_SIZE; 107 * B_PAGE_SIZE;
|
/haiku/src/kits/debugger/model/ |
H A D | TeamMemory.cpp | 24 char buffer[B_PAGE_SIZE]; 30 B_PAGE_SIZE - size_t(address % B_PAGE_SIZE));
|
/haiku/headers/private/fs_shell/ |
H A D | fssh_kernel_priv.h | 32 # define KERNEL_STACK_SIZE (B_PAGE_SIZE * 2) // 8 kB 34 # define KERNEL_STACK_SIZE (B_PAGE_SIZE * 3) // 8 kB + one guard page 44 #define ENV_SIZE (B_PAGE_SIZE * 8)
|
/haiku/src/add-ons/kernel/file_systems/userlandfs/server/ |
H A D | ServerDefs.h | 26 static const int32 kRequestPortSize = B_PAGE_SIZE;
|
/haiku/src/system/kernel/arch/x86/paging/32bit/ |
H A D | paging.h | 19 #define VADDR_TO_PDENT(va) (((va) / B_PAGE_SIZE) / 1024) 20 #define VADDR_TO_PTENT(va) (((va) / B_PAGE_SIZE) % 1024) 58 B_PAGE_SIZE * 1024))) 63 static const size_t kPageTableAlignment = 1024 * B_PAGE_SIZE;
|
H A D | X86PagingMethod32Bit.cpp | 92 addr_t virtualBase = vm_allocate_early(args, 1024 * B_PAGE_SIZE, 0, 0, 101 size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]); 111 _EarlyPreparePageTables(pageTable, virtualBase, 1024 * B_PAGE_SIZE); 125 size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]); 141 1024 * B_PAGE_SIZE, 0); 165 for (int32 i = 0; i < 1024; i++, slotAddress += B_PAGE_SIZE) { 182 (virtualAddress - fVirtualBase) / B_PAGE_SIZE]; 202 size_t areaSize = B_PAGE_SIZE + sizeof(PhysicalPageSlot[1024]); 218 &virtualBase, B_ANY_KERNEL_BLOCK_ADDRESS, 1024 * B_PAGE_SIZE, 226 memset(data, 0, B_PAGE_SIZE); [all...] |
/haiku/src/system/kernel/arch/generic/ |
H A D | generic_vm_physical_page_ops.cpp | 20 phys_addr_t pageOffset = address % B_PAGE_SIZE; 28 size_t toSet = min_c(length, B_PAGE_SIZE - pageOffset); 46 phys_addr_t pageOffset = from % B_PAGE_SIZE; 51 size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset); 86 phys_addr_t pageOffset = to % B_PAGE_SIZE; 91 size_t toCopy = min_c(length, B_PAGE_SIZE - pageOffset); 145 memcpy((void*)toVirtual, (const void*)fromVirtual, B_PAGE_SIZE);
|
/haiku/src/system/boot/platform/efi/arch/arm/ |
H A D | arch_start.cpp | 61 if (platform_allocate_lomem(&trampolinePage, B_PAGE_SIZE) == B_OK) 64 trampolinePage = (void *)get_next_virtual_address(B_PAGE_SIZE); 65 if (platform_allocate_region(&trampolinePage, B_PAGE_SIZE, 0, true) == B_OK) 69 if (platform_allocate_region(&trampolinePage, B_PAGE_SIZE, 0, false) != B_OK) 72 if (platform_free_region(trampolinePage, B_PAGE_SIZE) != B_OK) 75 if (platform_allocate_region(&trampolinePage, B_PAGE_SIZE, 0, true) != B_OK) 101 memcpy(trampolinePage, (void *)arch_enter_kernel, B_PAGE_SIZE); 147 entry->PhysicalStart + entry->NumberOfPages * B_PAGE_SIZE, 149 entry->VirtualStart + entry->NumberOfPages * B_PAGE_SIZE,
|
/haiku/src/add-ons/kernel/drivers/graphics/radeon/ |
H A D | PCI_GART.c | 35 gart->buffer.size = size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1); 78 gart->buffer.size = size = (size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1); 96 get_memory_map( unaligned_addr, B_PAGE_SIZE, map, 1 ); 144 num_pages = (gart->buffer.size + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1); 149 (num_pages * sizeof( uint32 ) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1), 162 get_memory_map(gart->GATT.ptr, B_PAGE_SIZE, PTB_ma [all...] |
/haiku/src/apps/activitymonitor/ |
H A D | SystemInfo.cpp | 51 return fSystemInfo.cached_pages * B_PAGE_SIZE; 61 return fSystemInfo.block_cache_pages * B_PAGE_SIZE; 68 return fSystemInfo.used_pages * B_PAGE_SIZE; 75 return fSystemInfo.max_pages * B_PAGE_SIZE; 90 * B_PAGE_SIZE; 97 return fSystemInfo.max_swap_pages * B_PAGE_SIZE;
|
/haiku/src/system/kernel/vm/ |
H A D | VMAnonymousNoSwapCache.cpp | 55 fGuardedSize = numGuardPages * B_PAGE_SIZE; 72 uint32 precommitted = fPrecommittedPages * B_PAGE_SIZE; 143 if (committed_size / B_PAGE_SIZE > page_count) 149 if (vm_try_reserve_memory(B_PAGE_SIZE, priority, 0) != B_OK) { 151 "reserve %d bytes of RAM.\n", this, (int)B_PAGE_SIZE); 155 committed_size += B_PAGE_SIZE;
|
/haiku/src/system/kernel/arch/riscv64/ |
H A D | arch_cpu.cpp | 114 int64 numPages = kernelStart / B_PAGE_SIZE - kernelEnd / B_PAGE_SIZE; 117 start += B_PAGE_SIZE; 122 int64 numPages = userStart / B_PAGE_SIZE - userEnd / B_PAGE_SIZE; 125 start += B_PAGE_SIZE;
|
/haiku/src/tests/add-ons/kernel/bus_managers/agp_gart/ |
H A D | gart_tester.cpp | 57 sApertureBase = memalign(65536, B_PAGE_SIZE); 183 allocate(aperture, 2 * B_PAGE_SIZE, 0, 0, base[0], physical[0]); 184 allocate(aperture, 4 * B_PAGE_SIZE, 0, B_APERTURE_NON_RESERVED, base[1], 186 allocate(aperture, 1 * B_PAGE_SIZE, 0, B_APERTURE_NEED_PHYSICAL, base[2], 189 allocate(aperture, 1 * B_PAGE_SIZE, 4 * B_PAGE_SIZE, 0, base[2], 194 allocate(aperture, 5 * B_PAGE_SIZE, 0, 0, base[1], physical[1]); 201 void *buffer = memalign(3 * B_PAGE_SIZE, B_PAGE_SIZE); 203 3 * B_PAGE_SIZE, [all...] |
/haiku/src/system/boot/platform/bios_ia32/ |
H A D | mmu.cpp | 133 return get_next_virtual_address(B_PAGE_SIZE); 140 return get_next_physical_address(B_PAGE_SIZE); 155 sNextPageTableAddress += B_PAGE_SIZE; 169 base = ROUNDDOWN(base, B_PAGE_SIZE * 1024); 192 base += B_PAGE_SIZE * 1024; 212 / (B_PAGE_SIZE * 1024)] & 0xfffff000); 213 pageTable[(virtualAddress % (B_PAGE_SIZE * 1024)) / B_PAGE_SIZE] = 0; 236 / (B_PAGE_SIZE * 1024)] & 0xfffff000); 249 physicalAddress &= ~(B_PAGE_SIZE [all...] |