Home | History | Annotate | Line # | Download | only in kern
kern_ras.c revision 1.31 
      1 /*	$NetBSD: kern_ras.c,v 1.31 2008/05/27 17:42:14 ad Exp $	*/
      2 
      3 /*-
      4  * Copyright (c) 2002, 2006, 2007, 2008 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, and by Andrew Doran.
      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  *
     19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29  * POSSIBILITY OF SUCH DAMAGE.
     30  */
     31 
     32 #include <sys/cdefs.h>
     33 __KERNEL_RCSID(0, "$NetBSD: kern_ras.c,v 1.31 2008/05/27 17:42:14 ad Exp $");
     34 
     35 #include <sys/param.h>
     36 #include <sys/systm.h>
     37 #include <sys/kernel.h>
     38 #include <sys/kmem.h>
     39 #include <sys/proc.h>
     40 #include <sys/ras.h>
     41 #include <sys/xcall.h>
     42 #include <sys/syscallargs.h>
     43 
     44 #include <uvm/uvm_extern.h>
     45 
     46 #define MAX_RAS_PER_PROC	16
     47 
     48 u_int ras_per_proc = MAX_RAS_PER_PROC;
     49 
     50 #ifdef DEBUG
     51 int ras_debug = 0;
     52 #define DPRINTF(x)	if (ras_debug) printf x
     53 #else
     54 #define DPRINTF(x)	/* nothing */
     55 #endif
     56 
     57 /*
     58  * Force all CPUs through cpu_switchto(), waiting until complete.
     59  * Context switching will drain the write buffer on the calling
     60  * CPU.
     61  */
     62 static void
     63 ras_sync(void)
     64 {
     65 
     66 	/* No need to sync if exiting or single threaded. */
     67 	if (curproc->p_nlwps > 1 && ncpu > 1) {
     68 #ifdef NO_SOFTWARE_PATENTS
     69 		uint64_t where;
     70 		where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
     71 		xc_wait(where);
     72 #else
     73 		/*
     74 		 * Assumptions:
     75 		 *
     76 		 * o preemption is disabled by the thread in
     77 		 *   ras_lookup().
     78 		 * o proc::p_raslist is only inspected with
     79 		 *   preemption disabled.
     80 		 * o ras_lookup() plus loads reordered in advance
     81 		 *   will take no longer than 1/8s to complete.
     82 		 */
     83 		const int delta = hz >> 3;
     84 		int target = hardclock_ticks + delta;
     85 		do {
     86 			kpause("ras", false, delta, NULL);
     87 		} while (hardclock_ticks < target);
     88 #endif
     89 	}
     90 }
     91 
     92 /*
     93  * Check the specified address to see if it is within the
     94  * sequence.  If it is found, we return the restart address,
     95  * otherwise we return -1.  If we do perform a restart, we
     96  * mark the sequence as hit.
     97  *
     98  * No locking required: we disable preemption and ras_sync()
     99  * guarantees that individual entries are valid while we still
    100  * have visibility of them.
    101  */
    102 void *
    103 ras_lookup(struct proc *p, void *addr)
    104 {
    105 	struct ras *rp;
    106 	void *startaddr;
    107 	lwp_t *l;
    108 
    109 	startaddr = (void *)-1;
    110 	l = curlwp;
    111 
    112 	KPREEMPT_DISABLE(l);
    113 	for (rp = p->p_raslist; rp != NULL; rp = rp->ras_next) {
    114 		if (addr > rp->ras_startaddr && addr < rp->ras_endaddr) {
    115 			startaddr = rp->ras_startaddr;
    116 			DPRINTF(("RAS hit: p=%p %p\n", p, addr));
    117 			break;
    118 		}
    119 	}
    120 	KPREEMPT_ENABLE(l);
    121 
    122 	return startaddr;
    123 }
    124 
    125 /*
    126  * During a fork, we copy all of the sequences from parent p1 to
    127  * the child p2.
    128  *
    129  * No locking required as the parent must be paused.
    130  */
    131 int
    132 ras_fork(struct proc *p1, struct proc *p2)
    133 {
    134 	struct ras *rp, *nrp;
    135 
    136 	for (rp = p1->p_raslist; rp != NULL; rp = rp->ras_next) {
    137 		nrp = kmem_alloc(sizeof(*nrp), KM_SLEEP);
    138 		nrp->ras_startaddr = rp->ras_startaddr;
    139 		nrp->ras_endaddr = rp->ras_endaddr;
    140 		nrp->ras_next = p2->p_raslist;
    141 		p2->p_raslist = nrp;
    142 	}
    143 
    144 	DPRINTF(("ras_fork: p1=%p, p2=%p\n", p1, p2));
    145 
    146 	return 0;
    147 }
    148 
    149 /*
    150  * Nuke all sequences for this process.
    151  */
    152 int
    153 ras_purgeall(void)
    154 {
    155 	struct ras *rp, *nrp;
    156 	proc_t *p;
    157 
    158 	p = curproc;
    159 
    160 	mutex_enter(&p->p_auxlock);
    161 	if ((rp = p->p_raslist) != NULL) {
    162 		p->p_raslist = NULL;
    163 		ras_sync();
    164 		for(; rp != NULL; rp = nrp) {
    165 			nrp = rp->ras_next;
    166 			kmem_free(rp, sizeof(*rp));
    167 		}
    168 	}
    169 	mutex_exit(&p->p_auxlock);
    170 
    171 	return 0;
    172 }
    173 
    174 #if defined(__HAVE_RAS)
    175 
    176 /*
    177  * Install the new sequence.  If it already exists, return
    178  * an error.
    179  */
    180 static int
    181 ras_install(void *addr, size_t len)
    182 {
    183 	struct ras *rp;
    184 	struct ras *newrp;
    185 	void *endaddr;
    186 	int nras, error;
    187 	proc_t *p;
    188 
    189 	endaddr = (char *)addr + len;
    190 
    191 	if (addr < (void *)VM_MIN_ADDRESS ||
    192 	    endaddr > (void *)VM_MAXUSER_ADDRESS)
    193 		return (EINVAL);
    194 
    195 	if (len <= 0)
    196 		return (EINVAL);
    197 
    198 	newrp = kmem_alloc(sizeof(*newrp), KM_SLEEP);
    199 	newrp->ras_startaddr = addr;
    200 	newrp->ras_endaddr = endaddr;
    201 	error = 0;
    202 	nras = 0;
    203 	p = curproc;
    204 
    205 	mutex_enter(&p->p_auxlock);
    206 	for (rp = p->p_raslist; rp != NULL; rp = rp->ras_next) {
    207 		if (++nras >= ras_per_proc) {
    208 			error = EINVAL;
    209 			break;
    210 		}
    211 		if (addr < rp->ras_endaddr && endaddr > rp->ras_startaddr) {
    212 			error = EEXIST;
    213 			break;
    214 		}
    215 	}
    216 	if (rp == NULL) {
    217 		newrp->ras_next = p->p_raslist;
    218 		p->p_raslist = newrp;
    219 		ras_sync();
    220 	 	mutex_exit(&p->p_auxlock);
    221 	} else {
    222 	 	mutex_exit(&p->p_auxlock);
    223  		kmem_free(newrp, sizeof(*newrp));
    224 	}
    225 
    226 	return error;
    227 }
    228 
    229 /*
    230  * Nuke the specified sequence.  Both address and len must
    231  * match, otherwise we return an error.
    232  */
    233 static int
    234 ras_purge(void *addr, size_t len)
    235 {
    236 	struct ras *rp, **link;
    237 	void *endaddr;
    238 	proc_t *p;
    239 
    240 	endaddr = (char *)addr + len;
    241 	p = curproc;
    242 
    243 	mutex_enter(&p->p_auxlock);
    244 	link = &p->p_raslist;
    245 	for (rp = *link; rp != NULL; link = &rp->ras_next, rp = *link) {
    246 		if (addr == rp->ras_startaddr && endaddr == rp->ras_endaddr)
    247 			break;
    248 	}
    249 	if (rp != NULL) {
    250 		*link = rp->ras_next;
    251 		ras_sync();
    252 		mutex_exit(&p->p_auxlock);
    253 		kmem_free(rp, sizeof(*rp));
    254 		return 0;
    255 	} else {
    256 		mutex_exit(&p->p_auxlock);
    257 		return ESRCH;
    258 	}
    259 }
    260 
    261 #endif /* defined(__HAVE_RAS) */
    262 
    263 /*ARGSUSED*/
    264 int
    265 sys_rasctl(struct lwp *l, const struct sys_rasctl_args *uap, register_t *retval)
    266 {
    267 
    268 #if defined(__HAVE_RAS)
    269 	/* {
    270 		syscallarg(void *) addr;
    271 		syscallarg(size_t) len;
    272 		syscallarg(int) op;
    273 	} */
    274 	void *addr;
    275 	size_t len;
    276 	int op;
    277 	int error;
    278 
    279 	/*
    280 	 * first, extract syscall args from the uap.
    281 	 */
    282 
    283 	addr = (void *)SCARG(uap, addr);
    284 	len = (size_t)SCARG(uap, len);
    285 	op = SCARG(uap, op);
    286 
    287 	DPRINTF(("sys_rasctl: p=%p addr=%p, len=%ld, op=0x%x\n",
    288 	    curproc, addr, (long)len, op));
    289 
    290 	switch (op) {
    291 	case RAS_INSTALL:
    292 		error = ras_install(addr, len);
    293 		break;
    294 	case RAS_PURGE:
    295 		error = ras_purge(addr, len);
    296 		break;
    297 	case RAS_PURGE_ALL:
    298 		error = ras_purgeall();
    299 		break;
    300 	default:
    301 		error = EINVAL;
    302 		break;
    303 	}
    304 
    305 	return (error);
    306 
    307 #else
    308 
    309 	return (EOPNOTSUPP);
    310 
    311 #endif
    312 
    313 }
    314