kern_ras.c revision 1.16
1 /* $NetBSD: kern_ras.c,v 1.16 2007/02/09 21:55:31 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 2002, 2006 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.16 2007/02/09 21:55:31 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 49 #include <sys/mount.h> 50 #include <sys/syscallargs.h> 51 52 #include <uvm/uvm_extern.h> 53 54 POOL_INIT(ras_pool, sizeof(struct ras), 0, 0, 0, "raspl", 55 &pool_allocator_nointr); 56 57 #define MAX_RAS_PER_PROC 16 58 59 u_int ras_per_proc = MAX_RAS_PER_PROC; 60 61 #ifdef DEBUG 62 int ras_debug = 0; 63 #define DPRINTF(x) if (ras_debug) printf x 64 #else 65 #define DPRINTF(x) /* nothing */ 66 #endif 67 68 /* 69 * Check the specified address to see if it is within the 70 * sequence. If it is found, we return the restart address, 71 * otherwise we return -1. If we do perform a restart, we 72 * mark the sequence as hit. 73 */ 74 caddr_t 75 ras_lookup(struct proc *p, caddr_t addr) 76 { 77 struct ras *rp; 78 caddr_t startaddr; 79 80 startaddr = (caddr_t)-1; 81 82 #ifdef DIAGNOSTIC 83 if (addr < (caddr_t)VM_MIN_ADDRESS || 84 addr > (caddr_t)VM_MAXUSER_ADDRESS) 85 return (startaddr); 86 #endif 87 88 mutex_enter(&p->p_rasmutex); 89 LIST_FOREACH(rp, &p->p_raslist, ras_list) { 90 if (addr > rp->ras_startaddr && addr < rp->ras_endaddr) { 91 rp->ras_hits++; 92 startaddr = rp->ras_startaddr; 93 #ifdef DIAGNOSTIC 94 DPRINTF(("RAS hit: p=%p %p\n", p, addr)); 95 #endif 96 break; 97 } 98 } 99 mutex_exit(&p->p_rasmutex); 100 101 return (startaddr); 102 } 103 104 /* 105 * During a fork, we copy all of the sequences from parent p1 to 106 * the child p2. 107 */ 108 int 109 ras_fork(struct proc *p1, struct proc *p2) 110 { 111 struct ras *rp, *nrp; 112 int nras; 113 114 again: 115 /* 116 * first, try to shortcut. 117 */ 118 119 if (LIST_EMPTY(&p1->p_raslist)) 120 return (0); 121 122 /* 123 * count entries. 124 */ 125 126 nras = 0; 127 mutex_enter(&p1->p_rasmutex); 128 LIST_FOREACH(rp, &p1->p_raslist, ras_list) 129 nras++; 130 mutex_exit(&p1->p_rasmutex); 131 132 /* 133 * allocate entries. 134 */ 135 136 for ( ; nras > 0; nras--) { 137 nrp = pool_get(&ras_pool, PR_WAITOK); 138 nrp->ras_hits = 0; 139 LIST_INSERT_HEAD(&p2->p_raslist, nrp, ras_list); 140 } 141 142 /* 143 * copy entries. 144 */ 145 146 mutex_enter(&p1->p_rasmutex); 147 nrp = LIST_FIRST(&p2->p_raslist); 148 LIST_FOREACH(rp, &p1->p_raslist, ras_list) { 149 if (nrp == NULL) 150 break; 151 nrp->ras_startaddr = rp->ras_startaddr; 152 nrp->ras_endaddr = rp->ras_endaddr; 153 nrp = LIST_NEXT(nrp, ras_list); 154 } 155 mutex_exit(&p1->p_rasmutex); 156 157 /* 158 * if we lose a race, retry. 159 */ 160 161 if (rp != NULL || nrp != NULL) { 162 ras_purgeall(p2); 163 goto again; 164 } 165 166 DPRINTF(("ras_fork: p1=%p, p2=%p, nras=%d\n", p1, p2, nras)); 167 168 return (0); 169 } 170 171 /* 172 * Nuke all sequences for this process. 173 */ 174 int 175 ras_purgeall(struct proc *p) 176 { 177 struct ras *rp; 178 179 mutex_enter(&p->p_rasmutex); 180 while (!LIST_EMPTY(&p->p_raslist)) { 181 rp = LIST_FIRST(&p->p_raslist); 182 DPRINTF(("RAS %p-%p, hits %d\n", rp->ras_startaddr, 183 rp->ras_endaddr, rp->ras_hits)); 184 LIST_REMOVE(rp, ras_list); 185 pool_put(&ras_pool, rp); 186 } 187 mutex_exit(&p->p_rasmutex); 188 189 return (0); 190 } 191 192 #if defined(__HAVE_RAS) 193 194 /* 195 * Install the new sequence. If it already exists, return 196 * an error. 197 */ 198 static int 199 ras_install(struct proc *p, caddr_t addr, size_t len) 200 { 201 struct ras *rp; 202 struct ras *newrp; 203 caddr_t endaddr = addr + len; 204 int nras = 0; 205 206 if (addr < (caddr_t)VM_MIN_ADDRESS || 207 endaddr > (caddr_t)VM_MAXUSER_ADDRESS) 208 return (EINVAL); 209 210 if (len <= 0) 211 return (EINVAL); 212 213 newrp = NULL; 214 again: 215 mutex_enter(&p->p_rasmutex); 216 LIST_FOREACH(rp, &p->p_raslist, ras_list) { 217 if (++nras >= ras_per_proc || 218 (addr < rp->ras_endaddr && endaddr > rp->ras_startaddr)) { 219 mutex_exit(&p->p_rasmutex); 220 return (EINVAL); 221 } 222 } 223 if (newrp == NULL) { 224 mutex_exit(&p->p_rasmutex); 225 newrp = pool_get(&ras_pool, PR_WAITOK); 226 goto again; 227 } 228 newrp->ras_startaddr = addr; 229 newrp->ras_endaddr = endaddr; 230 newrp->ras_hits = 0; 231 LIST_INSERT_HEAD(&p->p_raslist, newrp, ras_list); 232 mutex_exit(&p->p_rasmutex); 233 234 return (0); 235 } 236 237 /* 238 * Nuke the specified sequence. Both address and len must 239 * match, otherwise we return an error. 240 */ 241 static int 242 ras_purge(struct proc *p, caddr_t addr, size_t len) 243 { 244 struct ras *rp; 245 caddr_t endaddr = addr + len; 246 int error = ESRCH; 247 248 mutex_enter(&p->p_rasmutex); 249 LIST_FOREACH(rp, &p->p_raslist, ras_list) { 250 if (addr == rp->ras_startaddr && endaddr == rp->ras_endaddr) { 251 LIST_REMOVE(rp, ras_list); 252 break; 253 } 254 } 255 mutex_exit(&p->p_rasmutex); 256 257 if (rp != NULL) { 258 pool_put(&ras_pool, rp); 259 error = 0; 260 } 261 262 return (error); 263 } 264 265 #endif /* defined(__HAVE_RAS) */ 266 267 /*ARGSUSED*/ 268 int 269 sys_rasctl(struct lwp *l, void *v, register_t *retval) 270 { 271 272 #if defined(__HAVE_RAS) 273 274 struct sys_rasctl_args /* { 275 syscallarg(caddr_t) addr; 276 syscallarg(size_t) len; 277 syscallarg(int) op; 278 } */ *uap = v; 279 struct proc *p = l->l_proc; 280 caddr_t addr; 281 size_t len; 282 int op; 283 int error; 284 285 /* 286 * first, extract syscall args from the uap. 287 */ 288 289 addr = (caddr_t)SCARG(uap, addr); 290 len = (size_t)SCARG(uap, len); 291 op = SCARG(uap, op); 292 293 DPRINTF(("sys_rasctl: p=%p addr=%p, len=%ld, op=0x%x\n", 294 p, addr, (long)len, op)); 295 296 switch (op) { 297 case RAS_INSTALL: 298 error = ras_install(p, addr, len); 299 break; 300 case RAS_PURGE: 301 error = ras_purge(p, addr, len); 302 break; 303 case RAS_PURGE_ALL: 304 error = ras_purgeall(p); 305 break; 306 default: 307 error = EINVAL; 308 break; 309 } 310 311 return (error); 312 313 #else 314 315 return (EOPNOTSUPP); 316 317 #endif 318 319 } 320
Indexes created Mon Sep 22 05:09:51 GMT 2025