Index: head/sys/vm/vm_extern.h =================================================================== --- head/sys/vm/vm_extern.h (revision 6572) +++ head/sys/vm/vm_extern.h (revision 6573) @@ -1,135 +1,134 @@ /*- * Copyright (c) 1992, 1993 * The Regents of the University of California. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * @(#)vm_extern.h 8.2 (Berkeley) 1/12/94 - * $Id: vm_extern.h,v 1.8 1995/01/09 16:05:38 davidg Exp $ + * $Id: vm_extern.h,v 1.9 1995/02/09 14:16:07 davidg Exp $ */ #ifndef _VM_EXTERN_H_ #define _VM_EXTERN_H_ struct buf; struct loadavg; struct proc; struct vmspace; struct vmtotal; struct mount; struct vnode; #ifdef KGDB void chgkprot __P((caddr_t, int, int)); #endif /* * Try to get semi-meaningful wait messages into thread_sleep... */ void thread_sleep_ __P((int, simple_lock_t, char *)); #if __GNUC__ >= 2 #define thread_sleep(a,b,c) thread_sleep_((a), (b), __FUNCTION__) #else #define thread_sleep(a,b,c) thread_sleep_((a), (b), "vmslp") #endif #ifdef KERNEL #ifdef TYPEDEF_FOR_UAP int getpagesize __P((struct proc * p, void *, int *)); int madvise __P((struct proc *, void *, int *)); int mincore __P((struct proc *, void *, int *)); int mprotect __P((struct proc *, void *, int *)); int msync __P((struct proc *, void *, int *)); int munmap __P((struct proc *, void *, int *)); int obreak __P((struct proc *, void *, int *)); int sbrk __P((struct proc *, void *, int *)); int smmap __P((struct proc *, void *, int *)); int sstk __P((struct proc *, void *, int *)); #endif void assert_wait __P((int, boolean_t)); int grow __P((struct proc *, u_int)); void iprintf __P((const char *,...)); int kernacc __P((caddr_t, int, int)); int kinfo_loadavg __P((int, char *, int *, int, int *)); int kinfo_meter __P((int, caddr_t, int *, int, int *)); vm_offset_t kmem_alloc __P((vm_map_t, vm_size_t)); vm_offset_t kmem_alloc_pageable __P((vm_map_t, vm_size_t)); vm_offset_t kmem_alloc_wait __P((vm_map_t, vm_size_t)); void kmem_free __P((vm_map_t, vm_offset_t, vm_size_t)); void kmem_free_wakeup __P((vm_map_t, vm_offset_t, vm_size_t)); void kmem_init __P((vm_offset_t, vm_offset_t)); vm_offset_t kmem_malloc __P((vm_map_t, vm_size_t, boolean_t)); vm_map_t kmem_suballoc __P((vm_map_t, vm_offset_t *, vm_offset_t *, vm_size_t, boolean_t)); void loadav __P((struct loadavg *)); void munmapfd __P((struct proc *, int)); int pager_cache __P((vm_object_t, boolean_t)); void sched __P((void)); void swapinit __P((void)); int swapon __P((struct proc *, void *, int *)); void swapout __P((struct proc *)); void swapout_threads __P((void)); int swfree __P((struct proc *, int)); void swstrategy __P((struct buf *)); void thread_block __P((char *)); void thread_sleep __P((int, simple_lock_t, boolean_t)); void thread_wakeup __P((int)); int useracc __P((caddr_t, int, int)); int vm_allocate __P((vm_map_t, vm_offset_t *, vm_size_t, boolean_t)); int vm_allocate_with_pager __P((vm_map_t, vm_offset_t *, vm_size_t, boolean_t, vm_pager_t, vm_offset_t, boolean_t)); int vm_deallocate __P((vm_map_t, vm_offset_t, vm_size_t)); int vm_fault __P((vm_map_t, vm_offset_t, vm_prot_t, boolean_t)); void vm_fault_copy_entry __P((vm_map_t, vm_map_t, vm_map_entry_t, vm_map_entry_t)); void vm_fault_unwire __P((vm_map_t, vm_offset_t, vm_offset_t)); int vm_fault_wire __P((vm_map_t, vm_offset_t, vm_offset_t)); int vm_fork __P((struct proc *, struct proc *, int)); -int vm_inherit __P((vm_map_t, vm_offset_t, vm_size_t, vm_inherit_t)); void vm_init_limits __P((struct proc *)); void vm_mem_init __P((void)); int vm_mmap __P((vm_map_t, vm_offset_t *, vm_size_t, vm_prot_t, vm_prot_t, int, caddr_t, vm_offset_t)); vm_offset_t vm_page_alloc_contig __P((vm_offset_t, vm_offset_t, vm_offset_t, vm_offset_t)); int vm_protect __P((vm_map_t, vm_offset_t, vm_size_t, boolean_t, vm_prot_t)); void vm_set_page_size __P((void)); void vmmeter __P((void)); struct vmspace *vmspace_alloc __P((vm_offset_t, vm_offset_t, int)); struct vmspace *vmspace_fork __P((struct vmspace *)); void vmspace_free __P((struct vmspace *)); void vmtotal __P((struct vmtotal *)); void vnode_pager_setsize __P((struct vnode *, u_long)); void vnode_pager_umount __P((struct mount *)); boolean_t vnode_pager_uncache __P((struct vnode *)); void vslock __P((caddr_t, u_int)); void vsunlock __P((caddr_t, u_int, int)); #endif /* KERNEL */ #endif /* !_VM_EXTERN_H_ */ Index: head/sys/vm/vm_user.c =================================================================== --- head/sys/vm/vm_user.c (revision 6572) +++ head/sys/vm/vm_user.c (revision 6573) @@ -1,217 +1,200 @@ /* * Copyright (c) 1991, 1993 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * The Mach Operating System project at Carnegie-Mellon University. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * from: @(#)vm_user.c 8.2 (Berkeley) 1/12/94 * * * Copyright (c) 1987, 1990 Carnegie-Mellon University. * All rights reserved. * * Authors: Avadis Tevanian, Jr., Michael Wayne Young * * Permission to use, copy, modify and distribute this software and * its documentation is hereby granted, provided that both the copyright * notice and this permission notice appear in all copies of the * software, derivative works or modified versions, and any portions * thereof, and that both notices appear in supporting documentation. * * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. * * Carnegie Mellon requests users of this software to return to * * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU * School of Computer Science * Carnegie Mellon University * Pittsburgh PA 15213-3890 * * any improvements or extensions that they make and grant Carnegie the * rights to redistribute these changes. * - * $Id: vm_user.c,v 1.6 1995/01/10 07:32:52 davidg Exp $ + * $Id: vm_user.c,v 1.7 1995/02/09 14:14:13 davidg Exp $ */ /* * User-exported virtual memory functions. */ #include #include #include #include simple_lock_data_t vm_alloc_lock; /* XXX */ - -/* - * vm_inherit sets the inheritence of the specified range in the - * specified map. - */ -int -vm_inherit(map, start, size, new_inheritance) - register vm_map_t map; - vm_offset_t start; - vm_size_t size; - vm_inherit_t new_inheritance; -{ - if (map == NULL) - return (KERN_INVALID_ARGUMENT); - - return (vm_map_inherit(map, trunc_page(start), round_page(start + size), new_inheritance)); -} /* * vm_protect sets the protection of the specified range in the * specified map. */ int vm_protect(map, start, size, set_maximum, new_protection) register vm_map_t map; vm_offset_t start; vm_size_t size; boolean_t set_maximum; vm_prot_t new_protection; { if (map == NULL) return (KERN_INVALID_ARGUMENT); return (vm_map_protect(map, trunc_page(start), round_page(start + size), new_protection, set_maximum)); } /* * vm_allocate allocates "zero fill" memory in the specfied * map. */ int vm_allocate(map, addr, size, anywhere) register vm_map_t map; register vm_offset_t *addr; register vm_size_t size; boolean_t anywhere; { int result; if (map == NULL) return (KERN_INVALID_ARGUMENT); if (size == 0) { *addr = 0; return (KERN_SUCCESS); } if (anywhere) *addr = vm_map_min(map); else *addr = trunc_page(*addr); size = round_page(size); result = vm_map_find(map, NULL, (vm_offset_t) 0, addr, size, anywhere); return (result); } /* * vm_deallocate deallocates the specified range of addresses in the * specified address map. */ int vm_deallocate(map, start, size) register vm_map_t map; vm_offset_t start; vm_size_t size; { if (map == NULL) return (KERN_INVALID_ARGUMENT); if (size == (vm_offset_t) 0) return (KERN_SUCCESS); return (vm_map_remove(map, trunc_page(start), round_page(start + size))); } #if 1 /* * Similar to vm_allocate but assigns an explicit pager. */ int vm_allocate_with_pager(map, addr, size, anywhere, pager, poffset, internal) register vm_map_t map; register vm_offset_t *addr; register vm_size_t size; boolean_t anywhere; vm_pager_t pager; vm_offset_t poffset; boolean_t internal; { register vm_object_t object; register int result; if (map == NULL) return (KERN_INVALID_ARGUMENT); *addr = trunc_page(*addr); size = round_page(size); /* * Lookup the pager/paging-space in the object cache. If it's not * there, then create a new object and cache it. */ object = vm_object_lookup(pager); if (object == NULL) { object = vm_object_allocate(size); /* * From Mike Hibler: "unnamed anonymous objects should never * be on the hash list ... For now you can just change * vm_allocate_with_pager to not do vm_object_enter if this is * an internal object ..." */ if (!internal) vm_object_enter(object, pager); } if (internal) object->flags |= OBJ_INTERNAL; else { object->flags &= ~OBJ_INTERNAL; cnt.v_nzfod -= atop(size); } result = vm_map_find(map, object, poffset, addr, size, anywhere); if (result != KERN_SUCCESS) vm_object_deallocate(object); else if (pager != NULL) vm_object_setpager(object, pager, (vm_offset_t) 0, TRUE); return (result); } #endif