diff options
Diffstat (limited to 'sys/uvm')
| -rw-r--r-- | sys/uvm/uvm_extern.h | 5 | ||||
| -rw-r--r-- | sys/uvm/uvm_fault.c | 11 | ||||
| -rw-r--r-- | sys/uvm/uvm_map.c | 300 | ||||
| -rw-r--r-- | sys/uvm/uvm_map_i.h | 6 | ||||
| -rw-r--r-- | sys/uvm/uvm_mmap.c | 204 |
5 files changed, 465 insertions, 61 deletions
diff --git a/sys/uvm/uvm_extern.h b/sys/uvm/uvm_extern.h index 742d3e63732..f6dd3d2aa24 100644 --- a/sys/uvm/uvm_extern.h +++ b/sys/uvm/uvm_extern.h @@ -1,5 +1,5 @@ -/* $OpenBSD: uvm_extern.h,v 1.9 2001/03/09 05:34:38 smart Exp $ */ -/* $NetBSD: uvm_extern.h,v 1.27 1999/05/26 19:16:36 thorpej Exp $ */ +/* $OpenBSD: uvm_extern.h,v 1.10 2001/03/09 14:20:50 art Exp $ */ +/* $NetBSD: uvm_extern.h,v 1.28 1999/06/15 23:27:47 thorpej Exp $ */ /* * @@ -325,6 +325,7 @@ int uvm_map __P((vm_map_t, vaddr_t *, vsize_t, struct uvm_object *, vaddr_t, uvm_flag_t)); int uvm_map_pageable __P((vm_map_t, vaddr_t, vaddr_t, boolean_t)); +int uvm_map_pageable_all __P((vm_map_t, int, vsize_t)); boolean_t uvm_map_checkprot __P((vm_map_t, vaddr_t, vaddr_t, vm_prot_t)); int uvm_map_protect __P((vm_map_t, vaddr_t, diff --git a/sys/uvm/uvm_fault.c b/sys/uvm/uvm_fault.c index 0834cd17eb2..4be4a10c3f7 100644 --- a/sys/uvm/uvm_fault.c +++ b/sys/uvm/uvm_fault.c @@ -1,5 +1,5 @@ -/* $OpenBSD: uvm_fault.c,v 1.7 2001/03/08 15:21:36 smart Exp $ */ -/* $NetBSD: uvm_fault.c,v 1.33 1999/06/04 23:38:41 thorpej Exp $ */ +/* $OpenBSD: uvm_fault.c,v 1.8 2001/03/09 14:20:51 art Exp $ */ +/* $NetBSD: uvm_fault.c,v 1.35 1999/06/16 18:43:28 thorpej Exp $ */ /* * @@ -646,7 +646,7 @@ ReFault: */ enter_prot = ufi.entry->protection; - wired = (ufi.entry->wired_count != 0) || (fault_type == VM_FAULT_WIRE); + wired = VM_MAPENT_ISWIRED(ufi.entry) || (fault_type == VM_FAULT_WIRE); if (wired) access_type = enter_prot; /* full access for wired */ @@ -846,7 +846,7 @@ ReFault: VM_PAGE_TO_PHYS(anon->u.an_page), (anon->an_ref > 1) ? (enter_prot & ~VM_PROT_WRITE) : enter_prot, - (ufi.entry->wired_count != 0), 0); + VM_MAPENT_ISWIRED(ufi.entry), 0); } simple_unlock(&anon->an_lock); } @@ -1734,8 +1734,7 @@ uvm_fault_wire(map, start, end, access_type) /* * now fault it in page at a time. if the fault fails then we have - * to undo what we have done. note that in uvm_fault VM_PROT_NONE - * is replaced with the max protection if fault_type is VM_FAULT_WIRE. + * to undo what we have done. */ for (va = start ; va < end ; va += PAGE_SIZE) { diff --git a/sys/uvm/uvm_map.c b/sys/uvm/uvm_map.c index 6b6355e9207..f5e6bbc8c4b 100644 --- a/sys/uvm/uvm_map.c +++ b/sys/uvm/uvm_map.c @@ -1,5 +1,5 @@ -/* $OpenBSD: uvm_map.c,v 1.8 2001/01/29 02:07:46 niklas Exp $ */ -/* $NetBSD: uvm_map.c,v 1.53 1999/06/07 16:31:42 thorpej Exp $ */ +/* $OpenBSD: uvm_map.c,v 1.9 2001/03/09 14:20:51 art Exp $ */ +/* $NetBSD: uvm_map.c,v 1.56 1999/06/16 19:34:24 thorpej Exp $ */ /* * Copyright (c) 1997 Charles D. Cranor and Washington University. @@ -595,8 +595,8 @@ uvm_map(map, startp, size, uobj, uoffset, flags) prev_entry->advice != advice) goto step3; - /* wired_count's must match (new area is unwired) */ - if (prev_entry->wired_count) + /* wiring status must match (new area is unwired) */ + if (VM_MAPENT_ISWIRED(prev_entry)) goto step3; /* @@ -987,7 +987,7 @@ uvm_unmap_remove(map, start, end, entry_list) * unwiring will put the entries back into the pmap (XXX). */ - if (entry->wired_count) + if (VM_MAPENT_ISWIRED(entry)) uvm_map_entry_unwire(map, entry); /* @@ -1112,7 +1112,7 @@ uvm_unmap_detach(first_entry, amap_unref_flags) * sanity check */ /* was part of vm_map_entry_delete() */ - if (first_entry->wired_count) + if (VM_MAPENT_ISWIRED(first_entry)) panic("unmap: still wired!"); #endif @@ -1974,6 +1974,8 @@ uvm_map_advice(map, start, end, new_advice) /* * uvm_map_pageable: sets the pageability of a range in a map. * + * => wires map entries. should not be used for transient page locking. + * for that, use uvm_fault_wire()/uvm_fault_unwire() (see uvm_vslock()). * => regions sepcified as not pageable require lock-down (wired) memory * and page tables. * => map must not be locked. @@ -1986,8 +1988,7 @@ uvm_map_pageable(map, start, end, new_pageable) vaddr_t start, end; boolean_t new_pageable; { - vm_map_entry_t entry, start_entry; - vaddr_t failed = 0; + vm_map_entry_t entry, start_entry, failed_entry; int rv; UVMHIST_FUNC("uvm_map_pageable"); UVMHIST_CALLED(maphist); UVMHIST_LOG(maphist,"(map=0x%x,start=0x%x,end=0x%x,new_pageable=0x%x)", @@ -2021,20 +2022,17 @@ uvm_map_pageable(map, start, end, new_pageable) * handle wiring and unwiring separately. */ - if (new_pageable) { /* unwire */ - + if (new_pageable) { /* unwire */ UVM_MAP_CLIP_START(map, entry, start); - /* * unwiring. first ensure that the range to be unwired is * really wired down and that there are no holes. */ while ((entry != &map->header) && (entry->start < end)) { - if (entry->wired_count == 0 || (entry->end < end && - (entry->next == &map->header || - entry->next->start > entry->end))) { + (entry->next == &map->header || + entry->next->start > entry->end))) { vm_map_unlock(map); UVMHIST_LOG(maphist, "<- done (INVALID UNWIRE ARG)",0,0,0,0); @@ -2044,23 +2042,19 @@ uvm_map_pageable(map, start, end, new_pageable) } /* - * now decrement the wiring count for each region. if a region - * becomes completely unwired, unwire its physical pages and - * mappings. + * POSIX 1003.1b - a single munlock call unlocks a region, + * regardless of the number of mlock calls made on that + * region. * * Note, uvm_fault_unwire() (called via uvm_map_entry_unwire()) * does not lock the map, so we don't have to do anything * special regarding locking here. */ - entry = start_entry; while ((entry != &map->header) && (entry->start < end)) { UVM_MAP_CLIP_END(map, entry, end); - - entry->wired_count--; - if (entry->wired_count == 0) + if (VM_MAPENT_ISWIRED(entry)) uvm_map_entry_unwire(map, entry); - entry = entry->next; } vm_map_unlock(map); @@ -2080,7 +2074,7 @@ uvm_map_pageable(map, start, end, new_pageable) * be wired and increment its wiring count. * * 2: we downgrade to a read lock, and call uvm_fault_wire to fault - * in the pages for any newly wired area (wired_count is 1). + * in the pages for any newly wired area (wired_count == 1). * * downgrading to a read lock for uvm_fault_wire avoids a possible * deadlock with another thread that may have faulted on one of @@ -2094,9 +2088,7 @@ uvm_map_pageable(map, start, end, new_pageable) */ while ((entry != &map->header) && (entry->start < end)) { - - if (entry->wired_count == 0) { /* not already wired? */ - + if (VM_MAPENT_ISWIRED(entry) == 0) { /* not already wired? */ /* * perform actions of vm_map_lookup that need the * write lock on the map: create an anonymous map @@ -2104,22 +2096,16 @@ uvm_map_pageable(map, start, end, new_pageable) * for a zero-fill region. (XXXCDC: submap case * ok?) */ - if (!UVM_ET_ISSUBMAP(entry)) { /* not submap */ - /* - * XXXCDC: protection vs. max_protection?? - * (wirefault uses max?) - * XXXCDC: used to do it always if - * uvm_obj == NULL (wrong?) - */ - if ( UVM_ET_ISNEEDSCOPY(entry) && - (entry->protection & VM_PROT_WRITE) != 0) { + if (UVM_ET_ISNEEDSCOPY(entry) && + ((entry->protection & VM_PROT_WRITE) || + (entry->object.uvm_obj == NULL))) { amap_copy(map, entry, M_WAITOK, TRUE, start, end); /* XXXCDC: wait OK? */ } } - } /* wired_count == 0 */ + } UVM_MAP_CLIP_START(map, entry, start); UVM_MAP_CLIP_END(map, entry, end); entry->wired_count++; @@ -2127,8 +2113,10 @@ uvm_map_pageable(map, start, end, new_pageable) /* * Check for holes */ - if (entry->end < end && (entry->next == &map->header || - entry->next->start > entry->end)) { + if (entry->protection == VM_PROT_NONE || + (entry->end < end && + (entry->next == &map->header || + entry->next->start > entry->end))) { /* * found one. amap creation actions do not need to * be undone, but the wired counts need to be restored. @@ -2178,16 +2166,24 @@ uvm_map_pageable(map, start, end, new_pageable) * first drop the wiring count on all the entries * which haven't actually been wired yet. */ - failed = entry->start; - while (entry != &map->header && entry->start < end) + failed_entry = entry; + while (entry != &map->header && entry->start < end) { entry->wired_count--; + entry = entry->next; + } /* - * now, unlock the map, and unwire all the pages that - * were successfully wired above. + * now, unwire all the entries that were successfully + * wired above. */ + entry = start_entry; + while (entry != failed_entry) { + entry->wired_count--; + if (VM_MAPENT_ISWIRED(entry) == 0) + uvm_map_entry_unwire(map, entry); + entry = entry->next; + } vm_map_unlock(map); - (void) uvm_map_pageable(map, start, failed, TRUE); UVMHIST_LOG(maphist, "<- done (RV=%d)", rv,0,0,0); return(rv); } @@ -2200,6 +2196,212 @@ uvm_map_pageable(map, start, end, new_pageable) } /* + * uvm_map_pageable_all: special case of uvm_map_pageable - affects + * all mapped regions. + * + * => map must not be locked. + * => if no flags are specified, all regions are unwired. + * => XXXJRT: has some of the same problems as uvm_map_pageable() above. + */ + +int +uvm_map_pageable_all(map, flags, limit) + vm_map_t map; + int flags; + vsize_t limit; +{ + vm_map_entry_t entry, failed_entry; + vsize_t size; + int rv; + UVMHIST_FUNC("uvm_map_pageable_all"); UVMHIST_CALLED(maphist); + UVMHIST_LOG(maphist,"(map=0x%x,flags=0x%x)", map, flags, 0, 0); + +#ifdef DIAGNOSTIC + if ((map->flags & VM_MAP_PAGEABLE) == 0) + panic("uvm_map_pageable_all: map %p not pageable", map); +#endif + + vm_map_lock(map); + + /* + * handle wiring and unwiring separately. + */ + + if (flags == 0) { /* unwire */ + /* + * POSIX 1003.1b -- munlockall unlocks all regions, + * regardless of how many times mlockall has been called. + * + * Note, uvm_fault_unwire() (called via uvm_map_entry_unwire()) + * does not lock the map, so we don't have to do anything + * special regarding locking here. + */ + for (entry = map->header.next; entry != &map->header; + entry = entry->next) { + if (VM_MAPENT_ISWIRED(entry)) + uvm_map_entry_unwire(map, entry); + } + map->flags &= ~VM_MAP_WIREFUTURE; + vm_map_unlock(map); + UVMHIST_LOG(maphist,"<- done (OK UNWIRE)",0,0,0,0); + return (KERN_SUCCESS); + + /* + * end of unwire case! + */ + } + + if (flags & MCL_FUTURE) { + /* + * must wire all future mappings; remember this. + */ + map->flags |= VM_MAP_WIREFUTURE; + } + + if ((flags & MCL_CURRENT) == 0) { + /* + * no more work to do! + */ + UVMHIST_LOG(maphist,"<- done (OK no wire)",0,0,0,0); + vm_map_unlock(map); + return (KERN_SUCCESS); + } + + /* + * wire case: in three passes [XXXCDC: ugly block of code here] + * + * 1: holding the write lock, count all pages mapped by non-wired + * entries. if this would cause us to go over our limit, we fail. + * + * 2: still holding the write lock, we create any anonymous maps that + * need to be created. then we increment its wiring count. + * + * 3: we downgrade to a read lock, and call uvm_fault_wire to fault + * in the pages for any newly wired area (wired_count == 1). + * + * downgrading to a read lock for uvm_fault_wire avoids a possible + * deadlock with another thread that may have faulted on one of + * the pages to be wired (it would mark the page busy, blocking + * us, then in turn block on the map lock that we hold). because + * of problems in the recursive lock package, we cannot upgrade + * to a write lock in vm_map_lookup. thus, any actions that + * require the write lock must be done beforehand. because we + * keep the read lock on the map, the copy-on-write status of the + * entries we modify here cannot change. + */ + + for (size = 0, entry = map->header.next; entry != &map->header; + entry = entry->next) { + if (entry->protection != VM_PROT_NONE && + VM_MAPENT_ISWIRED(entry) == 0) { /* not already wired? */ + size += entry->end - entry->start; + } + } + + if (atop(size) + uvmexp.wired > uvmexp.wiredmax) { + vm_map_unlock(map); + return (KERN_NO_SPACE); /* XXX overloaded */ + } + + /* XXX non-pmap_wired_count case must be handled by caller */ +#ifdef pmap_wired_count + if (limit != 0 && + (size + ptoa(pmap_wired_count(vm_map_pmap(map))) > limit)) { + vm_map_unlock(map); + return (KERN_NO_SPACE); /* XXX overloaded */ + } +#endif + + /* + * Pass 2. + */ + + for (entry = map->header.next; entry != &map->header; + entry = entry->next) { + if (entry->protection == VM_PROT_NONE) + continue; + if (VM_MAPENT_ISWIRED(entry) == 0) { /* not already wired? */ + /* + * perform actions of vm_map_lookup that need the + * write lock on the map: create an anonymous map + * for a copy-on-write region, or an anonymous map + * for a zero-fill region. (XXXCDC: submap case + * ok?) + */ + if (!UVM_ET_ISSUBMAP(entry)) { /* not submap */ + if (UVM_ET_ISNEEDSCOPY(entry) && + ((entry->protection & VM_PROT_WRITE) || + (entry->object.uvm_obj == NULL))) { + amap_copy(map, entry, M_WAITOK, TRUE, + entry->start, entry->end); + /* XXXCDC: wait OK? */ + } + } + } + entry->wired_count++; + } + + /* + * Pass 3. + */ + + vm_map_downgrade(map); + + rv = KERN_SUCCESS; + for (entry = map->header.next; entry != &map->header; + entry = entry->next) { + if (entry->wired_count == 1) { + rv = uvm_fault_wire(map, entry->start, entry->end, + entry->protection); + if (rv) { + /* + * wiring failed. break out of the loop. + * we'll clean up the map below, once we + * have a write lock again. + */ + break; + } + } + } + + if (rv) { /* failed? */ + /* + * Get back an exclusive (write) lock. + */ + vm_map_upgrade(map); + + /* + * first drop the wiring count on all the entries + * which haven't actually been wired yet. + */ + failed_entry = entry; + for (/* nothing */; entry != &map->header; + entry = entry->next) + entry->wired_count--; + + /* + * now, unwire all the entries that were successfully + * wired above. + */ + for (entry = map->header.next; entry != failed_entry; + entry = entry->next) { + entry->wired_count--; + if (VM_MAPENT_ISWIRED(entry) == 0) + uvm_map_entry_unwire(map, entry); + } + vm_map_unlock(map); + UVMHIST_LOG(maphist,"<- done (RV=%d)", rv,0,0,0); + return (rv); + } + + /* We are holding a read lock here. */ + vm_map_unlock_read(map); + + UVMHIST_LOG(maphist,"<- done (OK WIRE)",0,0,0,0); + return (KERN_SUCCESS); +} + +/* * uvm_map_clean: push dirty pages off to backing store. * * => valid flags: @@ -2477,6 +2679,14 @@ uvmspace_exec(p) #endif /* + * POSIX 1003.1b -- "lock future mappings" is revoked + * when a process execs another program image. + */ + vm_map_lock(map); + map->flags &= ~VM_MAP_WIREFUTURE; + vm_map_unlock(map); + + /* * now unmap the old program */ uvm_unmap(map, VM_MIN_ADDRESS, VM_MAXUSER_ADDRESS); @@ -2750,7 +2960,7 @@ uvmspace_fork(vm1) if ((amap_flags(old_entry->aref.ar_amap) & AMAP_SHARED) != 0 || - old_entry->wired_count != 0) { + VM_MAPENT_ISWIRED(old_entry)) { amap_copy(new_map, new_entry, M_WAITOK, FALSE, 0, 0); @@ -2769,7 +2979,7 @@ uvmspace_fork(vm1) * allocated any needed amap (above). */ - if (old_entry->wired_count != 0) { + if (VM_MAPENT_ISWIRED(old_entry)) { /* * resolve all copy-on-write faults now diff --git a/sys/uvm/uvm_map_i.h b/sys/uvm/uvm_map_i.h index 4f04761b726..f2849603770 100644 --- a/sys/uvm/uvm_map_i.h +++ b/sys/uvm/uvm_map_i.h @@ -1,5 +1,5 @@ -/* $OpenBSD: uvm_map_i.h,v 1.5 2001/01/29 02:07:46 niklas Exp $ */ -/* $NetBSD: uvm_map_i.h,v 1.14 1999/06/04 23:38:42 thorpej Exp $ */ +/* $OpenBSD: uvm_map_i.h,v 1.6 2001/03/09 14:20:51 art Exp $ */ +/* $NetBSD: uvm_map_i.h,v 1.15 1999/06/14 22:05:23 thorpej Exp $ */ /* * Copyright (c) 1997 Charles D. Cranor and Washington University. @@ -124,7 +124,7 @@ uvm_map_setup(map, min, max, flags) map->first_free = &map->header; map->hint = &map->header; map->timestamp = 0; - lockinit(&map->lock, PVM, "thrd_sleep", 0, 0); + lockinit(&map->lock, PVM, "vmmaplk", 0, 0); simple_lock_init(&map->ref_lock); simple_lock_init(&map->hint_lock); diff --git a/sys/uvm/uvm_mmap.c b/sys/uvm/uvm_mmap.c index 7c6dbadca89..586631d6d10 100644 --- a/sys/uvm/uvm_mmap.c +++ b/sys/uvm/uvm_mmap.c @@ -1,5 +1,5 @@ -/* $OpenBSD: uvm_mmap.c,v 1.6 2001/01/29 02:07:46 niklas Exp $ */ -/* $NetBSD: uvm_mmap.c,v 1.21 1999/05/23 06:27:13 mrg Exp $ */ +/* $OpenBSD: uvm_mmap.c,v 1.7 2001/03/09 14:20:52 art Exp $ */ +/* $NetBSD: uvm_mmap.c,v 1.23 1999/06/16 17:25:39 minoura Exp $ */ /* * Copyright (c) 1997 Charles D. Cranor and Washington University. @@ -131,15 +131,140 @@ sys_mincore(p, v, retval) void *v; register_t *retval; { -#if 0 struct sys_mincore_args /* { - syscallarg(caddr_t) addr; + syscallarg(void *) addr; syscallarg(size_t) len; syscallarg(char *) vec; } */ *uap = v; + vm_page_t m; + char *vec, pgi; + struct uvm_object *uobj; + struct vm_amap *amap; + struct vm_anon *anon; + vm_map_entry_t entry; + vaddr_t start, end, lim; + vm_map_t map; + vsize_t len; + int error = 0, npgs; + + map = &p->p_vmspace->vm_map; + + start = (vaddr_t)SCARG(uap, addr); + len = SCARG(uap, len); + vec = SCARG(uap, vec); + + if (start & PAGE_MASK) + return (EINVAL); + len = round_page(len); + end = start + len; + if (end <= start) + return (EINVAL); + + npgs = len >> PAGE_SHIFT; + + if (uvm_useracc(vec, npgs, B_WRITE) == FALSE) + return (EFAULT); + + /* + * Lock down vec, so our returned status isn't outdated by + * storing the status byte for a page. + */ + uvm_vslock(p, vec, npgs, VM_PROT_WRITE); + + vm_map_lock_read(map); + + if (uvm_map_lookup_entry(map, start, &entry) == FALSE) { + error = ENOMEM; + goto out; + } + + for (/* nothing */; + entry != &map->header && entry->start < end; + entry = entry->next) { +#ifdef DIAGNOSTIC + if (UVM_ET_ISSUBMAP(entry)) + panic("mincore: user map has submap"); + if (start < entry->start) + panic("mincore: hole"); #endif + /* Make sure there are no holes. */ + if (entry->end < end && + (entry->next == &map->header || + entry->next->start > entry->end)) { + error = ENOMEM; + goto out; + } - return (ENOSYS); + lim = end < entry->end ? end : entry->end; + + /* + * Special case for mapped devices; these are always + * considered resident. + */ + if (UVM_ET_ISOBJ(entry)) { + extern struct uvm_pagerops uvm_deviceops; /* XXX */ +#ifdef DIAGNOSTIC + if (UVM_OBJ_IS_KERN_OBJECT(entry->object.uvm_obj)) + panic("mincore: user map has kernel object"); +#endif + if (entry->object.uvm_obj->pgops == &uvm_deviceops) { + for (/* nothing */; start < lim; + start += PAGE_SIZE, vec++) + subyte(vec, 1); + continue; + } + } + + uobj = entry->object.uvm_obj; /* top layer */ + amap = entry->aref.ar_amap; /* bottom layer */ + + if (amap != NULL) + amap_lock(amap); + if (uobj != NULL) + simple_lock(&uobj->vmobjlock); + + for (/* nothing */; start < lim; start += PAGE_SIZE, vec++) { + pgi = 0; + if (amap != NULL) { + /* Check the top layer first. */ + anon = amap_lookup(&entry->aref, + start - entry->start); + /* Don't need to lock anon here. */ + if (anon != NULL && anon->u.an_page != NULL) { + /* + * Anon has the page for this entry + * offset. + */ + pgi = 1; + } + } + + if (uobj != NULL && pgi == 0) { + /* Check the bottom layer. */ + m = uvm_pagelookup(uobj, + entry->offset + (start - entry->start)); + if (m != NULL) { + /* + * Object has the page for this entry + * offset. + */ + pgi = 1; + } + } + + (void) subyte(vec, pgi); + } + + if (uobj != NULL) + simple_unlock(&obj->vmobjlock); + if (amap != NULL) + amap_unlock(amap); + } + + out: + vm_map_unlock_read(map); + uvm_vsunlock(p, SCARG(uap, vec), npgs); + return (error); } #if 0 @@ -817,6 +942,75 @@ sys_munlock(p, v, retval) return (error == KERN_SUCCESS ? 0 : ENOMEM); } +#ifdef notyet +/* + * sys_mlockall: lock all pages mapped into an address space. + */ + +int +sys_mlockall(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + struct sys_mlockall_args /* { + syscallarg(int) flags; + } */ *uap = v; + vsize_t limit; + int error, flags; + + flags = SCARG(uap, flags); + + if (flags == 0 || + (flags & ~(MCL_CURRENT|MCL_FUTURE)) != 0) + return (EINVAL); + +#ifdef pmap_wired_count + /* Actually checked in uvm_map_pageable_all() */ + limit = p->p_rlimit[RLIMIT_MEMLOCK].rlim_cur; +#else + limit = 0; + if ((error = suser(p->p_ucred, &p->p_acflag)) != 0) + return (error); +#endif + + error = uvm_map_pageable_all(&p->p_vmspace->vm_map, flags, limit); + switch (error) { + case KERN_SUCCESS: + error = 0; + break; + + case KERN_NO_SPACE: /* XXX overloaded */ + error = ENOMEM; + break; + + default: + /* + * "Some or all of the memory could not be locked when + * the call was made." + */ + error = EAGAIN; + } + + return (error); +} + +/* + * sys_munlockall: unlock all pages mapped into an address space. + */ + +int +sys_munlockall(p, v, retval) + struct proc *p; + void *v; + register_t *retval; +{ + + (void) uvm_map_pageable_all(&p->p_vmspace->vm_map, 0, 0); + return (0); +} +#endif + /* * uvm_mmap: internal version of mmap * |