[apple/xnu.git] / osfmk / ppc / bsd_ppc.c

/*
 * Copyright (c) 2000-2001 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
#include <mach/mach_types.h>
#include <mach/exception_types.h>
#include <mach/error.h>
#include <kern/counters.h>
#include <kern/syscall_sw.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <ppc/thread.h>
#include <kern/thread_act.h>
#include <ppc/thread_act.h>
#include <ppc/asm.h>
#include <ppc/proc_reg.h>
#include <ppc/trap.h>
#include <ppc/exception.h>
#include <kern/assert.h>

#include <sys/syscall.h>
#include <sys/ktrace.h>
#include <sys/kdebug.h>
struct proc;

#define	ERESTART	-1		/* restart syscall */
#define	EJUSTRETURN	-2		/* don't modify regs, just return */

struct unix_syscallargs {
	int flavor;
	int r3;
	int arg1, arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
};
struct sysent {		/* system call table */
	unsigned short		sy_narg;		/* number of args */
	char			sy_parallel;	/* can execute in parallel */
	char			sy_funnel;	/* funnel type */
	unsigned long		(*sy_call)(void *, void *, int *);	/* implementing function */
};

#define KERNEL_FUNNEL 1
#define NETWORK_FUNNEL 2

extern funnel_t * kernel_flock;
extern funnel_t * network_flock;

extern struct sysent sysent[];

void  *get_bsdtask_info(
	task_t);

int set_bsduthreadargs (
	thread_act_t, struct pcb *, 
	struct unix_syscallargs  *);

void * get_bsduthreadarg(
	thread_act_t);

void
unix_syscall(
	struct pcb * pcb,
    int, int, int, int, int, int, int );

/*
 * Function:	unix_syscall
 *
 * Inputs:	pcb	- pointer to Process Control Block
 *		arg1	- arguments to mach system calls
 *		arg2
 *		arg3
 *		arg4
 *		arg5
 *		arg6
 *		arg7
 *
 * Outputs:	none
 */
void
unix_syscall(
    struct pcb * pcb,
    int arg1,
    int arg2,
    int arg3,
    int arg4,
    int arg5,
    int arg6,
    int arg7 
    )
{
	struct ppc_saved_state	*regs;
	thread_act_t		thread;
	struct sysent		*callp;
	int				nargs, error;
	unsigned short		code;
	struct proc *p;
	void *vt;
	int * vtint;
	int *rval;
	int funnel_type;
	struct proc *current_proc();

	struct unix_syscallargs sarg;
	extern int nsysent;

	regs = &pcb->ss;
	code = regs->r0;

	thread = current_act();
	p = current_proc();
	rval = (int *)get_bsduthreadrval(thread);

	/*
	 * Set up call pointer
	 */
	callp = (code >= nsysent) ? &sysent[63] : &sysent[code];

	sarg. flavor = (callp == sysent)? 1: 0;
	if (sarg.flavor) {
		code = regs->r3;
		callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
	} else 
		sarg. r3 = regs->r3;

	if (code != 180) {
		if (sarg.flavor)
			KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_START,
				arg1, arg2, arg3, arg4, 0);
		else
			KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_START,
				sarg.r3, arg1, arg2, arg3, 0);
	}
	sarg.arg1 = arg1;
	sarg.arg2 = arg2;
	sarg.arg3 = arg3;
	sarg.arg4 = arg4;
	sarg.arg5 = arg5;
	sarg.arg6 = arg6;
	sarg.arg7 = arg7;

	if(callp->sy_funnel == NETWORK_FUNNEL) {
		(void) thread_funnel_set(network_flock, TRUE);
	} else {
		(void) thread_funnel_set(kernel_flock, TRUE);
	}

	set_bsduthreadargs(thread,pcb,&sarg);

	if (callp->sy_narg > 8)
		panic("unix_syscall: max arg count exceeded");

	rval[0] = 0;

	/*
	 * r4 is volatile, if we set it to regs->r4 here the child
	 * will have parents r4 after execve
	 */
	rval[1] = 0;

	error = 0; /* Start with a good value */

	/*
	** the PPC runtime calls cerror after every unix system call, so
	** assume no error and adjust the "pc" to skip this call.
	** It will be set back to the cerror call if an error is detected.
	*/
	regs->srr0 += 4;
	vt = get_bsduthreadarg(thread);
	counter_always(c_syscalls_unix++);
	current_task()->syscalls_unix++;

	ktrsyscall(p, code, callp->sy_narg, vt);

	error = (*(callp->sy_call))(p, (void *)vt, rval);

	regs = find_user_regs(thread);
	if (regs == (struct ppc_saved_state  *)0)
		panic("No user savearea while returning from system call");

	if (error == ERESTART) {
		regs->srr0 -= 8;
	} else if (error != EJUSTRETURN) {
		if (error) {
			regs->r3 = error;
			/* set the "pc" to execute cerror routine */
			regs->srr0 -= 4;
		} else { /* (not error) */
			regs->r3 = rval[0];
			regs->r4 = rval[1];
		} 
	}
	/* else  (error == EJUSTRETURN) { nothing } */

	ktrsysret(p, code, error, rval[0]);

	(void) thread_funnel_set(current_thread()->funnel_lock, FALSE);

	if (code != 180) {
		KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END,
			error, rval[0], rval[1], 0, 0);
	}

	thread_exception_return();
	/* NOTREACHED */
}

unix_syscall_return(error)
{
	struct ppc_saved_state	*regs;
	thread_act_t		thread;
	struct sysent		*callp;
	int				nargs;
	unsigned short		code;
	int *rval;
	struct proc *p;
	void *vt;
	int * vtint;
	struct pcb *pcb;
	struct proc *current_proc();

	struct unix_syscallargs sarg;
	extern int nsysent;

	thread = current_act();
	p = current_proc();
	rval = (int *)get_bsduthreadrval(thread);
	pcb = thread->mact.pcb;
	regs = &pcb->ss;

	if (thread_funnel_get() == THR_FUNNEL_NULL)
		panic("Unix syscall return without funnel held");

	/*
	 * Get index into sysent table
	 */   
	code = regs->r0;

	if (error == ERESTART) {
		regs->srr0 -= 8;
	} else if (error != EJUSTRETURN) {
		if (error) {
			regs->r3 = error;
			/* set the "pc" to execute cerror routine */
			regs->srr0 -= 4;
		} else { /* (not error) */
			regs->r3 = rval[0];
			regs->r4 = rval[1];
		} 
	}
	/* else  (error == EJUSTRETURN) { nothing } */

	ktrsysret(p, code, error, rval[0]);

	(void) thread_funnel_set(current_thread()->funnel_lock, FALSE);

	if (code != 180) {
		KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) | DBG_FUNC_END,
			error, rval[0], rval[1], 0, 0);
	}

	thread_exception_return();
	/* NOTREACHED */
}
Commit	Line	Data
1c79356b	1	/*
9bccf70c	2	* Copyright (c) 2000-2001 Apple Computer, Inc. All rights reserved.
1c79356b A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
	11	*
	12	* This Original Code and all software distributed under the License are
	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
	22	#include <mach/mach_types.h>
	23	#include <mach/exception_types.h>
	24	#include <mach/error.h>
	25	#include <kern/counters.h>
	26	#include <kern/syscall_sw.h>
	27	#include <kern/task.h>
	28	#include <kern/thread.h>
	29	#include <ppc/thread.h>
	30	#include <kern/thread_act.h>
	31	#include <ppc/thread_act.h>
	32	#include <ppc/asm.h>
	33	#include <ppc/proc_reg.h>
	34	#include <ppc/trap.h>
	35	#include <ppc/exception.h>
	36	#include <kern/assert.h>
	37
9bccf70c A	38	#include <sys/syscall.h>
9bccf70c A	39	#include <sys/ktrace.h>
1c79356b	40	#include <sys/kdebug.h>
9bccf70c	41	struct proc;
1c79356b A	42
	43	#define ERESTART -1 /* restart syscall */
	44	#define EJUSTRETURN -2 /* don't modify regs, just return */
	45
	46	struct unix_syscallargs {
	47	int flavor;
	48	int r3;
	49	int arg1, arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9;
	50	};
	51	struct sysent { /* system call table */
	52	unsigned short sy_narg; /* number of args */
	53	char sy_parallel; /* can execute in parallel */
9bccf70c	54	char sy_funnel; /* funnel type */
1c79356b A	55	unsigned long (sy_call)(void , void , int ); /* implementing function */
	56	};
	57
	58	#define KERNEL_FUNNEL 1
	59	#define NETWORK_FUNNEL 2
	60
	61	extern funnel_t * kernel_flock;
	62	extern funnel_t * network_flock;
	63
	64	extern struct sysent sysent[];
	65
	66	void *get_bsdtask_info(
	67	task_t);
	68
	69	int set_bsduthreadargs (
	70	thread_act_t, struct pcb *,
	71	struct unix_syscallargs *);
	72
	73	void * get_bsduthreadarg(
	74	thread_act_t);
	75
	76	void
	77	unix_syscall(
	78	struct pcb * pcb,
	79	int, int, int, int, int, int, int );
	80
	81	/*
	82	* Function: unix_syscall
	83	*
	84	* Inputs: pcb - pointer to Process Control Block
	85	* arg1 - arguments to mach system calls
	86	* arg2
	87	* arg3
	88	* arg4
	89	* arg5
	90	* arg6
	91	* arg7
	92	*
	93	* Outputs: none
	94	*/
	95	void
	96	unix_syscall(
	97	struct pcb * pcb,
	98	int arg1,
	99	int arg2,
	100	int arg3,
	101	int arg4,
	102	int arg5,
	103	int arg6,
	104	int arg7
	105	)
	106	{
9bccf70c A	107	struct ppc_saved_state *regs;
	108	thread_act_t thread;
	109	struct sysent *callp;
	110	int nargs, error;
	111	unsigned short code;
	112	struct proc *p;
	113	void *vt;
	114	int * vtint;
1c79356b	115	int *rval;
9bccf70c A	116	int funnel_type;
9bccf70c A	117	struct proc *current_proc();
1c79356b A	118
	119	struct unix_syscallargs sarg;
	120	extern int nsysent;
	121
9bccf70c A	122	regs = &pcb->ss;
9bccf70c A	123	code = regs->r0;
1c79356b	124
9bccf70c	125	thread = current_act();
0b4e3aa0	126	p = current_proc();
1c79356b A	127	rval = (int *)get_bsduthreadrval(thread);
1c79356b A	128
1c79356b	129	/*
9bccf70c A	130	* Set up call pointer
9bccf70c A	131	*/
1c79356b A	132	callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
	133
	134	sarg. flavor = (callp == sysent)? 1: 0;
	135	if (sarg.flavor) {
9bccf70c A	136	code = regs->r3;
	137	callp = (code >= nsysent) ? &sysent[63] : &sysent[code];
	138	} else
1c79356b A	139	sarg. r3 = regs->r3;
	140
	141	if (code != 180) {
9bccf70c A	142	if (sarg.flavor)
	143	KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) \| DBG_FUNC_START,
	144	arg1, arg2, arg3, arg4, 0);
1c79356b	145	else
9bccf70c A	146	KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) \| DBG_FUNC_START,
	147	sarg.r3, arg1, arg2, arg3, 0);
	148	}
	149	sarg.arg1 = arg1;
	150	sarg.arg2 = arg2;
	151	sarg.arg3 = arg3;
	152	sarg.arg4 = arg4;
	153	sarg.arg5 = arg5;
	154	sarg.arg6 = arg6;
	155	sarg.arg7 = arg7;
	156
	157	if(callp->sy_funnel == NETWORK_FUNNEL) {
	158	(void) thread_funnel_set(network_flock, TRUE);
	159	} else {
	160	(void) thread_funnel_set(kernel_flock, TRUE);
1c79356b	161	}
1c79356b A	162
	163	set_bsduthreadargs(thread,pcb,&sarg);
	164
1c79356b	165	if (callp->sy_narg > 8)
9bccf70c	166	panic("unix_syscall: max arg count exceeded");
1c79356b A	167
	168	rval[0] = 0;
	169
9bccf70c A	170	/*
	171	* r4 is volatile, if we set it to regs->r4 here the child
	172	* will have parents r4 after execve
	173	*/
1c79356b A	174	rval[1] = 0;
	175
	176	error = 0; /* Start with a good value */
	177
	178	/*
	179	** the PPC runtime calls cerror after every unix system call, so
	180	** assume no error and adjust the "pc" to skip this call.
	181	** It will be set back to the cerror call if an error is detected.
	182	*/
	183	regs->srr0 += 4;
	184	vt = get_bsduthreadarg(thread);
	185	counter_always(c_syscalls_unix++);
	186	current_task()->syscalls_unix++;
9bccf70c A	187
	188	ktrsyscall(p, code, callp->sy_narg, vt);
	189
1c79356b A	190	error = ((callp->sy_call))(p, (void )vt, rval);
1c79356b A	191
0b4e3aa0 A	192	regs = find_user_regs(thread);
	193	if (regs == (struct ppc_saved_state *)0)
	194	panic("No user savearea while returning from system call");
	195
9bccf70c A	196	if (error == ERESTART) {
	197	regs->srr0 -= 8;
	198	} else if (error != EJUSTRETURN) {
	199	if (error) {
	200	regs->r3 = error;
	201	/* set the "pc" to execute cerror routine */
	202	regs->srr0 -= 4;
	203	} else { /* (not error) */
	204	regs->r3 = rval[0];
	205	regs->r4 = rval[1];
	206	}
	207	}
	208	/* else (error == EJUSTRETURN) { nothing } */
	209
	210	ktrsysret(p, code, error, rval[0]);
	211
	212	(void) thread_funnel_set(current_thread()->funnel_lock, FALSE);
	213
	214	if (code != 180) {
	215	KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) \| DBG_FUNC_END,
	216	error, rval[0], rval[1], 0, 0);
	217	}
	218
	219	thread_exception_return();
	220	/* NOTREACHED */
1c79356b A	221	}
	222
	223	unix_syscall_return(error)
	224	{
9bccf70c A	225	struct ppc_saved_state *regs;
	226	thread_act_t thread;
	227	struct sysent *callp;
	228	int nargs;
	229	unsigned short code;
1c79356b	230	int *rval;
9bccf70c A	231	struct proc *p;
	232	void *vt;
	233	int * vtint;
1c79356b	234	struct pcb *pcb;
9bccf70c	235	struct proc *current_proc();
1c79356b A	236
	237	struct unix_syscallargs sarg;
	238	extern int nsysent;
	239
9bccf70c	240	thread = current_act();
0b4e3aa0	241	p = current_proc();
1c79356b A	242	rval = (int *)get_bsduthreadrval(thread);
1c79356b A	243	pcb = thread->mact.pcb;
9bccf70c A	244	regs = &pcb->ss;
	245
	246	if (thread_funnel_get() == THR_FUNNEL_NULL)
	247	panic("Unix syscall return without funnel held");
	248
	249	/*
	250	* Get index into sysent table
	251	*/
	252	code = regs->r0;
	253
	254	if (error == ERESTART) {
	255	regs->srr0 -= 8;
	256	} else if (error != EJUSTRETURN) {
	257	if (error) {
	258	regs->r3 = error;
	259	/* set the "pc" to execute cerror routine */
	260	regs->srr0 -= 4;
	261	} else { /* (not error) */
	262	regs->r3 = rval[0];
	263	regs->r4 = rval[1];
	264	}
	265	}
	266	/* else (error == EJUSTRETURN) { nothing } */
	267
	268	ktrsysret(p, code, error, rval[0]);
	269
	270	(void) thread_funnel_set(current_thread()->funnel_lock, FALSE);
	271
	272	if (code != 180) {
	273	KERNEL_DEBUG_CONSTANT(BSDDBG_CODE(DBG_BSD_EXCP_SC, code) \| DBG_FUNC_END,
	274	error, rval[0], rval[1], 0, 0);
	275	}
	276
	277	thread_exception_return();
	278	/* NOTREACHED */
1c79356b A	279	}
1c79356b A	280