kern_ras.c revision 1.7 
1/*	$NetBSD: kern_ras.c,v 1.7 2004/03/25 22:08:33 pooka 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.7 2004/03/25 22:08:33 pooka 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
58u_int ras_per_proc = MAX_RAS_PER_PROC;
59
60#ifdef DEBUG
61int ras_debug = 0;
62#define DPRINTF(x)	if (ras_debug) printf x
63#else
64#define DPRINTF(x)	/* nothing */
65#endif
66
67int ras_install(struct proc *, caddr_t, size_t);
68int ras_purge(struct proc *, caddr_t, size_t);
69
70/*
71 * Check the specified address to see if it is within the
72 * sequence.  If it is found, we return the restart address,
73 * otherwise we return -1.  If we do perform a restart, we
74 * mark the sequence as hit.
75 */
76caddr_t
77ras_lookup(struct proc *p, caddr_t addr)
78{
79	struct ras *rp;
80
81#ifdef DIAGNOSTIC
82	if (addr < (caddr_t)VM_MIN_ADDRESS ||
83	    addr > (caddr_t)VM_MAXUSER_ADDRESS)
84		return ((caddr_t)-1);
85#endif
86
87	simple_lock(&p->p_lock);
88	LIST_FOREACH(rp, &p->p_raslist, ras_list) {
89		if (addr > rp->ras_startaddr && addr < rp->ras_endaddr) {
90			rp->ras_hits++;
91			simple_unlock(&p->p_lock);
92#ifdef DIAGNOSTIC
93			DPRINTF(("RAS hit: p=%p %p\n", p, addr));
94#endif
95			return (rp->ras_startaddr);
96		}
97	}
98	simple_unlock(&p->p_lock);
99
100	return ((caddr_t)-1);
101}
102
103/*
104 * During a fork, we copy all of the sequences from parent p1 to
105 * the child p2.
106 */
107int
108ras_fork(struct proc *p1, struct proc *p2)
109{
110	struct ras *rp, *nrp;
111	int nras = 0;
112
113	simple_lock(&p1->p_lock);
114	LIST_FOREACH(rp, &p1->p_raslist, ras_list) {
115		nras++;
116		nrp = pool_get(&ras_pool, PR_WAITOK);
117		nrp->ras_startaddr = rp->ras_startaddr;
118		nrp->ras_endaddr = rp->ras_endaddr;
119		nrp->ras_hits = 0;
120		LIST_INSERT_HEAD(&p2->p_raslist, nrp, ras_list);
121	}
122	simple_unlock(&p1->p_lock);
123
124	DPRINTF(("ras_fork: p1=%p, p2=%p, nras=%d\n", p1, p2, nras));
125
126	return (0);
127}
128
129/*
130 * Nuke all sequences for this process.
131 */
132int
133ras_purgeall(struct proc *p)
134{
135	struct ras *rp;
136
137	simple_lock(&p->p_lock);
138	while (!LIST_EMPTY(&p->p_raslist)) {
139		rp = LIST_FIRST(&p->p_raslist);
140                DPRINTF(("RAS %p-%p, hits %d\n", rp->ras_startaddr,
141                    rp->ras_endaddr, rp->ras_hits));
142		LIST_REMOVE(rp, ras_list);
143		pool_put(&ras_pool, rp);
144	}
145	simple_unlock(&p->p_lock);
146
147	return (0);
148}
149
150/*
151 * Install the new sequence.  If it already exists, return
152 * an error.
153 */
154int
155ras_install(struct proc *p, caddr_t addr, size_t len)
156{
157	struct ras *rp;
158	caddr_t endaddr = addr + len;
159	int nras = 0;
160
161	if (addr < (caddr_t)VM_MIN_ADDRESS ||
162	    endaddr > (caddr_t)VM_MAXUSER_ADDRESS)
163		return (EINVAL);
164
165	if (len <= 0)
166		return (EINVAL);
167
168	simple_lock(&p->p_lock);
169	LIST_FOREACH(rp, &p->p_raslist, ras_list) {
170		if (++nras >= ras_per_proc ||
171		    (addr < rp->ras_endaddr && endaddr > rp->ras_startaddr)) {
172			simple_unlock(&p->p_lock);
173			return (EINVAL);
174		}
175	}
176	rp = pool_get(&ras_pool, PR_WAITOK);
177	rp->ras_startaddr = addr;
178	rp->ras_endaddr = endaddr;
179	rp->ras_hits = 0;
180	LIST_INSERT_HEAD(&p->p_raslist, rp, ras_list);
181	simple_unlock(&p->p_lock);
182
183	return (0);
184}
185
186/*
187 * Nuke the specified sequence.  Both address and len must
188 * match, otherwise we return an error.
189 */
190int
191ras_purge(struct proc *p, caddr_t addr, size_t len)
192{
193	struct ras *rp;
194	caddr_t endaddr = addr + len;
195	int error = ESRCH;
196
197	simple_lock(&p->p_lock);
198	LIST_FOREACH(rp, &p->p_raslist, ras_list) {
199		if (addr == rp->ras_startaddr && endaddr == rp->ras_endaddr) {
200			LIST_REMOVE(rp, ras_list);
201			pool_put(&ras_pool, rp);
202			error = 0;
203			break;
204		}
205	}
206	simple_unlock(&p->p_lock);
207
208	return (error);
209}
210
211/*ARGSUSED*/
212int
213sys_rasctl(struct lwp *l, void *v, register_t *retval)
214{
215
216#if defined(__HAVE_RAS)
217
218	struct sys_rasctl_args /* {
219		syscallarg(caddr_t) addr;
220		syscallarg(size_t) len;
221		syscallarg(int) op;
222	} */ *uap = v;
223	struct proc *p = l->l_proc;
224	caddr_t addr;
225	size_t len;
226	int op;
227	int error;
228
229	/*
230	 * first, extract syscall args from the uap.
231	 */
232
233	addr = (caddr_t)SCARG(uap, addr);
234	len = (size_t)SCARG(uap, len);
235	op = SCARG(uap, op);
236
237	DPRINTF(("sys_rasctl: p=%p addr=%p, len=%ld, op=0x%x\n",
238	    p, addr, (long)len, op));
239
240	switch (op) {
241	case RAS_INSTALL:
242		error = ras_install(p, addr, len);
243		break;
244	case RAS_PURGE:
245		error = ras_purge(p, addr, len);
246		break;
247	case RAS_PURGE_ALL:
248		error = ras_purgeall(p);
249		break;
250	default:
251		error = EINVAL;
252		break;
253	}
254
255	return (error);
256
257#else
258
259	return (EOPNOTSUPP);
260
261#endif
262
263}
264