/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License, Version 1.0 only * (the "License"). You may not use this file except in compliance * with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright 2005 Sun Microsystems, Inc. All rights reserved. * Use is subject to license terms. */ /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ /* All Rights Reserved */ #pragma ident "%Z%%M% %I% %E% SMI" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include int use_brk_lpg = 1; int use_stk_lpg = 1; int use_zmap_lpg = 1; static int brk_lpg(caddr_t nva); static int grow_lpg(caddr_t sp); int brk(caddr_t nva) { int error; proc_t *p = curproc; /* * Serialize brk operations on an address space. * This also serves as the lock protecting p_brksize * and p_brkpageszc. */ as_rangelock(p->p_as); if (use_brk_lpg && (p->p_flag & SAUTOLPG) != 0) { error = brk_lpg(nva); } else { error = brk_internal(nva, p->p_brkpageszc); } as_rangeunlock(p->p_as); return ((error != 0 ? set_errno(error) : 0)); } /* * Algorithm: call arch-specific map_pgsz to get best page size to use, * then call brk_internal(). * Returns 0 on success. */ static int brk_lpg(caddr_t nva) { struct proc *p = curproc; size_t pgsz, len; caddr_t addr; caddr_t bssbase = p->p_bssbase; caddr_t brkbase = p->p_brkbase; int oszc, szc; int err; int remap = 0; oszc = p->p_brkpageszc; /* * If p_brkbase has not yet been set, the first call * to brk_internal() will initialize it. */ if (brkbase == 0) { return (brk_internal(nva, oszc)); } len = nva - bssbase; pgsz = map_pgsz(MAPPGSZ_HEAP, p, bssbase, len, &remap); szc = page_szc(pgsz); /* * Covers two cases: * 1. page_szc() returns -1 for invalid page size, so we want to * ignore it in that case. * 2. By design we never decrease page size, as it is more stable. */ if (szc <= oszc) { err = brk_internal(nva, oszc); /* If failed, back off to base page size. */ if (err != 0 && oszc != 0) { err = brk_internal(nva, 0); } return (err); } if (remap == 0) { /* * Map from the current brk end up to the new page size * alignment using the current page size. */ addr = brkbase + p->p_brksize; addr = (caddr_t)P2ROUNDUP((uintptr_t)addr, pgsz); if (addr < nva) { err = brk_internal(addr, oszc); /* * In failure case, try again if oszc is not base page * size, then return err. */ if (err != 0) { if (oszc != 0) { err = brk_internal(nva, 0); } return (err); } } } err = brk_internal(nva, szc); /* If using szc failed, map with base page size and return. */ if (err != 0) { if (szc != 0) { err = brk_internal(nva, 0); } return (err); } if (remap != 0) { /* * Round up brk base to a large page boundary and remap * anything in the segment already faulted in beyond that * point. */ addr = (caddr_t)P2ROUNDUP((uintptr_t)p->p_bssbase, pgsz); len = (brkbase + p->p_brksize) - addr; /* advisory, so ignore errors */ (void) as_setpagesize(p->p_as, addr, len, szc, B_FALSE); } ASSERT(err == 0); return (err); /* should always be 0 */ } /* * Returns 0 on success. */ int brk_internal(caddr_t nva, uint_t brkszc) { caddr_t ova; /* current break address */ size_t size; int error; struct proc *p = curproc; struct as *as = p->p_as; size_t pgsz; uint_t szc; rctl_qty_t as_rctl; /* * extend heap to brkszc alignment but use current p->p_brkpageszc * for the newly created segment. This allows the new extension * segment to be concatenated successfully with the existing brk * segment. */ if ((szc = brkszc) != 0) { pgsz = page_get_pagesize(szc); ASSERT(pgsz > PAGESIZE); } else { pgsz = PAGESIZE; } mutex_enter(&p->p_lock); as_rctl = rctl_enforced_value(rctlproc_legacy[RLIMIT_DATA], p->p_rctls, p); mutex_exit(&p->p_lock); /* * If p_brkbase has not yet been set, the first call * to brk() will initialize it. */ if (p->p_brkbase == 0) p->p_brkbase = nva; /* * Before multiple page size support existed p_brksize was the value * not rounded to the pagesize (i.e. it stored the exact user request * for heap size). If pgsz is greater than PAGESIZE calculate the * heap size as the real new heap size by rounding it up to pgsz. * This is useful since we may want to know where the heap ends * without knowing heap pagesize (e.g. some old code) and also if * heap pagesize changes we can update p_brkpageszc but delay adding * new mapping yet still know from p_brksize where the heap really * ends. The user requested heap end is stored in libc variable. */ if (pgsz > PAGESIZE) { caddr_t tnva = (caddr_t)P2ROUNDUP((uintptr_t)nva, pgsz); size = tnva - p->p_brkbase; if (tnva < p->p_brkbase || (size > p->p_brksize && size > (size_t)as_rctl)) { szc = 0; pgsz = PAGESIZE; size = nva - p->p_brkbase; } } else { size = nva - p->p_brkbase; } /* * use PAGESIZE to roundup ova because we want to know the real value * of the current heap end in case p_brkpageszc changes since the last * p_brksize was computed. */ nva = (caddr_t)P2ROUNDUP((uintptr_t)nva, pgsz); ova = (caddr_t)P2ROUNDUP((uintptr_t)(p->p_brkbase + p->p_brksize), PAGESIZE); if ((nva < p->p_brkbase) || (size > p->p_brksize && size > as_rctl)) { mutex_enter(&p->p_lock); (void) rctl_action(rctlproc_legacy[RLIMIT_DATA], p->p_rctls, p, RCA_SAFE); mutex_exit(&p->p_lock); return (ENOMEM); } if (nva > ova) { struct segvn_crargs crargs = SEGVN_ZFOD_ARGS(PROT_ZFOD, PROT_ALL); if (!(p->p_datprot & PROT_EXEC)) { crargs.prot &= ~PROT_EXEC; } /* * Add new zfod mapping to extend UNIX data segment */ crargs.szc = szc; crargs.lgrp_mem_policy_flags = LGRP_MP_FLAG_EXTEND_UP; error = as_map(as, ova, (size_t)(nva - ova), segvn_create, &crargs); if (error) { return (error); } } else if (nva < ova) { /* * Release mapping to shrink UNIX data segment. */ (void) as_unmap(as, nva, (size_t)(ova - nva)); } p->p_brksize = size; p->p_brkpageszc = szc; return (0); } /* * Grow the stack to include sp. Return 1 if successful, 0 otherwise. * This routine assumes that the stack grows downward. */ int grow(caddr_t sp) { struct proc *p = curproc; int err; /* * Serialize grow operations on an address space. * This also serves as the lock protecting p_stksize * and p_stkpageszc. */ as_rangelock(p->p_as); if (use_stk_lpg && (p->p_flag & SAUTOLPG) != 0) { err = grow_lpg(sp); } else { err = grow_internal(sp, p->p_stkpageszc); } as_rangeunlock(p->p_as); return ((err == 0 ? 1 : 0)); } /* * Algorithm: call arch-specific map_pgsz to get best page size to use, * then call grow_internal(). * Returns 0 on success. */ static int grow_lpg(caddr_t sp) { struct proc *p = curproc; size_t pgsz; size_t len, newsize; caddr_t addr, oldsp; int oszc, szc; int err; int remap = 0; newsize = p->p_usrstack - sp; oszc = p->p_stkpageszc; pgsz = map_pgsz(MAPPGSZ_STK, p, sp, newsize, &remap); szc = page_szc(pgsz); /* * Covers two cases: * 1. page_szc() returns -1 for invalid page size, so we want to * ignore it in that case. * 2. By design we never decrease page size, as it is more stable. * This shouldn't happen as the stack never shrinks. */ if (szc <= oszc) { err = grow_internal(sp, oszc); /* failed, fall back to base page size */ if (err != 0 && oszc != 0) { err = grow_internal(sp, 0); } return (err); } /* * We've grown sufficiently to switch to a new page size. * If we're not going to remap the whole segment with the new * page size, split the grow into two operations: map to the new * page size alignment boundary with the existing page size, then * map the rest with the new page size. */ err = 0; if (remap == 0) { oldsp = p->p_usrstack - p->p_stksize; addr = (caddr_t)P2ALIGN((uintptr_t)oldsp, pgsz); if (addr > sp) { err = grow_internal(addr, oszc); /* * In this case, grow with oszc failed, so grow all the * way to sp with base page size. */ if (err != 0) { if (oszc != 0) { err = grow_internal(sp, 0); } return (err); } } } err = grow_internal(sp, szc); /* The grow with szc failed, so fall back to base page size. */ if (err != 0) { if (szc != 0) { err = grow_internal(sp, 0); } return (err); } if (remap) { /* * Round up stack pointer to a large page boundary and remap * any pgsz pages in the segment already faulted in beyond that * point. */ addr = p->p_usrstack - p->p_stksize; addr = (caddr_t)P2ROUNDUP((uintptr_t)addr, pgsz); len = (caddr_t)P2ALIGN((uintptr_t)p->p_usrstack, pgsz) - addr; /* advisory, so ignore errors */ (void) as_setpagesize(p->p_as, addr, len, szc, B_FALSE); } /* Update page size code for stack. */ p->p_stkpageszc = szc; ASSERT(err == 0); return (err); /* should always be 0 */ } /* * This routine assumes that the stack grows downward. * Returns 0 on success, errno on failure. */ int grow_internal(caddr_t sp, uint_t growszc) { struct proc *p = curproc; struct as *as = p->p_as; size_t newsize = p->p_usrstack - sp; size_t oldsize; int error; size_t pgsz; uint_t szc; struct segvn_crargs crargs = SEGVN_ZFOD_ARGS(PROT_ZFOD, PROT_ALL); ASSERT(sp < p->p_usrstack); /* * grow to growszc alignment but use current p->p_stkpageszc for * the segvn_crargs szc passed to segvn_create. For memcntl to * increase the szc, this allows the new extension segment to be * concatenated successfully with the existing stack segment. */ if ((szc = growszc) != 0) { pgsz = page_get_pagesize(szc); ASSERT(pgsz > PAGESIZE); newsize = P2ROUNDUP(newsize, pgsz); if (newsize > (size_t)p->p_stk_ctl) { szc = 0; pgsz = PAGESIZE; newsize = p->p_usrstack - sp; } } else { pgsz = PAGESIZE; } if (newsize > (size_t)p->p_stk_ctl) { (void) rctl_action(rctlproc_legacy[RLIMIT_STACK], p->p_rctls, p, RCA_UNSAFE_ALL); return (ENOMEM); } oldsize = p->p_stksize; newsize = P2ROUNDUP(newsize, pgsz); ASSERT(P2PHASE(oldsize, PAGESIZE) == 0); if (newsize <= oldsize) { /* prevent the stack from shrinking */ return (0); } if (!(p->p_stkprot & PROT_EXEC)) { crargs.prot &= ~PROT_EXEC; } /* * extend stack with the p_stkpageszc. growszc is different than * p_stkpageszc only on a memcntl to increase the stack pagesize. */ crargs.szc = p->p_stkpageszc; crargs.lgrp_mem_policy_flags = LGRP_MP_FLAG_EXTEND_DOWN; if ((error = as_map(as, p->p_usrstack - newsize, newsize - oldsize, segvn_create, &crargs)) != 0) { if (error == EAGAIN) { cmn_err(CE_WARN, "Sorry, no swap space to grow stack " "for pid %d (%s)", p->p_pid, u.u_comm); } return (error); } p->p_stksize = newsize; /* * Set up translations so the process doesn't have to fault in * the stack pages we just gave it. */ (void) as_fault(as->a_hat, as, p->p_usrstack - newsize, newsize - oldsize, F_INVAL, S_WRITE); return (0); } /* * Used for MAP_ANON - fast way to get anonymous pages */ static int zmap(struct as *as, caddr_t *addrp, size_t len, uint_t uprot, int flags, offset_t pos) { struct segvn_crargs a, b; struct proc *p = curproc; int err; size_t pgsz; size_t l0, l1, l2, l3, l4; /* 0th through 5th chunks */ caddr_t ruaddr, ruaddr0; /* rounded up addresses */ extern size_t auto_lpg_va_default; if (((PROT_ALL & uprot) != uprot)) return (EACCES); if ((flags & MAP_FIXED) != 0) { caddr_t userlimit; /* * Use the user address. First verify that * the address to be used is page aligned. * Then make some simple bounds checks. */ if (((uintptr_t)*addrp & PAGEOFFSET) != 0) return (EINVAL); userlimit = flags & _MAP_LOW32 ? (caddr_t)USERLIMIT32 : as->a_userlimit; switch (valid_usr_range(*addrp, len, uprot, as, userlimit)) { case RANGE_OKAY: break; case RANGE_BADPROT: return (ENOTSUP); case RANGE_BADADDR: default: return (ENOMEM); } (void) as_unmap(as, *addrp, len); } else { /* * No need to worry about vac alignment for anonymous * pages since this is a "clone" object that doesn't * yet exist. */ map_addr(addrp, len, pos, 0, flags); if (*addrp == NULL) return (ENOMEM); } /* * Use the seg_vn segment driver; passing in the NULL amp * gives the desired "cloning" effect. */ a.vp = NULL; a.offset = 0; a.type = flags & MAP_TYPE; a.prot = uprot; a.maxprot = PROT_ALL; a.flags = flags & ~MAP_TYPE; a.cred = CRED(); a.amp = NULL; a.szc = 0; a.lgrp_mem_policy_flags = 0; /* * Call arch-specific map_pgsz routine to pick best page size to map * this segment, and break the mapping up into parts if required. * * The parts work like this: * * addr --------- * | | l0 * --------- * | | l1 * --------- * | | l2 * --------- * | | l3 * --------- * | | l4 * --------- * addr+len * * Starting from the middle, l2 is the number of bytes mapped by the * selected large page. l1 and l3 are mapped by auto_lpg_va_default * page size pages, and l0 and l4 are mapped by base page size pages. * If auto_lpg_va_default is the base page size, then l0 == l4 == 0. * If the requested address or length are aligned to the selected large * page size, l1 or l3 may also be 0. */ if (use_zmap_lpg) { pgsz = map_pgsz(MAPPGSZ_VA, p, *addrp, len, NULL); if (pgsz <= PAGESIZE || len < pgsz) { return (as_map(as, *addrp, len, segvn_create, &a)); } ruaddr = (caddr_t)P2ROUNDUP((uintptr_t)*addrp, pgsz); if (auto_lpg_va_default != MMU_PAGESIZE) { ruaddr0 = (caddr_t)P2ROUNDUP((uintptr_t)*addrp, auto_lpg_va_default); l0 = ruaddr0 - *addrp; } else { l0 = 0; ruaddr0 = *addrp; } l1 = ruaddr - ruaddr0; l3 = P2PHASE(len - l0 - l1, pgsz); if (auto_lpg_va_default == MMU_PAGESIZE) { l4 = 0; } else { l4 = P2PHASE(l3, auto_lpg_va_default); l3 -= l4; } l2 = len - l0 - l1 - l3 - l4; if (l0) { b = a; err = as_map(as, *addrp, l0, segvn_create, &b); if (err) { return (err); } } if (l1) { b = a; b.szc = page_szc(auto_lpg_va_default); err = as_map(as, ruaddr0, l1, segvn_create, &b); if (err) { goto error1; } } if (l2) { b = a; b.szc = page_szc(pgsz); err = as_map(as, ruaddr, l2, segvn_create, &b); if (err) { goto error2; } } if (l3) { b = a; b.szc = page_szc(auto_lpg_va_default); err = as_map(as, ruaddr + l2, l3, segvn_create, &b); if (err) { goto error3; } } if (l4) { err = as_map(as, ruaddr + l2 + l3, l4, segvn_create, &a); if (err) { error3: if (l3) { (void) as_unmap(as, ruaddr + l2, l3); } error2: if (l2) { (void) as_unmap(as, ruaddr, l2); } error1: if (l1) { (void) as_unmap(as, ruaddr0, l1); } if (l0) { (void) as_unmap(as, *addrp, l0); } return (err); } } return (0); } return (as_map(as, *addrp, len, segvn_create, &a)); } static int smmap_common(caddr_t *addrp, size_t len, int prot, int flags, struct file *fp, offset_t pos) { struct vnode *vp; struct as *as = curproc->p_as; uint_t uprot, maxprot, type; int error; if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | _MAP_NEW | _MAP_LOW32 | MAP_NORESERVE | MAP_ANON | MAP_ALIGN | MAP_TEXT | MAP_INITDATA)) != 0) { /* | MAP_RENAME */ /* not implemented, let user know */ return (EINVAL); } if ((flags & MAP_TEXT) && !(prot & PROT_EXEC)) { return (EINVAL); } if ((flags & (MAP_TEXT | MAP_INITDATA)) == (MAP_TEXT | MAP_INITDATA)) { return (EINVAL); } #if defined(__sparc) /* * See if this is an "old mmap call". If so, remember this * fact and convert the flags value given to mmap to indicate * the specified address in the system call must be used. * _MAP_NEW is turned set by all new uses of mmap. */ if ((flags & _MAP_NEW) == 0) flags |= MAP_FIXED; #endif flags &= ~_MAP_NEW; type = flags & MAP_TYPE; if (type != MAP_PRIVATE && type != MAP_SHARED) return (EINVAL); if (flags & MAP_ALIGN) { if (flags & MAP_FIXED) return (EINVAL); /* alignment needs to be a power of 2 >= page size */ if (((uintptr_t)*addrp < PAGESIZE && (uintptr_t)*addrp != 0) || !ISP2((uintptr_t)*addrp)) return (EINVAL); } /* * Check for bad lengths and file position. * We let the VOP_MAP routine check for negative lengths * since on some vnode types this might be appropriate. */ if (len == 0 || (pos & (u_offset_t)PAGEOFFSET) != 0) return (EINVAL); maxprot = PROT_ALL; /* start out allowing all accesses */ uprot = prot | PROT_USER; if (fp == NULL) { ASSERT(flags & MAP_ANON); as_rangelock(as); error = zmap(as, addrp, len, uprot, flags, pos); as_rangeunlock(as); return (error); } else if ((flags & MAP_ANON) != 0) return (EINVAL); vp = fp->f_vnode; /* Can't execute code from "noexec" mounted filesystem. */ if ((vp->v_vfsp->vfs_flag & VFS_NOEXEC) != 0) maxprot &= ~PROT_EXEC; /* * These checks were added as part of large files. * * Return ENXIO if the initial position is negative; return EOVERFLOW * if (offset + len) would overflow the maximum allowed offset for the * type of file descriptor being used. */ if (vp->v_type == VREG) { if (pos < 0) return (ENXIO); if ((offset_t)len > (OFFSET_MAX(fp) - pos)) return (EOVERFLOW); } if (type == MAP_SHARED && (fp->f_flag & FWRITE) == 0) { /* no write access allowed */ maxprot &= ~PROT_WRITE; } /* * XXX - Do we also adjust maxprot based on protections * of the vnode? E.g. if no execute permission is given * on the vnode for the current user, maxprot probably * should disallow PROT_EXEC also? This is different * from the write access as this would be a per vnode * test as opposed to a per fd test for writability. */ /* * Verify that the specified protections are not greater than * the maximum allowable protections. Also test to make sure * that the file descriptor does allows for read access since * "write only" mappings are hard to do since normally we do * the read from the file before the page can be written. */ if (((maxprot & uprot) != uprot) || (fp->f_flag & FREAD) == 0) return (EACCES); /* * If the user specified an address, do some simple checks here */ if ((flags & MAP_FIXED) != 0) { caddr_t userlimit; /* * Use the user address. First verify that * the address to be used is page aligned. * Then make some simple bounds checks. */ if (((uintptr_t)*addrp & PAGEOFFSET) != 0) return (EINVAL); userlimit = flags & _MAP_LOW32 ? (caddr_t)USERLIMIT32 : as->a_userlimit; switch (valid_usr_range(*addrp, len, uprot, as, userlimit)) { case RANGE_OKAY: break; case RANGE_BADPROT: return (ENOTSUP); case RANGE_BADADDR: default: return (ENOMEM); } } /* * Ok, now let the vnode map routine do its thing to set things up. */ error = VOP_MAP(vp, pos, as, addrp, len, uprot, maxprot, flags, fp->f_cred); if (error == 0) { if (vp->v_type == VREG && (flags & (MAP_TEXT | MAP_INITDATA)) != 0) { /* * Mark this as an executable vnode */ mutex_enter(&vp->v_lock); vp->v_flag |= VVMEXEC; mutex_exit(&vp->v_lock); } } return (error); } #ifdef _LP64 /* * LP64 mmap(2) system call: 64-bit offset, 64-bit address. * * The "large file" mmap routine mmap64(2) is also mapped to this routine * by the 64-bit version of libc. * * Eventually, this should be the only version, and have smmap_common() * folded back into it again. Some day. */ caddr_t smmap64(caddr_t addr, size_t len, int prot, int flags, int fd, off_t pos) { struct file *fp; int error; if (flags & _MAP_LOW32) error = EINVAL; else if (fd == -1 && (flags & MAP_ANON) != 0) error = smmap_common(&addr, len, prot, flags, NULL, (offset_t)pos); else if ((fp = getf(fd)) != NULL) { error = smmap_common(&addr, len, prot, flags, fp, (offset_t)pos); releasef(fd); } else error = EBADF; return (error ? (caddr_t)(uintptr_t)set_errno(error) : addr); } #endif /* _LP64 */ #if defined(_SYSCALL32_IMPL) || defined(_ILP32) /* * ILP32 mmap(2) system call: 32-bit offset, 32-bit address. */ caddr_t smmap32(caddr32_t addr, size32_t len, int prot, int flags, int fd, off32_t pos) { struct file *fp; int error; caddr_t a = (caddr_t)(uintptr_t)addr; if (flags & _MAP_LOW32) error = EINVAL; else if (fd == -1 && (flags & MAP_ANON) != 0) error = smmap_common(&a, (size_t)len, prot, flags | _MAP_LOW32, NULL, (offset_t)pos); else if ((fp = getf(fd)) != NULL) { error = smmap_common(&a, (size_t)len, prot, flags | _MAP_LOW32, fp, (offset_t)pos); releasef(fd); } else error = EBADF; ASSERT(error != 0 || (uintptr_t)(a + len) < (uintptr_t)UINT32_MAX); return (error ? (caddr_t)(uintptr_t)set_errno(error) : a); } /* * ILP32 mmap64(2) system call: 64-bit offset, 32-bit address. * * Now things really get ugly because we can't use the C-style * calling convention for more than 6 args, and 64-bit parameter * passing on 32-bit systems is less than clean. */ struct mmaplf32a { caddr_t addr; size_t len; #ifdef _LP64 /* * 32-bit contents, 64-bit cells */ uint64_t prot; uint64_t flags; uint64_t fd; uint64_t offhi; uint64_t offlo; #else /* * 32-bit contents, 32-bit cells */ uint32_t prot; uint32_t flags; uint32_t fd; uint32_t offhi; uint32_t offlo; #endif }; int smmaplf32(struct mmaplf32a *uap, rval_t *rvp) { struct file *fp; int error; caddr_t a = uap->addr; int flags = (int)uap->flags; int fd = (int)uap->fd; #ifdef _BIG_ENDIAN offset_t off = ((u_offset_t)uap->offhi << 32) | (u_offset_t)uap->offlo; #else offset_t off = ((u_offset_t)uap->offlo << 32) | (u_offset_t)uap->offhi; #endif if (flags & _MAP_LOW32) error = EINVAL; else if (fd == -1 && (flags & MAP_ANON) != 0) error = smmap_common(&a, uap->len, (int)uap->prot, flags | _MAP_LOW32, NULL, off); else if ((fp = getf(fd)) != NULL) { error = smmap_common(&a, uap->len, (int)uap->prot, flags | _MAP_LOW32, fp, off); releasef(fd); } else error = EBADF; if (error == 0) rvp->r_val1 = (uintptr_t)a; return (error); } #endif /* _SYSCALL32_IMPL || _ILP32 */ int munmap(caddr_t addr, size_t len) { struct proc *p = curproc; struct as *as = p->p_as; if (((uintptr_t)addr & PAGEOFFSET) != 0 || len == 0) return (set_errno(EINVAL)); if (valid_usr_range(addr, len, 0, as, as->a_userlimit) != RANGE_OKAY) return (set_errno(EINVAL)); /* * Discard lwpchan mappings. */ if (p->p_lcp != NULL) lwpchan_delete_mapping(p, addr, addr + len); if (as_unmap(as, addr, len) != 0) return (set_errno(EINVAL)); return (0); } int mprotect(caddr_t addr, size_t len, int prot) { struct as *as = curproc->p_as; uint_t uprot = prot | PROT_USER; int error; if (((uintptr_t)addr & PAGEOFFSET) != 0 || len == 0) return (set_errno(EINVAL)); switch (valid_usr_range(addr, len, prot, as, as->a_userlimit)) { case RANGE_OKAY: break; case RANGE_BADPROT: return (set_errno(ENOTSUP)); case RANGE_BADADDR: default: return (set_errno(ENOMEM)); } error = as_setprot(as, addr, len, uprot); if (error) return (set_errno(error)); return (0); } #define MC_CACHE 128 /* internal result buffer */ #define MC_QUANTUM (MC_CACHE * PAGESIZE) /* addresses covered in loop */ int mincore(caddr_t addr, size_t len, char *vecp) { struct as *as = curproc->p_as; caddr_t ea; /* end address of loop */ size_t rl; /* inner result length */ char vec[MC_CACHE]; /* local vector cache */ int error; model_t model; long llen; model = get_udatamodel(); /* * Validate form of address parameters. */ if (model == DATAMODEL_NATIVE) { llen = (long)len; } else { llen = (int32_t)(size32_t)len; } if (((uintptr_t)addr & PAGEOFFSET) != 0 || llen <= 0) return (set_errno(EINVAL)); if (valid_usr_range(addr, len, 0, as, as->a_userlimit) != RANGE_OKAY) return (set_errno(ENOMEM)); /* * Loop over subranges of interval [addr : addr + len), recovering * results internally and then copying them out to caller. Subrange * is based on the size of MC_CACHE, defined above. */ for (ea = addr + len; addr < ea; addr += MC_QUANTUM) { error = as_incore(as, addr, (size_t)MIN(MC_QUANTUM, ea - addr), vec, &rl); if (rl != 0) { rl = (rl + PAGESIZE - 1) / PAGESIZE; if (copyout(vec, vecp, rl) != 0) return (set_errno(EFAULT)); vecp += rl; } if (error != 0) return (set_errno(ENOMEM)); } return (0); }