Subversion Repositories planix.SVN

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2 - 1 
#include "u.h"
2 
#include "../port/lib.h"
3 
#include "mem.h"
4 
#include "dat.h"
5 
#include "fns.h"
6 
#include "../port/error.h"
7 
#include "../port/systab.h"
8 
 
9 
#include <tos.h>
10 
#include "ureg.h"
11 
 
12 
#include "arm.h"
13 
 
14 
typedef struct {
15 
	uintptr	ip;
16 
	Ureg*	arg0;
17 
	char*	arg1;
18 
	char	msg[ERRMAX];
19 
	Ureg*	old;
20 
	Ureg	ureg;
21 
} NFrame;
22 
 
23 
/*
24 
 *   Return user to state before notify()
25 
 */
26 
static void
27 
noted(Ureg* cur, uintptr arg0)
28 
{
29 
	NFrame *nf;
30 
	Ureg *nur;
31 
 
32 
	qlock(&up->debug);
33 
	if(arg0 != NRSTR && !up->notified){
34 
		qunlock(&up->debug);
35 
		pprint("call to noted() when not notified\n");
36 
		pexit("Suicide", 0);
37 
	}
38 
	up->notified = 0;
39 
	fpunoted();
40 
 
41 
	nf = up->ureg;
42 
 
43 
	/* sanity clause */
44 
	if(!okaddr(PTR2UINT(nf), sizeof(NFrame), 0)){
45 
		qunlock(&up->debug);
46 
		pprint("bad ureg in noted %#p\n", nf);
47 
		pexit("Suicide", 0);
48 
	}
49 
 
50 
	/* don't let user change system flags */
51 
	nur = &nf->ureg;
52 
	nur->psr &= PsrMask|PsrDfiq|PsrDirq;
53 
	nur->psr |= (cur->psr & ~(PsrMask|PsrDfiq|PsrDirq));
54 
 
55 
	memmove(cur, nur, sizeof(Ureg));
56 
 
57 
	switch((int)arg0){
58 
	case NCONT:
59 
	case NRSTR:
60 
		if(!okaddr(nur->pc, BY2WD, 0) || !okaddr(nur->sp, BY2WD, 0)){
61 
			qunlock(&up->debug);
62 
			pprint("suicide: trap in noted\n");
63 
			pexit("Suicide", 0);
64 
		}
65 
		up->ureg = nf->old;
66 
		qunlock(&up->debug);
67 
		break;
68 
	case NSAVE:
69 
		if(!okaddr(nur->pc, BY2WD, 0) || !okaddr(nur->sp, BY2WD, 0)){
70 
			qunlock(&up->debug);
71 
			pprint("suicide: trap in noted\n");
72 
			pexit("Suicide", 0);
73 
		}
74 
		qunlock(&up->debug);
75 
 
76 
		splhi();
77 
		nf->arg1 = nf->msg;
78 
		nf->arg0 = &nf->ureg;
79 
		nf->ip = 0;
80 
		cur->sp = PTR2UINT(nf);
81 
		cur->r0 = PTR2UINT(nf->arg0);
82 
		break;
83 
	default:
84 
		pprint("unknown noted arg %#p\n", arg0);
85 
		up->lastnote.flag = NDebug;
86 
		/*FALLTHROUGH*/
87 
	case NDFLT:
88 
		if(up->lastnote.flag == NDebug){
89 
			qunlock(&up->debug);
90 
			pprint("suicide: %s\n", up->lastnote.msg);
91 
		}
92 
		else
93 
			qunlock(&up->debug);
94 
		pexit(up->lastnote.msg, up->lastnote.flag != NDebug);
95 
	}
96 
}
97 
 
98 
/*
99 
 *  Call user, if necessary, with note.
100 
 *  Pass user the Ureg struct and the note on his stack.
101 
 */
102 
int
103 
notify(Ureg* ureg)
104 
{
105 
	int l;
106 
	Note *n;
107 
	u32int s;
108 
	uintptr sp;
109 
	NFrame *nf;
110 
 
111 
	if(up->procctl)
112 
		procctl(up);
113 
	if(up->nnote == 0)
114 
		return 0;
115 
 
116 
	fpunotify(ureg);
117 
 
118 
	s = spllo();
119 
	qlock(&up->debug);
120 
 
121 
	up->notepending = 0;
122 
	n = &up->note[0];
123 
	if(strncmp(n->msg, "sys:", 4) == 0){
124 
		l = strlen(n->msg);
125 
		if(l > ERRMAX-23)	/* " pc=0x0123456789abcdef\0" */
126 
			l = ERRMAX-23;
127 
		snprint(n->msg + l, sizeof n->msg - l, " pc=%#lux", ureg->pc);
128 
	}
129 
 
130 
	if(n->flag != NUser && (up->notified || up->notify == 0)){
131 
		if(n->flag == NDebug)
132 
			pprint("suicide: %s\n", n->msg);
133 
		qunlock(&up->debug);
134 
		pexit(n->msg, n->flag != NDebug);
135 
	}
136 
 
137 
	if(up->notified){
138 
		qunlock(&up->debug);
139 
		splhi();
140 
		return 0;
141 
	}
142 
 
143 
	if(up->notify == nil){
144 
		qunlock(&up->debug);
145 
		pexit(n->msg, n->flag != NDebug);
146 
	}
147 
	if(!okaddr(PTR2UINT(up->notify), 1, 0)){
148 
		pprint("suicide: notify function address %#p\n", up->notify);
149 
		qunlock(&up->debug);
150 
		pexit("Suicide", 0);
151 
	}
152 
 
153 
	sp = ureg->sp - sizeof(NFrame);
154 
	if(!okaddr(sp, sizeof(NFrame), 1)){
155 
		qunlock(&up->debug);
156 
		pprint("suicide: notify stack address %#p\n", sp);
157 
		pexit("Suicide", 0);
158 
	}
159 
 
160 
	nf = UINT2PTR(sp);
161 
	memmove(&nf->ureg, ureg, sizeof(Ureg));
162 
	nf->old = up->ureg;
163 
	up->ureg = nf;
164 
	memmove(nf->msg, up->note[0].msg, ERRMAX);
165 
	nf->arg1 = nf->msg;
166 
	nf->arg0 = &nf->ureg;
167 
	ureg->r0 = PTR2UINT(nf->arg0);
168 
	nf->ip = 0;
169 
 
170 
	ureg->sp = sp;
171 
	ureg->pc = PTR2UINT(up->notify);
172 
	up->notified = 1;
173 
	up->nnote--;
174 
	memmove(&up->lastnote, &up->note[0], sizeof(Note));
175 
	memmove(&up->note[0], &up->note[1], up->nnote*sizeof(Note));
176 
 
177 
	qunlock(&up->debug);
178 
	splx(s);
179 
 
180 
	return 1;
181 
}
182 
 
183 
void
184 
syscall(Ureg* ureg)
185 
{
186 
	char *e;
187 
	u32int s;
188 
	ulong sp;
189 
	long ret;
190 
	int i, scallnr;
191 
	vlong startns, stopns;
192 
 
193 
	if(!userureg(ureg))
194 
		panic("syscall: from kernel: pc %#lux r14 %#lux psr %#lux",
195 
			ureg->pc, ureg->r14, ureg->psr);
196 
 
197 
	cycles(&up->kentry);
198 
 
199 
	m->syscall++;
200 
	up->insyscall = 1;
201 
	up->pc = ureg->pc;
202 
	up->dbgreg = ureg;
203 
 
204 
	scallnr = ureg->r0;
205 
	up->scallnr = scallnr;
206 
	if(scallnr == RFORK)
207 
		fpusysrfork(ureg);
208 
	spllo();
209 
	sp = ureg->sp;
210 
 
211 
	if(up->procctl == Proc_tracesyscall){
212 
		/*
213 
		 * Redundant validaddr.  Do we care?
214 
		 * Tracing syscalls is not exactly a fast path...
215 
		 * Beware, validaddr currently does a pexit rather
216 
		 * than an error if there's a problem; that might
217 
		 * change in the future.
218 
		 */
219 
		if(sp < (USTKTOP-BY2PG) || sp > (USTKTOP-sizeof(Sargs)-BY2WD))
220 
			validaddr(sp, sizeof(Sargs)+BY2WD, 0);
221 
 
222 
		syscallfmt(scallnr, ureg->pc, (va_list)(sp+BY2WD));
223 
		up->procctl = Proc_stopme;
224 
		procctl(up);
225 
		if (up->syscalltrace)
226 
			free(up->syscalltrace);
227 
		up->syscalltrace = nil;
228 
	}
229 
 
230 
	up->nerrlab = 0;
231 
	ret = -1;
232 
	startns = todget(nil);
233 
	if(!waserror()){
234 
		if(scallnr >= nsyscall){
235 
			pprint("bad sys call number %d pc %#lux\n",
236 
				scallnr, ureg->pc);
237 
			postnote(up, 1, "sys: bad sys call", NDebug);
238 
			error(Ebadarg);
239 
		}
240 
 
241 
		if(sp < (USTKTOP-BY2PG) || sp > (USTKTOP-sizeof(Sargs)-BY2WD))
242 
			validaddr(sp, sizeof(Sargs)+BY2WD, 0);
243 
 
244 
		up->s = *((Sargs*)(sp+BY2WD));
245 
		up->psstate = sysctab[scallnr];
246 
 
247 
	/*	iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
248 
 
249 
		ret = systab[scallnr](up->s.args);
250 
		poperror();
251 
	}else{
252 
		/* failure: save the error buffer for errstr */
253 
		e = up->syserrstr;
254 
		up->syserrstr = up->errstr;
255 
		up->errstr = e;
256 
	}
257 
	if(up->nerrlab){
258 
		print("bad errstack [%d]: %d extra\n", scallnr, up->nerrlab);
259 
		for(i = 0; i < NERR; i++)
260 
			print("sp=%#p pc=%#p\n",
261 
				up->errlab[i].sp, up->errlab[i].pc);
262 
		panic("error stack");
263 
	}
264 
 
265 
	/*
266 
	 *  Put return value in frame.  On the x86 the syscall is
267 
	 *  just another trap and the return value from syscall is
268 
	 *  ignored.  On other machines the return value is put into
269 
	 *  the results register by caller of syscall.
270 
	 */
271 
	ureg->r0 = ret;
272 
 
273 
	if(up->procctl == Proc_tracesyscall){
274 
		stopns = todget(nil);
275 
		up->procctl = Proc_stopme;
276 
		sysretfmt(scallnr, (va_list)(sp+BY2WD), ret, startns, stopns);
277 
		s = splhi();
278 
		procctl(up);
279 
		splx(s);
280 
		if(up->syscalltrace)
281 
			free(up->syscalltrace);
282 
		up->syscalltrace = nil;
283 
	}
284 
 
285 
	up->insyscall = 0;
286 
	up->psstate = 0;
287 
 
288 
	if(scallnr == NOTED)
289 
		noted(ureg, *(ulong*)(sp+BY2WD));
290 
 
291 
	splhi();
292 
	if(scallnr != RFORK && (up->procctl || up->nnote))
293 
		notify(ureg);
294 
 
295 
	/* if we delayed sched because we held a lock, sched now */
296 
	if(up->delaysched){
297 
		sched();
298 
		splhi();
299 
	}
300 
	kexit(ureg);
301 
}
302 
 
303 
long
304 
execregs(ulong entry, ulong ssize, ulong nargs)
305 
{
306 
	ulong *sp;
307 
	Ureg *ureg;
308 
 
309 
	sp = (ulong*)(USTKTOP - ssize);
310 
	*--sp = nargs;
311 
 
312 
	ureg = up->dbgreg;
313 
//	memset(ureg, 0, 15*sizeof(ulong));
314 
	ureg->r13 = (ulong)sp;
315 
	ureg->pc = entry;
316 
//print("%lud: EXECREGS pc %#ux sp %#ux nargs %ld\n", up->pid, ureg->pc, ureg->r13, nargs);
317 
 
318 
	/*
319 
	 * return the address of kernel/user shared data
320 
	 * (e.g. clock stuff)
321 
	 */
322 
	return USTKTOP-sizeof(Tos);
323 
}
324 
 
325 
void
326 
sysprocsetup(Proc* p)
327 
{
328 
	fpusysprocsetup(p);
329 
}
330 
 
331 
/*
332 
 *  Craft a return frame which will cause the child to pop out of
333 
 *  the scheduler in user mode with the return register zero.  Set
334 
 *  pc to point to a l.s return function.
335 
 */
336 
void
337 
forkchild(Proc *p, Ureg *ureg)
338 
{
339 
	Ureg *cureg;
340 
 
341 
//print("%lud setting up for forking child %lud\n", up->pid, p->pid);
342 
	p->sched.sp = (ulong)p->kstack+KSTACK-sizeof(Ureg);
343 
	p->sched.pc = (ulong)forkret;
344 
 
345 
	cureg = (Ureg*)(p->sched.sp);
346 
	memmove(cureg, ureg, sizeof(Ureg));
347 
 
348 
	/* syscall returns 0 for child */
349 
	cureg->r0 = 0;
350 
 
351 
	/* Things from bottom of syscall which were never executed */
352 
	p->psstate = 0;
353 
	p->insyscall = 0;
354 
 
355 
	fpusysrforkchild(p, cureg, up);
356 
}