kern_ras.c revision 1.12.20.1
1 /* $NetBSD: kern_ras.c,v 1.12.20.1 2006/10/20 20:03:17 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 2002 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Gregory McGarry. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: kern_ras.c,v 1.12.20.1 2006/10/20 20:03:17 ad Exp $"); 41 42 #include <sys/param.h> 43 #include <sys/lock.h> 44 #include <sys/systm.h> 45 #include <sys/pool.h> 46 #include <sys/proc.h> 47 #include <sys/ras.h> 48 #include <sys/sa.h> 49 #include <sys/savar.h> 50 51 #include <sys/mount.h> 52 #include <sys/syscallargs.h> 53 54 #include <uvm/uvm_extern.h> 55 56 #define MAX_RAS_PER_PROC 16 57 58 u_int ras_per_proc = MAX_RAS_PER_PROC; 59 60 #ifdef DEBUG 61 int ras_debug = 0; 62 #define DPRINTF(x) if (ras_debug) printf x 63 #else 64 #define DPRINTF(x) /* nothing */ 65 #endif 66 67 /* 68 * Check the specified address to see if it is within the 69 * sequence. If it is found, we return the restart address, 70 * otherwise we return -1. If we do perform a restart, we 71 * mark the sequence as hit. 72 */ 73 caddr_t 74 ras_lookup(struct proc *p, caddr_t addr) 75 { 76 struct ras *rp; 77 78 #ifdef DIAGNOSTIC 79 if (addr < (caddr_t)VM_MIN_ADDRESS || 80 addr > (caddr_t)VM_MAXUSER_ADDRESS) 81 return ((caddr_t)-1); 82 #endif 83 84 mutex_enter(&p->p_rasmutex); 85 LIST_FOREACH(rp, &p->p_raslist, ras_list) { 86 if (addr > rp->ras_startaddr && addr < rp->ras_endaddr) { 87 rp->ras_hits++; 88 mutex_exit(&p->p_rasmutex); 89 #ifdef DIAGNOSTIC 90 DPRINTF(("RAS hit: p=%p %p\n", p, addr)); 91 #endif 92 return (rp->ras_startaddr); 93 } 94 } 95 mutex_exit(&p->p_rasmutex); 96 97 return ((caddr_t)-1); 98 } 99 100 /* 101 * During a fork, we copy all of the sequences from parent p1 to 102 * the child p2. 103 */ 104 int 105 ras_fork(struct proc *p1, struct proc *p2) 106 { 107 struct ras *rp, *nrp; 108 int nras; 109 110 again: 111 /* 112 * first, try to shortcut. 113 */ 114 115 if (LIST_EMPTY(&p1->p_raslist)) 116 return (0); 117 118 /* 119 * count entries. 120 */ 121 122 nras = 0; 123 mutex_enter(&p1->p_rasmutex); 124 LIST_FOREACH(rp, &p1->p_raslist, ras_list) 125 nras++; 126 mutex_exit(&p1->p_rasmutex); 127 128 /* 129 * allocate entries. 130 * 131 * XXXAD may change if we sleep. WTF? 132 */ 133 134 for ( ; nras > 0; nras--) { 135 nrp = pool_get(&ras_pool, PR_WAITOK); 136 nrp->ras_hits = 0; 137 LIST_INSERT_HEAD(&p2->p_raslist, nrp, ras_list); 138 } 139 140 /* 141 * copy entries. 142 */ 143 144 mutex_enter(&p1->p_rasmutex); 145 nrp = LIST_FIRST(&p2->p_raslist); 146 LIST_FOREACH(rp, &p1->p_raslist, ras_list) { 147 if (nrp == NULL) 148 break; 149 nrp->ras_startaddr = rp->ras_startaddr; 150 nrp->ras_endaddr = rp->ras_endaddr; 151 nrp = LIST_NEXT(nrp, ras_list); 152 } 153 mutex_exit(&p1->p_rasmutex); 154 155 /* 156 * if we lose a race, retry. 157 */ 158 159 if (rp != NULL || nrp != NULL) { 160 ras_purgeall(p2); 161 goto again; 162 } 163 164 DPRINTF(("ras_fork: p1=%p, p2=%p, nras=%d\n", p1, p2, nras)); 165 166 return (0); 167 } 168 169 /* 170 * Nuke all sequences for this process. 171 */ 172 int 173 ras_purgeall(struct proc *p) 174 { 175 struct ras *rp; 176 177 mutex_enter(&p->p_rasmutex); 178 while (!LIST_EMPTY(&p->p_raslist)) { 179 rp = LIST_FIRST(&p->p_raslist); 180 DPRINTF(("RAS %p-%p, hits %d\n", rp->ras_startaddr, 181 rp->ras_endaddr, rp->ras_hits)); 182 LIST_REMOVE(rp, ras_list); 183 pool_put(&ras_pool, rp); 184 } 185 mutex_exit(&p->p_rasmutex); 186 187 return (0); 188 } 189 190 #if defined(__HAVE_RAS) 191 192 /* 193 * Install the new sequence. If it already exists, return 194 * an error. 195 */ 196 static int 197 ras_install(struct proc *p, caddr_t addr, size_t len) 198 { 199 struct ras *rp; 200 struct ras *newrp; 201 caddr_t endaddr = addr + len; 202 int nras = 0; 203 204 if (addr < (caddr_t)VM_MIN_ADDRESS || 205 endaddr > (caddr_t)VM_MAXUSER_ADDRESS) 206 return (EINVAL); 207 208 if (len <= 0) 209 return (EINVAL); 210 211 newrp = NULL; 212 again: 213 mutex_enter(&p->p_rasmutex); 214 LIST_FOREACH(rp, &p->p_raslist, ras_list) { 215 if (++nras >= ras_per_proc || 216 (addr < rp->ras_endaddr && endaddr > rp->ras_startaddr)) { 217 mutex_exit(&p->p_rasmutex); 218 return (EINVAL); 219 } 220 } 221 if (newrp == NULL) { 222 mutex_exit(&p->p_rasmutex); 223 newrp = pool_get(&ras_pool, PR_WAITOK); 224 goto again; 225 } 226 newrp->ras_startaddr = addr; 227 newrp->ras_endaddr = endaddr; 228 newrp->ras_hits = 0; 229 LIST_INSERT_HEAD(&p->p_raslist, newrp, ras_list); 230 mutex_exit(&p->p_rasmutex); 231 232 return (0); 233 } 234 235 /* 236 * Nuke the specified sequence. Both address and len must 237 * match, otherwise we return an error. 238 */ 239 static int 240 ras_purge(struct proc *p, caddr_t addr, size_t len) 241 { 242 struct ras *rp; 243 caddr_t endaddr = addr + len; 244 int error = ESRCH; 245 246 mutex_enter(&p->p_rasmutex); 247 LIST_FOREACH(rp, &p->p_raslist, ras_list) { 248 if (addr == rp->ras_startaddr && endaddr == rp->ras_endaddr) { 249 LIST_REMOVE(rp, ras_list); 250 pool_put(&ras_pool, rp); 251 error = 0; 252 break; 253 } 254 } 255 mutex_exit(&p->p_rasmutex); 256 257 return (error); 258 } 259 260 #endif /* defined(__HAVE_RAS) */ 261 262 /*ARGSUSED*/ 263 int 264 sys_rasctl(struct lwp *l, void *v, register_t *retval) 265 { 266 267 #if defined(__HAVE_RAS) 268 269 struct sys_rasctl_args /* { 270 syscallarg(caddr_t) addr; 271 syscallarg(size_t) len; 272 syscallarg(int) op; 273 } */ *uap = v; 274 struct proc *p = l->l_proc; 275 caddr_t addr; 276 size_t len; 277 int op; 278 int error; 279 280 /* 281 * first, extract syscall args from the uap. 282 */ 283 284 addr = (caddr_t)SCARG(uap, addr); 285 len = (size_t)SCARG(uap, len); 286 op = SCARG(uap, op); 287 288 DPRINTF(("sys_rasctl: p=%p addr=%p, len=%ld, op=0x%x\n", 289 p, addr, (long)len, op)); 290 291 switch (op) { 292 case RAS_INSTALL: 293 error = ras_install(p, addr, len); 294 break; 295 case RAS_PURGE: 296 error = ras_purge(p, addr, len); 297 break; 298 case RAS_PURGE_ALL: 299 error = ras_purgeall(p); 300 break; 301 default: 302 error = EINVAL; 303 break; 304 } 305 306 return (error); 307 308 #else 309 310 return (EOPNOTSUPP); 311 312 #endif 313 314 } 315
Indexes created Mon Sep 29 13:09:55 GMT 2025