xref: /netbsd-src/sys/kern/kern_ras.c (revision 267197ec1eebfcb9810ea27a89625b6ddf68e3e7)
1 /*	$NetBSD: kern_ras.c,v 1.27 2008/01/07 20:56:32 dsl Exp $	*/
2 
3 /*-
4  * Copyright (c) 2002, 2006, 2007 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  * 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.27 2008/01/07 20:56:32 dsl Exp $");
41 
42 #include <sys/param.h>
43 #include <sys/systm.h>
44 #include <sys/kernel.h>
45 #include <sys/pool.h>
46 #include <sys/proc.h>
47 #include <sys/ras.h>
48 #include <sys/xcall.h>
49 #include <sys/syscallargs.h>
50 
51 #include <uvm/uvm_extern.h>
52 
53 POOL_INIT(ras_pool, sizeof(struct ras), 0, 0, 0, "raspl",
54     &pool_allocator_nointr, IPL_NONE);
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  * Force all CPUs through cpu_switchto(), waiting until complete.
69  * Context switching will drain the write buffer on the calling
70  * CPU.
71  */
72 static void
73 ras_sync(void)
74 {
75 
76 	/* No need to sync if exiting or single threaded. */
77 	if (curproc->p_nlwps > 1 && ncpu > 1) {
78 #ifdef NO_SOFTWARE_PATENTS
79 		uint64_t where;
80 		where = xc_broadcast(0, (xcfunc_t)nullop, NULL, NULL);
81 		xc_wait(where);
82 #else
83 		/*
84 		 * Assumptions:
85 		 *
86 		 * o preemption is disabled by the thread in
87 		 *   ras_lookup().
88 		 * o proc::p_raslist is only inspected with
89 		 *   preemption disabled.
90 		 * o ras_lookup() plus loads reordered in advance
91 		 *   will take no longer than 1/8s to complete.
92 		 */
93 		const int delta = hz >> 3;
94 		int target = hardclock_ticks + delta;
95 		do {
96 			kpause("ras", false, delta, NULL);
97 		} while (hardclock_ticks < target);
98 #endif
99 	}
100 }
101 
102 /*
103  * Check the specified address to see if it is within the
104  * sequence.  If it is found, we return the restart address,
105  * otherwise we return -1.  If we do perform a restart, we
106  * mark the sequence as hit.
107  *
108  * No locking required: we disable preemption and ras_sync()
109  * guarantees that individual entries are valid while we still
110  * have visibility of them.
111  */
112 void *
113 ras_lookup(struct proc *p, void *addr)
114 {
115 	struct ras *rp;
116 	void *startaddr;
117 
118 	startaddr = (void *)-1;
119 
120 	crit_enter();
121 	for (rp = p->p_raslist; rp != NULL; rp = rp->ras_next) {
122 		if (addr > rp->ras_startaddr && addr < rp->ras_endaddr) {
123 			startaddr = rp->ras_startaddr;
124 			DPRINTF(("RAS hit: p=%p %p\n", p, addr));
125 			break;
126 		}
127 	}
128 	crit_exit();
129 
130 	return startaddr;
131 }
132 
133 /*
134  * During a fork, we copy all of the sequences from parent p1 to
135  * the child p2.
136  *
137  * No locking required as the parent must be paused.
138  */
139 int
140 ras_fork(struct proc *p1, struct proc *p2)
141 {
142 	struct ras *rp, *nrp;
143 
144 	for (rp = p1->p_raslist; rp != NULL; rp = rp->ras_next) {
145 		nrp = pool_get(&ras_pool, PR_WAITOK);
146 		nrp->ras_startaddr = rp->ras_startaddr;
147 		nrp->ras_endaddr = rp->ras_endaddr;
148 		nrp->ras_next = p2->p_raslist;
149 		p2->p_raslist = nrp;
150 	}
151 
152 	DPRINTF(("ras_fork: p1=%p, p2=%p\n", p1, p2));
153 
154 	return 0;
155 }
156 
157 /*
158  * Nuke all sequences for this process.
159  */
160 int
161 ras_purgeall(void)
162 {
163 	struct ras *rp, *nrp;
164 	proc_t *p;
165 
166 	p = curproc;
167 
168 	mutex_enter(&p->p_auxlock);
169 	if ((rp = p->p_raslist) != NULL) {
170 		p->p_raslist = NULL;
171 		ras_sync();
172 		for(; rp != NULL; rp = nrp) {
173 			nrp = rp->ras_next;
174 			pool_put(&ras_pool, rp);
175 		}
176 	}
177 	mutex_exit(&p->p_auxlock);
178 
179 	return 0;
180 }
181 
182 #if defined(__HAVE_RAS)
183 
184 /*
185  * Install the new sequence.  If it already exists, return
186  * an error.
187  */
188 static int
189 ras_install(void *addr, size_t len)
190 {
191 	struct ras *rp;
192 	struct ras *newrp;
193 	void *endaddr;
194 	int nras, error;
195 	proc_t *p;
196 
197 	endaddr = (char *)addr + len;
198 
199 	if (addr < (void *)VM_MIN_ADDRESS ||
200 	    endaddr > (void *)VM_MAXUSER_ADDRESS)
201 		return (EINVAL);
202 
203 	if (len <= 0)
204 		return (EINVAL);
205 
206 	newrp = pool_get(&ras_pool, PR_WAITOK);
207 	newrp->ras_startaddr = addr;
208 	newrp->ras_endaddr = endaddr;
209 	error = 0;
210 	nras = 0;
211 	p = curproc;
212 
213 	mutex_enter(&p->p_auxlock);
214 	for (rp = p->p_raslist; rp != NULL; rp = rp->ras_next) {
215 		if (++nras >= ras_per_proc) {
216 			error = EINVAL;
217 			break;
218 		}
219 		if (addr < rp->ras_endaddr && endaddr > rp->ras_startaddr) {
220 			error = EEXIST;
221 			break;
222 		}
223 	}
224 	if (rp == NULL) {
225 		newrp->ras_next = p->p_raslist;
226 		p->p_raslist = newrp;
227 		ras_sync();
228 	 	mutex_exit(&p->p_auxlock);
229 	} else {
230 	 	mutex_exit(&p->p_auxlock);
231  		pool_put(&ras_pool, newrp);
232 	}
233 
234 	return error;
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(void *addr, size_t len)
243 {
244 	struct ras *rp, **link;
245 	void *endaddr;
246 	proc_t *p;
247 
248 	endaddr = (char *)addr + len;
249 	p = curproc;
250 
251 	mutex_enter(&p->p_auxlock);
252 	link = &p->p_raslist;
253 	for (rp = *link; rp != NULL; link = &rp->ras_next, rp = *link) {
254 		if (addr == rp->ras_startaddr && endaddr == rp->ras_endaddr)
255 			break;
256 	}
257 	if (rp != NULL) {
258 		*link = rp->ras_next;
259 		ras_sync();
260 		mutex_exit(&p->p_auxlock);
261 		pool_put(&ras_pool, rp);
262 		return 0;
263 	} else {
264 		mutex_exit(&p->p_auxlock);
265 		return ESRCH;
266 	}
267 }
268 
269 #endif /* defined(__HAVE_RAS) */
270 
271 /*ARGSUSED*/
272 int
273 sys_rasctl(struct lwp *l, const struct sys_rasctl_args *uap, register_t *retval)
274 {
275 
276 #if defined(__HAVE_RAS)
277 	/* {
278 		syscallarg(void *) addr;
279 		syscallarg(size_t) len;
280 		syscallarg(int) op;
281 	} */
282 	void *addr;
283 	size_t len;
284 	int op;
285 	int error;
286 
287 	/*
288 	 * first, extract syscall args from the uap.
289 	 */
290 
291 	addr = (void *)SCARG(uap, addr);
292 	len = (size_t)SCARG(uap, len);
293 	op = SCARG(uap, op);
294 
295 	DPRINTF(("sys_rasctl: p=%p addr=%p, len=%ld, op=0x%x\n",
296 	    curproc, addr, (long)len, op));
297 
298 	switch (op) {
299 	case RAS_INSTALL:
300 		error = ras_install(addr, len);
301 		break;
302 	case RAS_PURGE:
303 		error = ras_purge(addr, len);
304 		break;
305 	case RAS_PURGE_ALL:
306 		error = ras_purgeall();
307 		break;
308 	default:
309 		error = EINVAL;
310 		break;
311 	}
312 
313 	return (error);
314 
315 #else
316 
317 	return (EOPNOTSUPP);
318 
319 #endif
320 
321 }
322