![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to systemcalls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / machdep / ppc|
Return to systemcalls.c CVS log | Up to [Apple Darwin 0.x] / kernel / machdep / ppc |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*
26: * Copyright (c) 1997 Apple Computer, Inc.
27: *
28: * PowerPC Family: System Call handlers.
29: *
30: * HISTORY
31: * 18-Aug-97 Umesh Vaishampayan ([email protected])
32: * Added syscalltrace filtering.
33: * 27-July-97 Umesh Vaishampayan ([email protected])
34: * Debug printf() changed to kprintf(). Cleanup unused system timing.
35: */
36:
37: #include <mach/mach_types.h>
38: #include <mach/exception.h>
39: #include <mach/error.h>
40:
41: #include <kern/syscall_sw.h>
42: #include <kern/kdp.h>
43: #include <kern/kdebug.h>
44:
45: #include <machdep/ppc/frame.h>
46: #include <machdep/ppc/thread.h>
47: #include <machdep/ppc/asm.h>
48: #include <machdep/ppc/proc_reg.h>
49: #include <machdep/ppc/trap.h>
50: #include <machdep/ppc/exception.h>
51: #include <machdep/ppc/pcb_flags.h>
52:
53: #include <sys/param.h>
54: #include <sys/proc.h>
55: #include <sys/user.h>
56: #include <sys/systm.h>
57:
58: #if DIAGNOSTIC
59: /* syscalltrace defines */
60: #define _SCT_NUM_PIDS 8
61:
62: #define _SCT_OFF 0x00
63: #define _SCT_MACHCALLS 0x01
64: #define _SCT_UNIXCALLS 0x02
65: #define _SCT_ALL (_SCT_MACHCALLS | _SCT_UNIXCALLS)
66:
67: int syscalltrace = 0;
68: int usepids = 0; /* 1 enables pid filtering */
69: int pidstraced[_SCT_NUM_PIDS]; /* can specify upto _SCT_NUM_PIDS to filter */
70:
71: static int
72: matchpid( int pid )
73: {
74: int i;
75: for(i=0; i<_SCT_NUM_PIDS; i++)
76: if( pidstraced[i] == pid )
77: return 1; /* match! */
78: return 0; /* not found */
79: }
80:
81: #endif /* DIAGNOSTIC */
82:
83: /*
84: ** Function: mach_syscall
85: **
86: ** Inputs: pcb - pointer to Process Control Block
87: ** arg1 - arguments to mach system calls
88: ** arg2
89: ** arg3
90: ** arg4
91: ** arg5
92: ** arg6
93: ** arg7
94: **
95: ** Outputs: none
96: **
97: ** Notes: There may be additional arguments to the mach calls
98: ** that will be read in from user space if necessary
99: */
100: void
101: mach_syscall(
102: struct pcb * pcb,
103: int arg1,
104: int arg2,
105: int arg3,
106: int arg4,
107: int arg5,
108: int arg6,
109: int arg7
110: )
111: {
112: struct ppc_saved_state *regs;
113: int error; /* error code */
114: struct uthread *uthread;
115: struct proc *p;
116:
117: /* the mach trap number supplied by libmach */
118: int mach_trap;
119: mach_trap_t *trapp;
120: thread_t thread;
121: int arg0;
122: struct stack_frame *usfp;
123: int sbargs[4], uasfp, *argp;
124: extern char *mach_callnames[];
125:
126:
127: if (!USERMODE(pcb->ss.srr1))
128: panic("mach_syscall");
129:
130: regs = &pcb->ss;
131:
132: thread = current_thread();
133: uthread = thread->_uthread;
134: uthread->uu_ar0 = (int *)pcb;
135: p = current_proc();
136:
137: /* get the mach trap number */
138: mach_trap = -(regs->r0);
139:
140: /* get the first argument to the mach trap call */
141: arg0 = regs->r3;
142:
143: error = 0;
144:
145: /* find mach trap table entry */
146: if (mach_trap >= mach_trap_count || mach_trap < 0)
147: {
148: error = KERN_FAILURE;
149: }
150: else
151: {
152: trapp = &mach_trap_table[mach_trap];
153:
154: if (trapp->mach_trap_arg_count > MAXREGARGS)
155: {
156: int i, word;
157:
158: /*
159: ** This code gets executed when there are more than MAXREGARGS
160: ** worth of parameters expected for the call. The additional
161: ** parameters are passed on the users stack and must be copies
162: ** in from user space.
163: */
164: if (trapp->mach_trap_arg_count > NARGS)
165: panic("mach_syscall: max arg count exceeded");
166:
167: /* get the user stack frame pointer from saved state r1 */
168: usfp = (struct stack_frame *)regs->r1;
169:
170: /* set up a pointer to the user arguments stack frame pointer */
171: uasfp = (int)&usfp->pa.spa.saved_p8;
172:
173: /* setup the pointer for the stack based args */
174: argp = sbargs;
175:
176: for (i = 0; i < (trapp->mach_trap_arg_count - MAXREGARGS); i++ )
177: {
178: if (copyin ((void *)uasfp++, (void *)&word, sizeof(int)))
179: {
180: regs->r3 = -1;
181: thread_exception_return();
182: }
183: *argp++ = word;
184: }
185: }
186:
187: #if DIAGNOSTIC
188: if ((syscalltrace == _SCT_MACHCALLS) || (syscalltrace == _SCT_ALL)) {
189: int trpid = ((p) ? p->p_pid : -1);
190: if((!usepids) || (usepids && matchpid(trpid)))
191: kprintf("%s (%d) mach_syscall[%d = %s] --",
192: ((p) ? p->p_comm : "no-proc"),
193: trpid, mach_trap, mach_callnames[mach_trap]);
194: }
195: #endif /* DIAGNOSTIC */
196: /*
197: ** Notice that there are always NARGS passed into the mach_trap
198: ** regardless whether they are needed or not.
199: **
200: ** If NARGS changes this function call must be changed as well!!
201: */
202: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_EXCP_SC, 0) | DBG_FUNC_START,
203: mach_trap, arg0, arg1, arg2, arg3);
204:
205: error = (*(trapp->mach_trap_function))( arg0, arg1,
206: arg2, arg3,
207: arg4, arg5,
208: arg6, arg7,
209: sbargs[0], sbargs[1],
210: sbargs[2], sbargs[3] );
211:
212: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_EXCP_SC, 0) | DBG_FUNC_END,
213: mach_trap, error, 0, 0, 0);
214: #if DIAGNOSTIC
215: if ((syscalltrace == _SCT_MACHCALLS) || (syscalltrace == _SCT_ALL)) {
216: int trpid = ((p) ? p->p_pid : -1);
217: if((!usepids) || (usepids && matchpid(trpid))) {
218: if (error)
219: kprintf("> sys=0x%X, sub=0x%X, code=0x%X\n",
220: err_get_system(error), err_get_sub(error),
221: err_get_code(error));
222: else
223: kprintf("> error == 0x%X\n", error);
224: }
225: }
226: #endif /* DIAGNOSTIC */
227: }
228:
229: regs->r3 = error;
230:
231: thread_exception_return();
232: /* NOTREACHED */
233: }
234:
235:
236: /*
237: ** Function: unix_syscall
238: **
239: ** Inputs: pcb - pointer to Process Control Block
240: ** arg1 - arguments to mach system calls
241: ** arg2
242: ** arg3
243: ** arg4
244: ** arg5
245: ** arg6
246: ** arg7
247: **
248: ** Outputs: none
249: */
250: void
251: unix_syscall(
252: struct pcb * pcb,
253: int arg1,
254: int arg2,
255: int arg3,
256: int arg4,
257: int arg5,
258: int arg6,
259: int arg7
260: )
261: {
262: struct ppc_saved_state *regs;
263: thread_t thread;
264: struct uthread *uthread;
265: struct sysent *callp;
266: struct proc *p;
267: int nargs, error;
268: unsigned short code;
269: int rval[2];
270: extern char *syscallnames[];
271:
272: if (!USERMODE(pcb->ss.srr1))
273: panic("unix_syscall");
274:
275: regs = &pcb->ss;
276: thread = current_thread();
277:
278: uthread = thread->_uthread;
279: uthread->uu_ar0 = (int *)pcb;
280: p = current_proc();
281:
282: /*
283: ** Get index into sysent table
284: */
285: code = regs->r0;
286:
287: if (code > nsysent)
288: {
289: error = 0;
290: switch (code) {
291: case 0x7FFA:
292: if ((thread->pcb->flags & PCB_BB_MASK) == 0) {
293: error = EPERM;
294: break;
295: }
296: NotifyInterruption(regs->r3,arg1,arg2,arg3,arg4,arg5,arg6,arg7);
297: break;
298: case 0x7FFF:
299: mapBlueBoxShmem(regs->r3,arg1,arg2,arg3,arg4,arg5,arg6,arg7);
300: break;
301: case 0x7FFD:
302: unmapBlueBoxShmem(regs->r3,arg1,arg2,arg3,arg4,arg5,arg6,arg7);
303: break;
304: }
305: }
306: else {
307: /*
308: ** Set up call pointer
309: */
310: callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
311:
312: /*
313: ** SPECIAL CASE function 0 to be indirect system call
314: */
315: if (callp == sysent)
316: {
317: code = regs->r3;
318: callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
319: uthread->uu_arg[0] = arg1;
320: uthread->uu_arg[1] = arg2;
321: uthread->uu_arg[2] = arg3;
322: uthread->uu_arg[3] = arg4;
323: uthread->uu_arg[4] = arg5;
324: uthread->uu_arg[5] = arg6;
325: uthread->uu_arg[6] = arg7;
326: }
327: else
328: {
329: /*
330: ** Set up the args for the system call
331: */
332: uthread->uu_arg[0] = regs->r3;
333: uthread->uu_arg[1] = arg1;
334: uthread->uu_arg[2] = arg2;
335: uthread->uu_arg[3] = arg3;
336: uthread->uu_arg[4] = arg4;
337: uthread->uu_arg[5] = arg5;
338: uthread->uu_arg[6] = arg6;
339: uthread->uu_arg[7] = arg7;
340: }
341:
342: if (callp->sy_narg > 8)
343: panic("unix_syscall: max arg count exceeded");
344:
345: rval[0] = 0;
346:
347: /* r4 is volatile, if we set it to regs->r4 here the child
348: * will have parents r4 after execve */
349: rval[1] = 0;
350:
351: error = 0; /* Start with a good value */
352:
353: /*
354: ** the PPC runtime calls cerror after every unix system call, so
355: ** assume no error and adjust the "pc" to skip this call.
356: ** It will be set back to the cerror call if an error is detected.
357: */
358: regs->srr0 += 4;
359: #if DIAGNOSTIC
360: if ((syscalltrace == _SCT_UNIXCALLS) || (syscalltrace == _SCT_ALL)) {
361: int trpid = ((p) ? p->p_pid : -1);
362: if((!usepids) || (usepids && matchpid(trpid))) {
363: kprintf("%s(%d) unix_syscall[%d = %s] --",
364: ((p) ? p->p_comm : "no-proc"),
365: trpid, code, syscallnames[code]);
366: if ( (code == 5) || (code == 59) )
367: kprintf(" arg0 = %x, arg1 = %d, arg2 = %d, "
368: "arg3 = %d --",
369: uthread->uu_arg[0], uthread->uu_arg[1],
370: uthread->uu_arg[2], uthread->uu_arg[3]);
371: }
372: }
373: #endif /* DIAGNOSTIC */
374: #if KDEBUG
375: if (code != 180) {
376: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_EXCP_SC, 1) | DBG_FUNC_START,
377: code, uthread->uu_arg[0], uthread->uu_arg[1],
378: uthread->uu_arg[2], uthread->uu_arg[3]);
379: }
380: #endif /* KDEBUG */
381:
382: error = (*(callp->sy_call))(p, (caddr_t)uthread->uu_arg, rval);
383:
384: #if KDEBUG
385: if (code != 180) {
386: KERNEL_DEBUG(MACHDBG_CODE(DBG_MACH_EXCP_SC, 1) | DBG_FUNC_END,
387: code, error, rval[0], rval[1], 0);
388: }
389: #endif /* KDEBUG */
390: #if DIAGNOSTIC
391: if ((syscalltrace == _SCT_UNIXCALLS) || (syscalltrace == _SCT_ALL)) {
392: int trpid = ((p) ? p->p_pid : -1);
393: if((!usepids) || (usepids && matchpid(trpid)))
394: if (error)
395: kprintf("> error == 0x%X\n", error);
396: else
397: kprintf("> rval=0x%X %X\n", rval[0],rval[1]);
398: }
399: #endif /* DIAGNOSTIC */
400: }
401: if (error == ERESTART) {
402: regs->srr0 -= 8;
403: }
404: else if (error != EJUSTRETURN) {
405: if (error)
406: {
407: regs->r3 = error;
408: /* set the "pc" to execute cerror routine */
409: regs->srr0 -= 4;
410: } else { /* (not error) */
411: regs->r3 = rval[0];
412: regs->r4 = rval[1];
413: }
414: }
415: /* else (error == EJUSTRETURN) { nothing } */
416:
417: thread_exception_return();
418: /* NOTREACHED */
419:
420: }
421:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.