kern_ras.c revision 1.18 
1/*	$NetBSD: kern_ras.c,v 1.18 2007/03/12 18:18:33 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.18 2007/03/12 18:18:33 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
54POOL_INIT(ras_pool, sizeof(struct ras), 0, 0, 0, "raspl",
55    &pool_allocator_nointr, IPL_NONE);
56
57#define MAX_RAS_PER_PROC	16
58
59u_int ras_per_proc = MAX_RAS_PER_PROC;
60
61#ifdef DEBUG
62int 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 */
74void *
75ras_lookup(struct proc *p, void *addr)
76{
77	struct ras *rp;
78	void *startaddr;
79
80	startaddr = (void *)-1;
81
82#ifdef DIAGNOSTIC
83	if (addr < (void *)VM_MIN_ADDRESS ||
84	    addr > (void *)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 */
108int
109ras_fork(struct proc *p1, struct proc *p2)
110{
111	struct ras *rp, *nrp;
112	int nras;
113
114again:
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 */
174int
175ras_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		mutex_exit(&p->p_rasmutex);
186		pool_put(&ras_pool, rp);
187		mutex_enter(&p->p_rasmutex);
188	}
189	mutex_exit(&p->p_rasmutex);
190
191	return (0);
192}
193
194#if defined(__HAVE_RAS)
195
196/*
197 * Install the new sequence.  If it already exists, return
198 * an error.
199 */
200static int
201ras_install(struct proc *p, void *addr, size_t len)
202{
203	struct ras *rp;
204	struct ras *newrp;
205	void *endaddr = (char *)addr + len;
206	int nras = 0;
207
208	if (addr < (void *)VM_MIN_ADDRESS ||
209	    endaddr > (void *)VM_MAXUSER_ADDRESS)
210		return (EINVAL);
211
212	if (len <= 0)
213		return (EINVAL);
214
215	newrp = NULL;
216again:
217	mutex_enter(&p->p_rasmutex);
218	LIST_FOREACH(rp, &p->p_raslist, ras_list) {
219		if (++nras >= ras_per_proc ||
220		    (addr < rp->ras_endaddr && endaddr > rp->ras_startaddr)) {
221			mutex_exit(&p->p_rasmutex);
222			return (EINVAL);
223		}
224	}
225	if (newrp == NULL) {
226		mutex_exit(&p->p_rasmutex);
227		newrp = pool_get(&ras_pool, PR_WAITOK);
228		goto again;
229	}
230	newrp->ras_startaddr = addr;
231	newrp->ras_endaddr = endaddr;
232	newrp->ras_hits = 0;
233	LIST_INSERT_HEAD(&p->p_raslist, newrp, ras_list);
234	mutex_exit(&p->p_rasmutex);
235
236	return (0);
237}
238
239/*
240 * Nuke the specified sequence.  Both address and len must
241 * match, otherwise we return an error.
242 */
243static int
244ras_purge(struct proc *p, void *addr, size_t len)
245{
246	struct ras *rp;
247	void *endaddr = (char *)addr + len;
248	int error = ESRCH;
249
250	mutex_enter(&p->p_rasmutex);
251	LIST_FOREACH(rp, &p->p_raslist, ras_list) {
252		if (addr == rp->ras_startaddr && endaddr == rp->ras_endaddr) {
253			LIST_REMOVE(rp, ras_list);
254			break;
255		}
256	}
257	mutex_exit(&p->p_rasmutex);
258
259	if (rp != NULL) {
260		pool_put(&ras_pool, rp);
261		error = 0;
262	}
263
264	return (error);
265}
266
267#endif /* defined(__HAVE_RAS) */
268
269/*ARGSUSED*/
270int
271sys_rasctl(struct lwp *l, void *v, register_t *retval)
272{
273
274#if defined(__HAVE_RAS)
275
276	struct sys_rasctl_args /* {
277		syscallarg(void *) addr;
278		syscallarg(size_t) len;
279		syscallarg(int) op;
280	} */ *uap = v;
281	struct proc *p = l->l_proc;
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	    p, addr, (long)len, op));
297
298	switch (op) {
299	case RAS_INSTALL:
300		error = ras_install(p, addr, len);
301		break;
302	case RAS_PURGE:
303		error = ras_purge(p, addr, len);
304		break;
305	case RAS_PURGE_ALL:
306		error = ras_purgeall(p);
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