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.2 (Berkeley) 04/20/91 14 */ 15 16 /* 17 * User-exported virtual memory functions. 18 */ 19 20 #include "param.h" 21 #include "systm.h" 22 #include "proc.h" 23 24 #include "vm.h" 25 #include "vm_page.h" 26 27 simple_lock_data_t vm_alloc_lock; /* XXX */ 28 29 #ifdef MACHVMCOMPAT 30 /* 31 * BSD style syscall interfaces to MACH calls 32 * All return MACH return values. 33 */ 34 /* ARGSUSED */ 35 svm_allocate(p, uap, retval) 36 struct proc *p; 37 struct args { 38 vm_map_t map; 39 vm_offset_t *addr; 40 vm_size_t size; 41 boolean_t anywhere; 42 } *uap; 43 int *retval; 44 { 45 vm_offset_t addr; 46 int rv; 47 48 uap->map = p->p_map; /* XXX */ 49 50 if (copyin((caddr_t)uap->addr, (caddr_t)&addr, sizeof (addr))) 51 rv = KERN_INVALID_ARGUMENT; 52 else 53 rv = vm_allocate(uap->map, &addr, uap->size, uap->anywhere); 54 if (rv == KERN_SUCCESS) { 55 if (copyout((caddr_t)&addr, (caddr_t)uap->addr, sizeof(addr))) 56 rv = KERN_INVALID_ARGUMENT; 57 } 58 return((int)rv); 59 } 60 61 /* ARGSUSED */ 62 svm_deallocate(p, uap, retval) 63 struct proc *p; 64 struct args { 65 vm_map_t map; 66 vm_offset_t addr; 67 vm_size_t size; 68 } *uap; 69 int *retval; 70 { 71 int rv; 72 73 uap->map = p->p_map; /* XXX */ 74 rv = vm_deallocate(uap->map, uap->addr, uap->size); 75 return((int)rv); 76 } 77 78 /* ARGSUSED */ 79 svm_inherit(p, uap, retval) 80 struct proc *p; 81 struct args { 82 vm_map_t map; 83 vm_offset_t addr; 84 vm_size_t size; 85 vm_inherit_t inherit; 86 } *uap; 87 int *retval; 88 { 89 int rv; 90 91 uap->map = p->p_map; /* XXX */ 92 rv = vm_inherit(uap->map, uap->addr, uap->size, uap->inherit); 93 return((int)rv); 94 } 95 96 /* ARGSUSED */ 97 svm_protect(p, uap, retval) 98 struct proc *p; 99 struct args { 100 vm_map_t map; 101 vm_offset_t addr; 102 vm_size_t size; 103 boolean_t setmax; 104 vm_prot_t prot; 105 } *uap; 106 int *retval; 107 { 108 int rv; 109 110 uap->map = p->p_map; /* XXX */ 111 rv = vm_protect(uap->map, uap->addr, uap->size, uap->setmax, uap->prot); 112 return((int)rv); 113 } 114 #endif 115 116 /* 117 * vm_allocate allocates "zero fill" memory in the specfied 118 * map. 119 */ 120 vm_allocate(map, addr, size, anywhere) 121 register vm_map_t map; 122 register vm_offset_t *addr; 123 register vm_size_t size; 124 boolean_t anywhere; 125 { 126 int result; 127 128 if (map == NULL) 129 return(KERN_INVALID_ARGUMENT); 130 if (size == 0) { 131 *addr = 0; 132 return(KERN_SUCCESS); 133 } 134 135 if (anywhere) 136 *addr = vm_map_min(map); 137 else 138 *addr = trunc_page(*addr); 139 size = round_page(size); 140 141 result = vm_map_find(map, NULL, (vm_offset_t) 0, addr, 142 size, anywhere); 143 144 return(result); 145 } 146 147 /* 148 * vm_deallocate deallocates the specified range of addresses in the 149 * specified address map. 150 */ 151 vm_deallocate(map, start, size) 152 register vm_map_t map; 153 vm_offset_t start; 154 vm_size_t size; 155 { 156 if (map == NULL) 157 return(KERN_INVALID_ARGUMENT); 158 159 if (size == (vm_offset_t) 0) 160 return(KERN_SUCCESS); 161 162 return(vm_map_remove(map, trunc_page(start), round_page(start+size))); 163 } 164 165 /* 166 * vm_inherit sets the inheritence of the specified range in the 167 * specified map. 168 */ 169 vm_inherit(map, start, size, new_inheritance) 170 register vm_map_t map; 171 vm_offset_t start; 172 vm_size_t size; 173 vm_inherit_t new_inheritance; 174 { 175 if (map == NULL) 176 return(KERN_INVALID_ARGUMENT); 177 178 return(vm_map_inherit(map, trunc_page(start), round_page(start+size), new_inheritance)); 179 } 180 181 /* 182 * vm_protect sets the protection of the specified range in the 183 * specified map. 184 */ 185 186 vm_protect(map, start, size, set_maximum, new_protection) 187 register vm_map_t map; 188 vm_offset_t start; 189 vm_size_t size; 190 boolean_t set_maximum; 191 vm_prot_t new_protection; 192 { 193 if (map == NULL) 194 return(KERN_INVALID_ARGUMENT); 195 196 return(vm_map_protect(map, trunc_page(start), round_page(start+size), new_protection, set_maximum)); 197 } 198