PAGE_MASK
bytes = (bytes + PAGE_MASK) & ~(size_t)PAGE_MASK;
size = (size + PAGE_MASK) & ~(size_t)PAGE_MASK;
((size & PAGE_MASK) == 0 && size > MAX_SLAB_PAGEALIGN)) {
size = (size + PAGE_MASK) & ~(size_t)PAGE_MASK;
size = (size + PAGE_MASK) & ~(size_t)PAGE_MASK;
chunking = (chunking + PAGE_MASK) &
~(size_t)PAGE_MASK;
#define IN_SAME_PAGE_MASK (~(intptr_t)PAGE_MASK | MIN_CHUNK_MASK)
MASSERT_WTHUNLK((big->active & PAGE_MASK) == 0,
MASSERT_WTHUNLK((big->bytes & PAGE_MASK) == 0,
a = (va - vm->dmapbase) & ~PAGE_MASK;
return (PAGE_SIZE - ((size_t)pa & PAGE_MASK));
return (PAGE_SIZE - ((size_t)pa & PAGE_MASK));
off = (gva & PAGE_MASK);
gva &= ~PAGE_MASK;
if ((gva & PAGE_MASK) + size > PAGE_SIZE) {
remain = ((gva & PAGE_MASK) + size - PAGE_SIZE);
if ((gva & PAGE_MASK) + size > PAGE_SIZE) {
remain = ((gva & PAGE_MASK) + size - PAGE_SIZE);
pad = (u_int)dest & PAGE_MASK;
(((vm_offset_t)(*data_ptrs[i])) & PAGE_MASK)),
#define btoc(x) (((unsigned)(x)+PAGE_MASK)>>PAGE_SHIFT)
#define round_page(x) ((((unsigned long)(x)) + PAGE_MASK) & ~(unsigned long)(PAGE_MASK))
#define trunc_page(x) ((unsigned long)(x) & ~(unsigned long)(PAGE_MASK))
if (vaddr & PAGE_MASK) free -= datalen / PAGE_SIZE;
pnext = (paddr & (~PAGE_MASK)) + PAGE_SIZE;
~(intptr_t)PAGE_MASK) -
KKASSERT((paddr & PAGE_MASK) == 0);
KKASSERT((paddr & PAGE_MASK) == 0);
unsigned off = *pos & ~PAGE_MASK;
phys_addr_t addr = *pos & PAGE_MASK;
loff_t off = *pos & ~PAGE_MASK;
phys_addr_t addr = *pos & PAGE_MASK;
loff_t off = *pos & ~PAGE_MASK;
result |= addr & (~PAGE_MASK);
#define LINUX_PAGE_MASK (~PAGE_MASK)
#define offset_in_page(off) ((unsigned long)(off) & PAGE_MASK)
if (((unsigned long)uaddr & ~PAGE_MASK) ==
((unsigned long)end & ~PAGE_MASK))
if (((unsigned long)uaddr & ~PAGE_MASK) ==
((unsigned long)end & ~PAGE_MASK)) {
pgcount = (sg->offset + sg->length + PAGE_MASK) >> PAGE_SHIFT;
pgcount = (sg->offset + sg->length + PAGE_MASK) >> PAGE_SHIFT;
BUG_ON(phys_addr & PAGE_MASK);
BUG_ON(size & PAGE_MASK);
cfgptr = va + (off & PAGE_MASK);
((desc->next & PAGE_MASK) + sizeof *desc) > PAGE_SIZE) {
((desc->next & PAGE_MASK) + sizeof *desc) > PAGE_SIZE) {
((desc->bufaddr & PAGE_MASK) + sizeof(struct epic_frag_list)) > PAGE_SIZE) {
firstloc = noteloc & PAGE_MASK;
firstloc = pathloc & PAGE_MASK;
pageoff = (pos & PAGE_MASK);
if (addr & PAGE_MASK)
v &= ~(long)PAGE_MASK;
o = (int)uio->uio_offset & PAGE_MASK;
c = (u_int)(PAGE_SIZE - ((uintptr_t)iov->iov_base & PAGE_MASK));
iolen = ((vm_offset_t)ubase) & PAGE_MASK;
if (size >= ZoneLimit || ((size & PAGE_MASK) == 0 && size > PAGE_SIZE*2)) {
page_offset = offset & PAGE_MASK;
offset = (vm_offset_t)uptr & PAGE_MASK;
offset = (vm_offset_t)ptr & PAGE_MASK;
xio->xio_offset = (vm_offset_t)kbase & PAGE_MASK;
offset = (xio->xio_offset + uoffset) & PAGE_MASK;
offset = (xio->xio_offset + uoffset) & PAGE_MASK;
offset = (xio->xio_offset + uoffset) & PAGE_MASK;
offset = (xio->xio_offset + uoffset) & PAGE_MASK;
offset = vaddr & PAGE_MASK;
size = (size + PAGE_MASK) & ~(size_t)PAGE_MASK;
pgoff = (vm_offset_t)(off & PAGE_MASK);
int poffset = foff & PAGE_MASK;
resid -= PAGE_SIZE - (foff & PAGE_MASK);
foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;
if (tinc > PAGE_SIZE - ((toff + loffset) & PAGE_MASK))
tinc = PAGE_SIZE - ((toff + loffset) & PAGE_MASK);
(vm_offset_t) ((toff + loffset) & PAGE_MASK), tinc) == 0) {
maxsize = size + (loffset & PAGE_MASK);
desiredpages = ((int)(bp->b_loffset & PAGE_MASK) +
newbsize + PAGE_MASK) >> PAGE_SHIFT;
tinc = PAGE_SIZE - ((bp->b_loffset + toff) & PAGE_MASK);
pi = ((bp->b_loffset & PAGE_MASK) + toff) >>
(vm_offset_t)(bp->b_loffset & PAGE_MASK));
((int)bp->b_loffset & PAGE_MASK) != 0 ||
(bp->b_bcount & PAGE_MASK) != 0) {
resid = ((foff + PAGE_SIZE) & ~(off_t)PAGE_MASK) - foff;
foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;
int base = (foff + off) & PAGE_MASK;
xoff = (int)bp->b_loffset & PAGE_MASK; /* loffset offset into pg 0 */
(m->dirty & vm_page_bits(soff & PAGE_MASK, eoff - soff))) {
vm_page_set_validclean(m, soff & PAGE_MASK, eoff - soff);
xoff = (int)bp->b_loffset & PAGE_MASK; /* loffset offset into pg 0 */
vm_page_set_validdirty(m, soff & PAGE_MASK, eoff - soff);
(bp->b_loffset & PAGE_MASK) == 0) {
int j = ((vm_offset_t)sa & PAGE_MASK) / DEV_BSIZE;
((intptr_t)bdata & PAGE_MASK);
((vm_offset_t)tbp->b_data & PAGE_MASK));
((vm_offset_t)tbp->b_data & PAGE_MASK));
offset = (int)uio->uio_offset & PAGE_MASK;
nobjsize = OFF_TO_IDX(truncboffset + blksize + PAGE_MASK);
nobjsize = OFF_TO_IDX(truncboffset + PAGE_MASK);
pi = OFF_TO_IDX(length + PAGE_MASK);
newlen = (~PAGE_MASK) & mtu;
((sizeof(struct mdglobaldata) + PAGE_MASK) & ~PAGE_MASK)
bpage->vaddr |= vaddr & PAGE_MASK;
bpage->busaddr |= vaddr & PAGE_MASK;
size = PAGE_SIZE - (bpage->busaddr & PAGE_MASK);
bpage->vaddr &= ~PAGE_MASK;
bpage->busaddr &= ~PAGE_MASK;
if ((vaddr ^ (vaddr + dmat->maxsize - 1)) & ~PAGE_MASK) {
vaddr += (PAGE_SIZE - (vaddr & PAGE_MASK));
size = PAGE_SIZE - (paddr & PAGE_MASK);
#define MD_ALIGN(x) (((off_t)(x) + PAGE_MASK) & ~PAGE_MASK)
ASSYM(PAGE_MASK, PAGE_MASK);
incr = (incr + PAGE_MASK) &
~(vm_paddr_t)PAGE_MASK;
if ((sz & PAGE_MASK)) {
if (pa != 0 && (((uintptr_t)pa) & PAGE_MASK) != 0) {
#define MD_ALIGN(x) (((off_t)(x) + PAGE_MASK) & ~PAGE_MASK)
va = base & ~(vm_offset_t)PAGE_MASK;
ptp = (void *)PHYS_TO_DMAP(pte & ~(pt_entry_t)PAGE_MASK);
rtval |= va & PAGE_MASK;
rtval |= va & PAGE_MASK;
pa = (pa & PG_FRAME) | (va & PAGE_MASK);
KASSERT((sva & PAGE_MASK) == 0,
KASSERT((eva & PAGE_MASK) == 0,
bcopy((char *)src_virt + (src & PAGE_MASK),
(char *)dst_virt + (dst & PAGE_MASK),
offset = pa & PAGE_MASK;
pa = pa & ~PAGE_MASK;
base = va & ~PAGE_MASK;
offset = va & PAGE_MASK;
pa = (pte & PG_FRAME) | (va & PAGE_MASK);
((sizeof(struct mdglobaldata) + PAGE_MASK) & ~PAGE_MASK)
if ((vaddr ^ (vaddr + dmat->maxsize - 1)) & ~PAGE_MASK) {
vaddr += (PAGE_SIZE - (vaddr & PAGE_MASK));
size = PAGE_SIZE - (paddr & PAGE_MASK);
dest = (u_int *)(kva + ((vm_offset_t)p & PAGE_MASK));
if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))
res = atomic_swap_long((uint64_t *)(kva + ((vm_offset_t)p & PAGE_MASK)),
if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))
res = atomic_swap_int((u_int *)(kva + ((vm_offset_t)p & PAGE_MASK)),
if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))
res = atomic_fetchadd_long((uint64_t *)(kva + ((vm_offset_t)p & PAGE_MASK)),
if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))
res = atomic_fetchadd_int((u_int *)(kva + ((vm_offset_t)p & PAGE_MASK)),
n = PAGE_SIZE - ((vm_offset_t)uptr & PAGE_MASK);
n = PAGE_SIZE - ((vm_offset_t)udaddr & PAGE_MASK);
bcopy((char *)lwbuf_kva(lwb)+((vm_offset_t)udaddr & PAGE_MASK),
n = PAGE_SIZE - ((vm_offset_t)udaddr & PAGE_MASK);
((vm_offset_t)udaddr & PAGE_MASK), n);
if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(uint64_t))
dest = (uint64_t *)(kva + ((vm_offset_t)p & PAGE_MASK));
if (PAGE_SIZE - ((vm_offset_t)p & PAGE_MASK) < sizeof(u_int))
xtra = (PAGE_SIZE - (vm_offset_t)sbrk(0)) & PAGE_MASK;
phys_avail[0].phys_beg = (phys_avail[0].phys_beg + PAGE_MASK) &
~(vm_paddr_t)PAGE_MASK;
virtual_start = (virtual_start + PAGE_MASK) & ~(vm_offset_t)PAGE_MASK;
assert((MSGBUF_SIZE & PAGE_MASK) == 0);
bcopy((char *)src_virt + (src & PAGE_MASK),
(char *)dst_virt + (dst & PAGE_MASK),
if (PAGE_SIZE - (va & PAGE_MASK) < sizeof(u_int))
pa = VM_PAGE_TO_PHYS(m) | (va & PAGE_MASK);
rtval = (*pte & VPTE_FRAME) | (va & PAGE_MASK);
pa = (pa & VPTE_FRAME) | (va & PAGE_MASK);
#define trunc_page64(x) ((x) & ~(int64_t)PAGE_MASK)
#define round_page64(x) (((x) + PAGE_MASK) & ~(int64_t)PAGE_MASK)
if ((vm_offset_t)base & PAGE_MASK) {
int n = PAGE_SIZE - ((vm_offset_t)base & PAGE_MASK);
bytes &= ~PAGE_MASK;
if (off & PAGE_MASK) {
cnt += off & PAGE_MASK;
off &= ~(u_quad_t)PAGE_MASK;
(cnt + PAGE_MASK) / PAGE_SIZE, OBJPC_SYNC);
if (iosize & PAGE_MASK)
iosize = (iosize & ~PAGE_MASK) + PAGE_SIZE;
if (foff & PAGE_MASK)
if (foff & PAGE_MASK)
if (bp->b_bcount & PAGE_MASK) {
OFF_TO_IDX(offset + PAGE_MASK + size));
vaddr & ~PAGE_MASK,
(vaddr & ~PAGE_MASK) + PAGE_SIZE);
if (next_ba->offset & PAGE_MASK)
OFF_TO_IDX(offset + size + PAGE_MASK),
OFF_TO_IDX(offset + size + PAGE_MASK),
pageoff = (addr & PAGE_MASK);
pageoff = (addr & PAGE_MASK);
if (foff & PAGE_MASK) {
pageoff = (pos & PAGE_MASK);
if (addr & PAGE_MASK)
pageoff = (addr & PAGE_MASK);
pageoff = (addr & PAGE_MASK);
pageoff = (addr & PAGE_MASK);
pageoff = (addr & PAGE_MASK);
size = (size + PAGE_MASK) >> PAGE_SHIFT;
vm_pindex_t pages = (size + PAGE_MASK) >> PAGE_SHIFT;
if ((base & PAGE_MASK) != 0 &&
((base ^ (base_end - 1)) & ~(vm_offset_t)PAGE_MASK) == 0) {
pageoff = (addr & PAGE_MASK);
nobjsize = OFF_TO_IDX(nsize + PAGE_MASK);
if (nsize & PAGE_MASK) {
int base = (int)nsize & PAGE_MASK;
buf += (bytes + PAGE_MASK) & ~PAGE_MASK;
buf += (bytes + PAGE_MASK) & ~PAGE_MASK;