page_num_t
inline page_num_t WiredPagesCount() const;
page_num_t* toPage, page_num_t* freedPages);
page_num_t fWiredPagesCount;
page_num_t
typedef page_num_t KeyType;
static page_num_t GetKey(const NodeType* node)
static int Compare(page_num_t key, const NodeType* node)
page_num_t pageNumber, bool accessed,
page_num_t pageNumber);
page_num_t vm_allocate_early_physical_page(kernel_args *args, phys_addr_t maxAddress = 0);
void vm_free_page_mapping(page_num_t page, vm_page_mapping* mapping, uint32 flags);
status_t vm_mark_page_inuse(page_num_t page);
status_t vm_mark_page_range_inuse(page_num_t startPage, page_num_t length);
page_num_t vm_page_num_pages(void);
page_num_t vm_page_num_free_pages(void);
page_num_t vm_page_num_unused_pages(void);
struct vm_page *vm_page_allocate_page_run(uint32 flags, page_num_t length,
struct vm_page *vm_lookup_page(page_num_t pageNumber);
page_num_t physical_page_number;
page_num_t cache_offset;
inline void Init(page_num_t pageNumber);
vm_page::Init(page_num_t pageNumber)
page_num_t firstPageIndex = firstModified->cache_offset;
page_num_t index = page->cache_offset - firstPageIndex;
page_num_t allocatedPages = 0;
page_num_t firstPageOffset = lineOffset / B_PAGE_SIZE;
page_num_t linePageCount = (lineSize + B_PAGE_SIZE - 1) / B_PAGE_SIZE;
page_num_t firstMissing = 0;
page_num_t lastMissing = 0;
page_num_t missingPages = 0;
page_num_t pageOffset = firstPageOffset;
page_num_t currentPageOffset;
page_num_t index = pageOffset - firstPageOffset;
page_num_t index = pageOffset - firstPageOffset;
page_num_t page = (oldEntry & ARM_PTE_ADDRESS_MASK) / B_PAGE_SIZE;
page_num_t page = (oldPte & kPteAddrMask) >> fPageBits;
page_num_t page = (oldEntry & M68K_PTE_ADDRESS_MASK) / B_PAGE_SIZE;
page_num_t pageNumber = entry->physical_page_number;
page_num_t page = (oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE;
page_num_t pageNumber = entry->physical_page_number;
page_num_t page = (oldEntry & PPC_PTE_ADDRESS_MASK) / B_PAGE_SIZE;
page_num_t ppn = page->physical_page_number;
FreePageTable(vm_page_reservation* reservation, page_num_t ppn, bool isKernel, uint32 level = 2)
GetPageTableSize(page_num_t ppn, bool isKernel, uint32 level = 2)
page_num_t ppn = vm_allocate_early_physical_page(args);
page_num_t page = (oldEntry & X86_PTE_ADDRESS_MASK) / B_PAGE_SIZE;
page_num_t page = (oldEntry & X86_64_PTE_ADDRESS_MASK) / B_PAGE_SIZE;
static const page_num_t kMaxFree32BitPagesCount = 32;
page_num_t fFreePagesCount;
page_num_t page = (oldEntry & X86_PAE_PTE_ADDRESS_MASK) / B_PAGE_SIZE;
page_num_t firstPageOffset = lineOffset / B_PAGE_SIZE;
page_num_t linePageCount = (lineSize + B_PAGE_SIZE - 1) / B_PAGE_SIZE;
page_num_t firstMissing = 0;
page_num_t lastMissing = 0;
page_num_t missingPages = 0;
page_num_t pageOffset = firstPageOffset;
page_num_t currentPageOffset;
page_num_t index = pageOffset - firstPageOffset;
page_num_t index = pageOffset - firstPageOffset;
page_num_t firstPage = (requestOffset - lineOffset) / B_PAGE_SIZE;
page_num_t endPage = (requestOffset + requestLength - lineOffset
ReadPage(VMAnonymousCache* cache, page_num_t pageIndex,
page_num_t fPageIndex;
WritePage(VMAnonymousCache* cache, page_num_t pageIndex,
page_num_t fPageIndex;
void SetTo(page_num_t pageIndex, swap_addr_t slotIndex, bool newSlot)
page_num_t fPageIndex;
const page_num_t first = base >> PAGE_SHIFT;
const page_num_t pageCount = PAGE_ALIGN(virtual_end) >> PAGE_SHIFT;
page_num_t totalPages = 0;
page_num_t pageCount = (vecs[i].length + B_PAGE_SIZE - 1) >> PAGE_SHIFT;
page_num_t pagesLeft = totalPages;
page_num_t pageCount = (vecs[i].length + B_PAGE_SIZE - 1) >> PAGE_SHIFT;
page_num_t n = pageCount;
for (page_num_t j = 0; j < pageCount; j += n) {
page_num_t pageIndex = offset >> PAGE_SHIFT;
page_num_t* toPage = NULL, page_num_t* freedPages = NULL)
page_num_t oldPageCount = (page_num_t)((virtual_end + B_PAGE_SIZE - 1)
page_num_t newPageCount = (page_num_t)((newSize + B_PAGE_SIZE - 1)
page_num_t basePage = (page_num_t)(newBase >> PAGE_SHIFT);
page_num_t startPage = offset >> PAGE_SHIFT;
page_num_t endPage = (offset + size + B_PAGE_SIZE - 1) >> PAGE_SHIFT;
page_num_t discarded = 0;
page_num_t startPage = offset >> PAGE_SHIFT;
page_num_t endPage = (offset + size + B_PAGE_SIZE - 1) >> PAGE_SHIFT;
const page_num_t firstOffset = ROUNDDOWN(virtual_base, B_PAGE_SIZE) >> PAGE_SHIFT,
endOffset = (page_num_t)((virtual_end + B_PAGE_SIZE - 1) >> PAGE_SHIFT);
return pages.Lookup((page_num_t)(offset >> PAGE_SHIFT));
vm_page* page = pages.Lookup((page_num_t)(offset >> PAGE_SHIFT));
page->cache_offset = (page_num_t)(offset >> PAGE_SHIFT);
inline page_num_t Count() const { return fCount; }
page_num_t fCount;
VMTranslationMap::PageUnmapped(VMArea* area, page_num_t pageNumber,
VMTranslationMap::UnaccessedPageUnmapped(VMArea* area, page_num_t pageNumber)
page_num_t guardPages;
page_num_t reservedPages = reservedMapPages;
page_num_t firstPage = cacheOffset / B_PAGE_SIZE;
page_num_t endPage = firstPage + area->Size() / B_PAGE_SIZE;
page_num_t reservedPreMapPages = 0;
page_num_t wiredPages = 0;
page_num_t oldWiredPages = wiredPages;
page_num_t firstPageOffset = area->cache_offset / B_PAGE_SIZE;
page_num_t lastPageOffset
page_mapping_object_cache_for(page_num_t page)
allocate_page_mapping(page_num_t page, uint32 flags = 0)
vm_free_page_mapping(page_num_t page, vm_page_mapping* mapping, uint32 flags)
page_num_t totalPages = 0;
page_num_t
page_num_t physicalAddress = vm_allocate_early_physical_page(args);
page_num_t swappableModified = 0;
page_num_t swappableModifiedInactive = 0;
page_num_t start;
page_num_t end;
page_num_t Length() const { return end - start; }
for (page_num_t i = 0; i < sNumPages; i++) {
static page_num_t sPhysicalPageOffset;
static page_num_t sNumPages;
static page_num_t sNonExistingPages;
for (page_num_t i = 0; i < sNumPages; i++)
page_num_t pageFilter = 0;
for (page_num_t i = 0; i < sNumPages; i++)
static page_num_t sPageUsageArrays[512];
static page_num_t* sPageUsage = sPageUsageArrays;
static page_num_t sPageUsagePageCount;
memset(sNextPageUsage, 0, sizeof(page_num_t) * 256);
static page_num_t* sNextPageUsage = sPageUsageArrays + 256;
static page_num_t sNextPageUsagePageCount;
mark_page_range_in_use(page_num_t startPage, page_num_t length, bool wired)
for (page_num_t i = 0; i < length; i++) {
AllocatePage(page_num_t pageNumber)
page_num_t physicalPagesEnd = sPhysicalPageOffset
page_num_t start = args->physical_memory_range[i].start / B_PAGE_SIZE;
page_num_t available
+ std::max((page_num_t)32, (sNumPages - sNonExistingPages) / 1024);
page_num_t fPageNumber;
AllocatePageRun(page_num_t startPage, uint32 length)
vm_mark_page_inuse(page_num_t page)
vm_mark_page_range_inuse(page_num_t startPage, page_num_t length)
page_num_t fStartPage;
static page_num_t
allocate_page_run(page_num_t start, page_num_t length, uint32 flags,
page_num_t cachedPages = 0;
page_num_t i = 0;
FreePage(page_num_t pageNumber)
page_num_t freedCachedPages = 0;
page_num_t nextIndex = start;
for (page_num_t i = start; i < start + length; i++)
page_num_t fPageNumber;
vm_page_allocate_page_run(uint32 flags, page_num_t length,
page_num_t requestedStart
page_num_t start = requestedStart;
page_num_t end;
page_num_t alignmentMask
page_num_t boundary = restrictions->boundary / B_PAGE_SIZE;
bool useCached = (freePages > 0) && ((page_num_t)freePages > (length * 2));
page_num_t offsetStart = start + sPhysicalPageOffset;
page_num_t i;
vm_lookup_page(page_num_t pageNumber)
page_num_t
page_num_t
page_num_t
page_num_t blockCachePages = block_cache_used_memory() / B_PAGE_SIZE;
page_num_t modifiedNonTemporaryPages
page_num_t pageNumber) = 0;
page_num_t pageNumber)
AllocationInfoPrinterCallback(bool printStackTrace, page_num_t pageFilter,
page_num_t pageNumber)
page_num_t fPageFilter;
page_num_t pageNumber)
for (page_num_t i = 0; i < sNumPages; i++) {
} else if ((page_num_t)pageIndex >= sNumPages) {
if (pageIndex < 0 || (page_num_t)pageIndex >= sNumPages) {
for (page_num_t i = 0; page; i++, page = queue->Next(page)) {
next_modified_page(VMPageQueue& queue, page_num_t& maxPagesToSee)
page_num_t pagesSinceLastSuccessfulWrite = 0;
page_num_t modifiedPages = queue.Count();
page_num_t maxPagesToSee = modifiedPages;
page_num_t