ptoa
obj_1t1_pt = vm_pager_allocate(OBJT_PHYS, NULL, ptoa(1 +
va = (vm_offset_t)image->map_addr + ptoa(m->pindex);
image->md_image = (void *)(image->map_addr + ptoa(m->pindex));
kstack0_sz = ptoa(kstack_pages);
if (memsize < ptoa((uintmax_t)vm_free_count()))
memsize = ptoa((uintmax_t)Maxmem);
ptoa((uintmax_t)vm_free_count()),
ptoa((uintmax_t)vm_free_count()) / 1048576);
end = ptoa((vm_paddr_t)Maxmem);
ptoa((uintmax_t)physmem) / 1048576);
va += ptoa(cnt);
offset += ptoa(object->pg_color);
ndmpdp = howmany(ptoa(Maxmem), NBPDP);
ndm1g = ptoa(Maxmem) >> PDPSHIFT;
pd_p[i] = (KPTphys + ptoa(i)) | X86_PG_RW | X86_PG_V;
pdp_p = (pdp_entry_t *)(KPDPphys + ptoa(KPML4I - KPML4BASE));
pdp_p[i + KPDPI] = (KPDphys + ptoa(i)) | X86_PG_RW | X86_PG_V;
pd_p[i + kasankpdi] = (KASANPTphys + ptoa(i)) | X86_PG_RW |
pt_p[i] = (KASANphys + ptoa(i)) | X86_PG_RW | X86_PG_V |
pdp_p[i] = DMPDphys + ptoa(j);
p4d_p[i] = (DMPDPphys + ptoa(i)) | X86_PG_RW | X86_PG_V |
pdp_p[i + j] = (DMPDkernphys + ptoa(i)) |
p4_p[KASANPML4I + i] = KASANPDPphys + ptoa(i);
p4_p[KMSANSHADPML4I + i] = KMSANSHADPDPphys + ptoa(i);
p4_p[KMSANORIGPML4I + i] = KMSANORIGPDPphys + ptoa(i);
p4_p[KPML4BASE + i] = KPDPphys + ptoa(i);
p5_p[i] = (DMPML4phys + ptoa(i - DMPML5I)) |
vm_phys_early_add_seg(KPTphys, KPTphys + ptoa(nkpt));
ptoa(i), false);
0x40000000 + ptoa(i));
pm_pml4[KPML4BASE + i] = (KPDPphys + ptoa(i)) | X86_PG_RW |
pm_pml4[KASANPML4I + i] = (KASANPDPphys + ptoa(i)) | X86_PG_RW |
pm_pml4[KMSANSHADPML4I + i] = (KMSANSHADPDPphys + ptoa(i)) |
pm_pml4[KMSANORIGPML4I + i] = (KMSANORIGPDPphys + ptoa(i)) |
pm_pml4[DMPML4I + i] = (DMPDPphys + ptoa(i)) | X86_PG_RW |
pagezero(PHYS_TO_DMAP(dummypd + ptoa(i)));
pdpe[i] = (pdp_entry_t)(dummypd + ptoa(i) | X86_PG_V |
domain = vm_phys_domain(ptoa(pfn));
va = start + ptoa(m->pindex - m_start->pindex);
(total) = ptoa(td->td_kstack_pages); \
return (ptoa(Maxmem));
if (ptoa(bz->total_bpages) < maxsize) {
ptoa((uintmax_t)physmem) / 1048576);
va = start + ptoa(m->pindex - m_start->pindex);
offset += ptoa(object->pg_color);
(total) = ptoa(td->td_kstack_pages) - sizeof(struct pcb); \
if (ptoa(bz->total_bpages) < maxsize) {
if (newtag->common.lowaddr < ptoa((vm_paddr_t)Maxmem) ||
dmat->common.lowaddr >= ptoa((vm_paddr_t)Maxmem) &&
ptoa((vm_paddr_t)Maxmem),
printf("real memory = %ju (%ju MB)\n", ptoa((uintmax_t)realmem),
ptoa((uintmax_t)realmem) / 1024 / 1024);
ptoa((uintmax_t)vm_free_count()),
ptoa((uintmax_t)vm_free_count()) / 1024 / 1024);
ptoa((uintmax_t)physmem) / 1048576);
va = start + ptoa(m->pindex - m_start->pindex);
offset += ptoa(object->pg_color);
(total) = ptoa(td->td_kstack_pages); \
rv = vmmpmap_enter(stack_hyp_va[cpu] + ptoa(i),
PAGE_SIZE, vtophys(stack[cpu] + ptoa(i)),
#define pfn_to_page(pfn) PHYS_TO_VM_PAGE(ptoa(pfn))
len = ptoa((vm_offset_t)nr_pages);
end = start + ptoa((vm_offset_t)nr_pages);
size = ptoa(count);
coff += ptoa(c);
(vm_offset_t)vaddr + ptoa(i));
memsize = ptoa(realmem) >> 20;
if (ptoa((vm_paddr_t)Maxmem) >
if (dev->dma && offset < ptoa(dev->dma->page_count)) {
paddr = pstart + ptoa(i);
vm_page_initfake(&fma[i], pstart + ptoa(i),
iolen = min(ptoa(npages) - (ma_offs & PAGE_MASK), len);
cons->intf = pmap_mapdev_attr(ptoa(xen_get_console_mfn()), PAGE_SIZE,
xen_store = pmap_mapdev_attr(ptoa(xs.gpfn), PAGE_SIZE,
return (ptoa(xs.gpfn));
sb->st_blocks = ptoa(node->tn_reg.tn_pages);
vap->va_bytes = ptoa(node->tn_reg.tn_pages);
physmap[physmap_idx + 1] = ptoa((vm_paddr_t)Maxmem);
end = ptoa((vm_paddr_t)Maxmem);
if (memsize < ptoa((uintmax_t)vm_free_count()))
memsize = ptoa((uintmax_t)Maxmem);
ptoa((uintmax_t)vm_free_count()),
ptoa((uintmax_t)vm_free_count()) / 1048576);
smap = (void *)vm86_addpage(&vmc, 1, PMAP_MAP_LOW + ptoa(1));
printf("Physical memory: %ju MB\n", ptoa((uintmax_t)physmem) / 1048576);
va = start + ptoa(m->pindex - m_start->pindex);
IdlePTD[a] = (KPTphys + ptoa(a)) | PG_V | PG_RW | PG_A | PG_M;
IdlePDPT[a] = ((u_int)IdlePTD + ptoa(a)) | PG_V;
IdlePTD[PTDPTDI + a] = ((u_int)IdlePTD + ptoa(a)) | PG_V |
*pt = (ISA_HOLE_START + ptoa(a)) | PG_RW | PG_U | PG_A |
offset += ptoa(object->pg_color);
invlpg(kaddr + ptoa(i));
KPTD[i] = (KPTphys + ptoa(i)) | PG_RW | PG_V;
pc->pc_copyout_maddr = kva_alloc(ptoa(2));
pc->pc_copyout_saddr = kva_alloc(ptoa(2));
pc->pc_pmap_eh_va = (vm_offset_t)kva_alloc(ptoa(1));
pc->pc_qmap_addr = pages + ptoa(2);
mpte = PHYS_TO_VM_PAGE(KPTphys + ptoa(i));
mpte->phys_addr = KPTphys + ptoa(i);
pageablemem = ptoa((vm_paddr_t)vm_free_count());
ptoa(exec_map_guard_pages));
return (ptoa(pind - segs[i-1].pindex) + segs[i - 1].target);
ptoa(page_count), 0, VMFS_ANY_SPACE,
new_image_stage->map_size = ptoa(new_segments->size);
bzero(buf, ptoa(md_pages));
cpu_flush_dcache((void *)segment_va, ptoa(page_count));
(vm_offset_t)ef->address + ptoa(ef->object->size));
pmap_san_enter(sva + ptoa(i));
kasan_mark(td->td_kstack, ptoa(td->td_kstack_pages),
ptoa(td->td_kstack_pages), 0);
kmsan_mark(td->td_kstack, ptoa(td->td_kstack_pages),
pmap_san_enter(va + ptoa(i));
pmap_san_enter(va + ptoa(i));
maxpipekva = ptoa(physpages / 64);
KASSERT(ptoa(m->m_epg_npgs) <= ktls_maxlen,
len = ptoa(m->m_epg_npgs - 1) + m->m_epg_last_len -
m->m_epg_pa[i] = state->parray[0] + ptoa(i);
MPASS(uio->uio_resid <= ptoa(io_hold_cnt + 2));
resid = PAGE_SIZE - (uio->uio_offset & PAGE_MASK) + ptoa(i - 1);
if (len > ptoa(io_hold_cnt))
len = ptoa(io_hold_cnt);
va = start + ptoa(m->pindex - m_start->pindex);
moea64_bpvo_pool_size = ((ptoa((uintmax_t)physmem) * sizeof(struct vm_page)) /
va = start + ptoa(m->pindex - m_start->pindex);
offset += ptoa(object->pg_color);
vm_phys_add_seg(KPTphys, KPTphys + ptoa(nkpt));
va = start + ptoa(m->pindex - m_start->pindex);
offset += ptoa(object->pg_color);
domain = vm_phys_domain(ptoa(pfn));
va = start + ptoa(m->pindex - m_start->pindex);
(total) = ptoa(td->td_kstack_pages) - sizeof(struct pcb); \
ptoa(Maxmem), 0);
if (ptoa(bz->total_bpages) < maxsize) {
if (newtag->common.lowaddr < ptoa((vm_paddr_t)Maxmem) && newtag->iommu == NULL)
dmat->common.lowaddr >= ptoa((vm_paddr_t)Maxmem) &&
"alignment= %d", dmat->common.lowaddr, ptoa((vm_paddr_t)Maxmem),
"alignment= %d", dmat->common.lowaddr, ptoa((vm_paddr_t)Maxmem),
printf("real memory = %ju (%ju MB)\n", ptoa((uintmax_t)physmem),
ptoa((uintmax_t)physmem) / 1048576);
ptoa((uintmax_t)vm_free_count()),
ptoa((uintmax_t)vm_free_count()) / 1048576);
ptoa((uintmax_t)physmem) / 1048576);
(total) = ptoa(td->td_kstack_pages); \
if (newtag->common.lowaddr < ptoa((vm_paddr_t)Maxmem) ||
if (ptoa(bz->total_bpages) < maxsize) {
dmat->common.lowaddr >= ptoa((vm_paddr_t)Maxmem) &&
ptoa((vm_paddr_t)Maxmem),
printf("real memory = %ju (%ju MB)\n", ptoa((uintmax_t)realmem),
ptoa((uintmax_t)realmem) / (1024 * 1024));
ptoa((uintmax_t)vm_free_count()),
ptoa((uintmax_t)vm_free_count()) / (1024 * 1024));
ptoa((uintmax_t)physmem) / 1048576);
pmap_store(&pte[i], L3_PTE(pa + ptoa(i), PTE_KERN |
va = start + ptoa(m->pindex - m_start->pindex);
offset += ptoa(object->pg_color);
pa = (vm_paddr_t)kern_l3 + ptoa(i);
pa = (vm_paddr_t)kern_l2 + ptoa(i);
pa = (vm_paddr_t)devmap_l3 + ptoa(i);
pmap_store(&pte[i], L3_PTE(pa + ptoa(i), PTE_KERN |
return (td->td_kstack + ptoa(td->td_kstack_pages));
if (uio->uio_resid > ptoa(io_hold_cnt) || uio->uio_offset < 0 ||
bp->b_bufsize = bp->b_bcount = ptoa(bp->b_npages);
swap_release_by_cred(ptoa(object->size), object->cred);
slabsize = (rsize <= PAGE_SIZE) ? ptoa(i) :
fs.entry->next_read = vaddr + ptoa(ahead) + PAGE_SIZE;
if (vaddr - end >= size - PAGE_SIZE - ptoa(ahead) &&
*fork_charge += ptoa(dst_object->size);
rv = pmap_enter(fs->map->pmap, vaddr + ptoa(i),
if (size != ptoa(kstack_pages + KSTACK_GUARD_PAGES)) {
if (size == ptoa(kstack_pages + KSTACK_GUARD_PAGES)) {
if (size != ptoa(kstack_pages + KSTACK_GUARD_PAGES)) {
KASSERT(rem <= ptoa(kpages),
ks = vm_thread_alloc_kstack_kva(ptoa(pages + KSTACK_GUARD_PAGES),
ks += ptoa(KSTACK_GUARD_PAGES);
vm_thread_free_kstack_kva(ks - ptoa(KSTACK_GUARD_PAGES),
ptoa(pages + KSTACK_GUARD_PAGES), domain);
pmap_qremove(ks - ptoa(KSTACK_GUARD_PAGES),
kasan_mark(ks, ptoa(pages), ptoa(pages), 0);
ptoa(pages + KSTACK_GUARD_PAGES), domain);
kasan_mark(ks, 0, ptoa(pages), KASAN_KSTACK_FREED);
(exec_map_entry_size + 2 * ptoa(exec_map_guard_pages)) +
if (entry->end - entry->start < ptoa(object->size)) {
swap_reserve_force_by_cred(ptoa(object->size) -
start = addr + ptoa(tmpidx);
if (((addr + ptoa(tmpidx)) &
ptoa(tmpidx), p_start, prot);
pmap_enter_object(map->pmap, start, addr + ptoa(psize),
if (!swap_reserve(ptoa(obj->size))) {
ptoa(pend - pstart),
swap_release_by_cred(ptoa(oldsize -
*fork_charge += ptoa(src_object->size) - size;
if (ptoa(pmap_wired_count(map->pmap)) + grow_amount > lmemlim) {
ptoa(pmap_wired_count(map->pmap)) + grow_amount)) {
ptoa(pmap_wired_count(map->pmap)));
nsize = ptoa(npages + pmap_wired_count(map->pmap));
ptoa(pmap_wired_count(map->pmap)));
ptoa(pmap_wired_count(map->pmap)));
ptoa(pmap_wired_count(map->pmap)));
if (ptoa(pmap_wired_count(map->pmap)) + size >
ptoa(pmap_wired_count(map->pmap)) + size);
swap_reserve_force_by_cred(ptoa(size), cred);
vm_size_t charge = ptoa(next_end - prev_object->size);
swap_release_by_cred(ptoa(prev_object->size -
swap_release_by_cred(ptoa(next_size),
kvo->kvo_size = ptoa(obj->size);
VM_PAGE_TO_PHYS(start_m) + ptoa(rcount) !=
if (!vm_addr_bound_ok(pa, ptoa(npages), boundary)) {
pa += ptoa(npages);
if (alignment < ptoa(minalign))
alignment = ptoa(minalign);
startp + ptoa((vm_paddr_t)j),
bp->b_kvabase = kva_alloc(ptoa(PBUF_PAGES));
bp->b_kvasize = ptoa(PBUF_PAGES);
start += ptoa(dpage_count);
vm_phys_fictitious_init_range(fp, ptoa(first_page), dpage_count,
end -= ptoa(dpage_count);
start = ptoa(first_page + vm_page_array_size);
end = ptoa(first_page);
if (pa_end - pa_start < ptoa(npages))
if (pa_end - pa_start < ptoa(npages))
KASSERT(pa_start + ptoa(npages) <= high,
KASSERT(vm_addr_ok(pa_start, ptoa(npages), alignment, boundary),
pa = m->phys_addr + ptoa(npages);
if (ptoa(pmap_wired_count(map->pmap)) +
ptoa(pmap_wired_count(map->pmap)) +
ptoa(pmap_wired_count(map->pmap)));
ptoa(pmap_wired_count(map->pmap)));
bytecount = ptoa(bp->b_npages);
if (error == 0 && bp->b_bcount != ptoa(bp->b_npages)) {
ptoa(bp->b_npages) - bp->b_bcount);
int bytes = ptoa(count);
maxsize = ptoa(count);
domain->iodom.end = id_mapped ? ptoa(Maxmem) : BUS_SPACE_MAXADDR;
domain->iodom.end = id_mapped ? ptoa(Maxmem) : BUS_SPACE_MAXADDR;
if (ptoa(bz->total_bpages) < dmat->common.maxsize) {
if (newtag->common.lowaddr < ptoa((vm_paddr_t)Maxmem) ||
dmat->common.lowaddr >= ptoa((vm_paddr_t)Maxmem) &&
ptoa((vm_paddr_t)Maxmem),
ptoa((vm_paddr_t)Maxmem),
swapbytes = ptoa(pu[idx]->pages);
sysputuint64(wd, row, lcol, width, ptoa(pages), flags);