1 /* 2 * Copyright (c) 1985, Avadis Tevanian, Jr., Michael Wayne Young 3 * Copyright (c) 1987 Carnegie-Mellon University 4 * Copyright (c) 1991 Regents of the University of California. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to Berkeley by 8 * The Mach Operating System project at Carnegie-Mellon University. 9 * 10 * The CMU software License Agreement specifies the terms and conditions 11 * for use and redistribution. 12 * 13 * @(#)vm_user.c 7.1 (Berkeley) 12/05/90 14 */ 15 16 /* 17 * User-exported virtual memory functions. 18 */ 19 20 #include "param.h" 21 #include "systm.h" 22 #include "user.h" 23 #include "proc.h" 24 25 #include "../vm/vm_param.h" 26 #include "../vm/vm_object.h" 27 #include "../vm/vm_map.h" 28 #include "../vm/vm_page.h" 29 #include "../vm/vm_statistics.h" 30 31 #include "lock.h" /* XXX */ 32 simple_lock_data_t vm_alloc_lock; /* XXX */ 33 34 #ifdef MACHVMCOMPAT 35 /* 36 * BSD style syscall interfaces to MACH calls 37 * All return MACH return values. 38 */ 39 /* ARGSUSED */ 40 svm_allocate(p, uap, retval) 41 struct proc *p; 42 struct args { 43 vm_map_t map; 44 vm_offset_t *addr; 45 vm_size_t size; 46 boolean_t anywhere; 47 } *uap; 48 int *retval; 49 { 50 vm_offset_t addr; 51 int rv; 52 53 uap->map = p->p_map; /* XXX */ 54 55 if (copyin((caddr_t)uap->addr, (caddr_t)&addr, sizeof (addr))) 56 rv = KERN_INVALID_ARGUMENT; 57 else 58 rv = vm_allocate(uap->map, &addr, uap->size, uap->anywhere); 59 if (rv == KERN_SUCCESS) { 60 if (copyout((caddr_t)&addr, (caddr_t)uap->addr, sizeof(addr))) 61 rv = KERN_INVALID_ARGUMENT; 62 } 63 return((int)rv); 64 } 65 66 /* ARGSUSED */ 67 svm_deallocate(p, uap, retval) 68 struct proc *p; 69 struct args { 70 vm_map_t map; 71 vm_offset_t addr; 72 vm_size_t size; 73 } *uap; 74 int *retval; 75 { 76 int rv; 77 78 uap->map = p->p_map; /* XXX */ 79 rv = vm_deallocate(uap->map, uap->addr, uap->size); 80 return((int)rv); 81 } 82 83 /* ARGSUSED */ 84 svm_inherit(p, uap, retval) 85 struct proc *p; 86 struct args { 87 vm_map_t map; 88 vm_offset_t addr; 89 vm_size_t size; 90 vm_inherit_t inherit; 91 } *uap; 92 int *retval; 93 { 94 int rv; 95 96 uap->map = p->p_map; /* XXX */ 97 rv = vm_inherit(uap->map, uap->addr, uap->size, uap->inherit); 98 return((int)rv); 99 } 100 101 /* ARGSUSED */ 102 svm_protect(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 boolean_t setmax; 109 vm_prot_t prot; 110 } *uap; 111 int *retval; 112 { 113 int rv; 114 115 uap->map = p->p_map; /* XXX */ 116 rv = vm_protect(uap->map, uap->addr, uap->size, uap->setmax, uap->prot); 117 return((int)rv); 118 } 119 #endif 120 121 /* 122 * vm_allocate allocates "zero fill" memory in the specfied 123 * map. 124 */ 125 vm_allocate(map, addr, size, anywhere) 126 register vm_map_t map; 127 register vm_offset_t *addr; 128 register vm_size_t size; 129 boolean_t anywhere; 130 { 131 int result; 132 133 if (map == VM_MAP_NULL) 134 return(KERN_INVALID_ARGUMENT); 135 if (size == 0) { 136 *addr = 0; 137 return(KERN_SUCCESS); 138 } 139 140 if (anywhere) 141 *addr = vm_map_min(map); 142 else 143 *addr = trunc_page(*addr); 144 size = round_page(size); 145 146 result = vm_map_find(map, VM_OBJECT_NULL, (vm_offset_t) 0, addr, 147 size, anywhere); 148 149 return(result); 150 } 151 152 /* 153 * vm_deallocate deallocates the specified range of addresses in the 154 * specified address map. 155 */ 156 vm_deallocate(map, start, size) 157 register vm_map_t map; 158 vm_offset_t start; 159 vm_size_t size; 160 { 161 if (map == VM_MAP_NULL) 162 return(KERN_INVALID_ARGUMENT); 163 164 if (size == (vm_offset_t) 0) 165 return(KERN_SUCCESS); 166 167 return(vm_map_remove(map, trunc_page(start), round_page(start+size))); 168 } 169 170 /* 171 * vm_inherit sets the inheritence of the specified range in the 172 * specified map. 173 */ 174 vm_inherit(map, start, size, new_inheritance) 175 register vm_map_t map; 176 vm_offset_t start; 177 vm_size_t size; 178 vm_inherit_t new_inheritance; 179 { 180 if (map == VM_MAP_NULL) 181 return(KERN_INVALID_ARGUMENT); 182 183 return(vm_map_inherit(map, trunc_page(start), round_page(start+size), new_inheritance)); 184 } 185 186 /* 187 * vm_protect sets the protection of the specified range in the 188 * specified map. 189 */ 190 191 vm_protect(map, start, size, set_maximum, new_protection) 192 register vm_map_t map; 193 vm_offset_t start; 194 vm_size_t size; 195 boolean_t set_maximum; 196 vm_prot_t new_protection; 197 { 198 if (map == VM_MAP_NULL) 199 return(KERN_INVALID_ARGUMENT); 200 201 return(vm_map_protect(map, trunc_page(start), round_page(start+size), new_protection, set_maximum)); 202 } 203