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 
 
192 
	if(!userureg(ureg))
193 
		panic("syscall: from kernel: pc %#lux r14 %#lux psr %#lux",
194 
			ureg->pc, ureg->r14, ureg->psr);
195 
 
196 
	cycles(&up->kentry);
197 
 
198 
	m->syscall++;
199 
	up->insyscall = 1;
200 
	up->pc = ureg->pc;
201 
	up->dbgreg = ureg;
202 
 
203 
	if(up->procctl == Proc_tracesyscall){
204 
		up->procctl = Proc_stopme;
205 
		procctl(up);
206 
	}
207 
 
208 
	scallnr = ureg->r0;
209 
	up->scallnr = scallnr;
210 
	if(scallnr == RFORK)
211 
		fpusysrfork(ureg);
212 
	spllo();
213 
 
214 
	sp = ureg->sp;
215 
	up->nerrlab = 0;
216 
	ret = -1;
217 
	if(!waserror()){
218 
		if(scallnr >= nsyscall){
219 
			pprint("bad sys call number %d pc %#lux\n",
220 
				scallnr, ureg->pc);
221 
			postnote(up, 1, "sys: bad sys call", NDebug);
222 
			error(Ebadarg);
223 
		}
224 
 
225 
		if(sp < (USTKTOP-BY2PG) || sp > (USTKTOP-sizeof(Sargs)-BY2WD))
226 
			validaddr(sp, sizeof(Sargs)+BY2WD, 0);
227 
 
228 
		up->s = *((Sargs*)(sp+BY2WD));
229 
		up->psstate = sysctab[scallnr];
230 
 
231 
	/*	iprint("%s: syscall %s\n", up->text, sysctab[scallnr]?sysctab[scallnr]:"huh?"); */
232 
 
233 
		ret = systab[scallnr](up->s.args);
234 
		poperror();
235 
	}else{
236 
		/* failure: save the error buffer for errstr */
237 
		e = up->syserrstr;
238 
		up->syserrstr = up->errstr;
239 
		up->errstr = e;
240 
	}
241 
	if(up->nerrlab){
242 
		print("bad errstack [%d]: %d extra\n", scallnr, up->nerrlab);
243 
		for(i = 0; i < NERR; i++)
244 
			print("sp=%#p pc=%#p\n",
245 
				up->errlab[i].sp, up->errlab[i].pc);
246 
		panic("error stack");
247 
	}
248 
 
249 
	/*
250 
	 *  Put return value in frame.  On the x86 the syscall is
251 
	 *  just another trap and the return value from syscall is
252 
	 *  ignored.  On other machines the return value is put into
253 
	 *  the results register by caller of syscall.
254 
	 */
255 
	ureg->r0 = ret;
256 
 
257 
	if(up->procctl == Proc_tracesyscall){
258 
		up->procctl = Proc_stopme;
259 
		s = splhi();
260 
		procctl(up);
261 
		splx(s);
262 
	}
263 
 
264 
	up->insyscall = 0;
265 
	up->psstate = 0;
266 
 
267 
	if(scallnr == NOTED)
268 
		noted(ureg, *(ulong*)(sp+BY2WD));
269 
 
270 
	splhi();
271 
	if(scallnr != RFORK && (up->procctl || up->nnote))
272 
		notify(ureg);
273 
 
274 
	/* if we delayed sched because we held a lock, sched now */
275 
	if(up->delaysched){
276 
		sched();
277 
		splhi();
278 
	}
279 
	kexit(ureg);
280 
}
281 
 
282 
long	/* void* */
283 
execregs(ulong entry, ulong ssize, ulong nargs)
284 
{
285 
	ulong *sp;
286 
	Ureg *ureg;
287 
 
288 
	sp = (ulong*)(USTKTOP - ssize);
289 
	*--sp = nargs;
290 
 
291 
	ureg = up->dbgreg;
292 
//	memset(ureg, 0, 15*sizeof(ulong));
293 
	ureg->r13 = (ulong)sp;
294 
	ureg->pc = entry;
295 
//print("%lud: EXECREGS pc %#ux sp %#ux nargs %ld\n", up->pid, ureg->pc, ureg->r13, nargs);
296 
 
297 
	/*
298 
	 * return the address of kernel/user shared data
299 
	 * (e.g. clock stuff)
300 
	 */
301 
	return USTKTOP-sizeof(Tos);
302 
}
303 
 
304 
void
305 
sysprocsetup(Proc* p)
306 
{
307 
	fpusysprocsetup(p);
308 
}
309 
 
310 
/*
311 
 *  Craft a return frame which will cause the child to pop out of
312 
 *  the scheduler in user mode with the return register zero.  Set
313 
 *  pc to point to a l.s return function.
314 
 */
315 
void
316 
forkchild(Proc *p, Ureg *ureg)
317 
{
318 
	Ureg *cureg;
319 
 
320 
//print("%lud setting up for forking child %lud\n", up->pid, p->pid);
321 
	p->sched.sp = (ulong)p->kstack+KSTACK-sizeof(Ureg);
322 
	p->sched.pc = (ulong)forkret;
323 
 
324 
	cureg = (Ureg*)(p->sched.sp);
325 
	memmove(cureg, ureg, sizeof(Ureg));
326 
 
327 
	/* syscall returns 0 for child */
328 
	cureg->r0 = 0;
329 
 
330 
	/* Things from bottom of syscall which were never executed */
331 
	p->psstate = 0;
332 
	p->insyscall = 0;
333 
 
334 
	fpusysrforkchild(p, cureg, up);
335 
}