1 /* 2 * Copyright (c) 1991 Regents of the University of California. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to Berkeley by 6 * The Mach Operating System project at Carnegie-Mellon University. 7 * 8 * %sccs.include.redist.c% 9 * 10 * @(#)vm_user.c 7.3 (Berkeley) 04/21/91 11 * 12 * 13 * Copyright (c) 1987, 1990 Carnegie-Mellon University. 14 * All rights reserved. 15 * 16 * Authors: Avadis Tevanian, Jr., Michael Wayne Young 17 * 18 * Permission to use, copy, modify and distribute this software and 19 * its documentation is hereby granted, provided that both the copyright 20 * notice and this permission notice appear in all copies of the 21 * software, derivative works or modified versions, and any portions 22 * thereof, and that both notices appear in supporting documentation. 23 * 24 * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" 25 * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND 26 * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. 27 * 28 * Carnegie Mellon requests users of this software to return to 29 * 30 * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU 31 * School of Computer Science 32 * Carnegie Mellon University 33 * Pittsburgh PA 15213-3890 34 * 35 * any improvements or extensions that they make and grant Carnegie the 36 * rights to redistribute these changes. 37 */ 38 39 /* 40 * User-exported virtual memory functions. 41 */ 42 43 #include "param.h" 44 #include "systm.h" 45 #include "proc.h" 46 47 #include "vm.h" 48 #include "vm_page.h" 49 50 simple_lock_data_t vm_alloc_lock; /* XXX */ 51 52 #ifdef MACHVMCOMPAT 53 /* 54 * BSD style syscall interfaces to MACH calls 55 * All return MACH return values. 56 */ 57 /* ARGSUSED */ 58 svm_allocate(p, uap, retval) 59 struct proc *p; 60 struct args { 61 vm_map_t map; 62 vm_offset_t *addr; 63 vm_size_t size; 64 boolean_t anywhere; 65 } *uap; 66 int *retval; 67 { 68 vm_offset_t addr; 69 int rv; 70 71 uap->map = p->p_map; /* XXX */ 72 73 if (copyin((caddr_t)uap->addr, (caddr_t)&addr, sizeof (addr))) 74 rv = KERN_INVALID_ARGUMENT; 75 else 76 rv = vm_allocate(uap->map, &addr, uap->size, uap->anywhere); 77 if (rv == KERN_SUCCESS) { 78 if (copyout((caddr_t)&addr, (caddr_t)uap->addr, sizeof(addr))) 79 rv = KERN_INVALID_ARGUMENT; 80 } 81 return((int)rv); 82 } 83 84 /* ARGSUSED */ 85 svm_deallocate(p, uap, retval) 86 struct proc *p; 87 struct args { 88 vm_map_t map; 89 vm_offset_t addr; 90 vm_size_t size; 91 } *uap; 92 int *retval; 93 { 94 int rv; 95 96 uap->map = p->p_map; /* XXX */ 97 rv = vm_deallocate(uap->map, uap->addr, uap->size); 98 return((int)rv); 99 } 100 101 /* ARGSUSED */ 102 svm_inherit(p, uap, retval) 103 struct proc *p; 104 struct args { 105 vm_map_t map; 106 vm_offset_t addr; 107 vm_size_t size; 108 vm_inherit_t inherit; 109 } *uap; 110 int *retval; 111 { 112 int rv; 113 114 uap->map = p->p_map; /* XXX */ 115 rv = vm_inherit(uap->map, uap->addr, uap->size, uap->inherit); 116 return((int)rv); 117 } 118 119 /* ARGSUSED */ 120 svm_protect(p, uap, retval) 121 struct proc *p; 122 struct args { 123 vm_map_t map; 124 vm_offset_t addr; 125 vm_size_t size; 126 boolean_t setmax; 127 vm_prot_t prot; 128 } *uap; 129 int *retval; 130 { 131 int rv; 132 133 uap->map = p->p_map; /* XXX */ 134 rv = vm_protect(uap->map, uap->addr, uap->size, uap->setmax, uap->prot); 135 return((int)rv); 136 } 137 #endif 138 139 /* 140 * vm_allocate allocates "zero fill" memory in the specfied 141 * map. 142 */ 143 vm_allocate(map, addr, size, anywhere) 144 register vm_map_t map; 145 register vm_offset_t *addr; 146 register vm_size_t size; 147 boolean_t anywhere; 148 { 149 int result; 150 151 if (map == NULL) 152 return(KERN_INVALID_ARGUMENT); 153 if (size == 0) { 154 *addr = 0; 155 return(KERN_SUCCESS); 156 } 157 158 if (anywhere) 159 *addr = vm_map_min(map); 160 else 161 *addr = trunc_page(*addr); 162 size = round_page(size); 163 164 result = vm_map_find(map, NULL, (vm_offset_t) 0, addr, 165 size, anywhere); 166 167 return(result); 168 } 169 170 /* 171 * vm_deallocate deallocates the specified range of addresses in the 172 * specified address map. 173 */ 174 vm_deallocate(map, start, size) 175 register vm_map_t map; 176 vm_offset_t start; 177 vm_size_t size; 178 { 179 if (map == NULL) 180 return(KERN_INVALID_ARGUMENT); 181 182 if (size == (vm_offset_t) 0) 183 return(KERN_SUCCESS); 184 185 return(vm_map_remove(map, trunc_page(start), round_page(start+size))); 186 } 187 188 /* 189 * vm_inherit sets the inheritence of the specified range in the 190 * specified map. 191 */ 192 vm_inherit(map, start, size, new_inheritance) 193 register vm_map_t map; 194 vm_offset_t start; 195 vm_size_t size; 196 vm_inherit_t new_inheritance; 197 { 198 if (map == NULL) 199 return(KERN_INVALID_ARGUMENT); 200 201 return(vm_map_inherit(map, trunc_page(start), round_page(start+size), new_inheritance)); 202 } 203 204 /* 205 * vm_protect sets the protection of the specified range in the 206 * specified map. 207 */ 208 209 vm_protect(map, start, size, set_maximum, new_protection) 210 register vm_map_t map; 211 vm_offset_t start; 212 vm_size_t size; 213 boolean_t set_maximum; 214 vm_prot_t new_protection; 215 { 216 if (map == NULL) 217 return(KERN_INVALID_ARGUMENT); 218 219 return(vm_map_protect(map, trunc_page(start), round_page(start+size), new_protection, set_maximum)); 220 } 221