/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/* ONC_PLUS EXTRACT START */

/*

 * Use is subject to license terms.

 */

/*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/* ONC_PLUS EXTRACT END */

#pragma ident	"%Z%%M%	%I%	%E% SMI"	/* SVr4.0 1.51	*/

#include <sys/param.h>

#include <sys/types.h>

#include <sys/systm.h>

#include <sys/systrace.h>

#include <sys/procfs.h>

/* ONC_PLUS EXTRACT START */

/*

 * This table is the switch used to transfer to the appropriate

 * routine for processing a system call.  Each row contains the

 * number of arguments expected, a switch that tells systrap()

 * in trap.c whether a setjmp() is not necessary, and a pointer

 * to the routine.

 */

/* ONC_PLUS EXTRACT END */

int	access();

int	alarm();

int	auditsys();

int64_t	brandsys();

int	brk();

int	chdir();

int	chmod();

int	chown();

int	chroot();

int	cladm();

int	close();

int	creat();

int	dup();

int	exec();

int	exece();

int	fcntl();

int64_t	forkall();

int64_t	vfork();

int64_t	forksys();

int64_t	fork1();

int	fstat();

int	fsat32();

int	fdsync();

int64_t	getgid();

int	ucredsys();

int64_t	getpid();

int64_t	getuid();

time_t	gtime();

int	getloadavg();

int	rusagesys();

int	getpagesizes();

int	gtty();

#if defined(__i386) || defined(__amd64)

int	hrtsys();

#endif /* __i386 || __amd64 */

int	ioctl();

int	issetugid();

int	kill();

int	labelsys();

int	link();

off32_t	lseek32();

off_t	lseek64();

int	lgrpsys();

int	mknod();

int	mount();

int	nice();

int	nullsys();

int	open();

int	pause();

long	pcsample();

int	privsys();

int	profil();

ssize_t	pread();

ssize_t	pwrite();

ssize_t	read();

int	rename();

void	rexit();

int	semsys();

int	setgid();

int	setpgrp();

int	setuid();

uintptr_t	shmsys();

int	ssig();

int	sigprocmask();

int	sigsuspend();

int	sigaltstack();

int	sigaction();

int	sigpending();

int	sigtimedwait();

int	getsetcontext();

int	stat();

int	stime();

int	stty();

int	syssync();

int	sysacct();

clock_t	times();

long	ulimit();

int	getrlimit32();

int	setrlimit32();

int	umask();

int	umount();

int	umount2();

int	unlink();

int	utime();

int64_t	utssys32();

int64_t	utssys64();

int	uucopy();

ssize_t	uucopystr();

int64_t	wait();

ssize_t	write();

ssize_t	readv();

ssize_t	writev();

int	syslwp_park();

int	rmdir();

int	mkdir();

int	getdents32();

int	statfs32();

int	fstatfs32();

int	sysfs();

int	getmsg();

int	poll();

int	pollsys();

int	putmsg();

int	uadmin();

int	lstat();

int	symlink();

ssize_t	readlink();

int	resolvepath();

int	setgroups();

int	getgroups();

int	fchdir();

int	fchown();

int	fchmod();

int	getcwd();

int	statvfs();

int	fstatvfs();

offset_t llseek32();

#if (defined(__i386) && !defined(__amd64)) || defined(__i386_COMPAT)

int	sysi86();

#endif

int	acl();

int	facl();

long	priocntlsys();

int	waitsys();

int	sigsendsys();

int	mincore();

caddr_t	smmap64();

caddr_t smmap32();

int	smmaplf32();

int	mprotect();

int	munmap();

#if (defined(__i386) && !defined(__amd64)) || defined(__i386_COMPAT)

int	xstat();

int	lxstat();

int	fxstat();

int	xmknod();

#endif

int	uname();

int	lchown();

int	getpmsg();

int	putpmsg();

int	memcntl();

long	sysconfig();

int	adjtime();

long	systeminfo();

int	setegid();

int	seteuid();

int	setreuid();

int	setregid();

int	install_utrap();

#ifdef __sparc

int	sparc_utrap_install();

#endif

int	syslwp_create();

void	syslwp_exit();

int	syslwp_suspend();

int	syslwp_continue();

int	syslwp_private();

int	lwp_detach();

int	lwp_info();

int	lwp_kill();

int	lwp_self();

int64_t	lwp_sigmask();

int	yield();

int	lwp_wait();

int	lwp_mutex_lock();

int	lwp_mutex_timedlock();

int	lwp_mutex_wakeup();

int	lwp_mutex_unlock();

int	lwp_mutex_trylock();

int	lwp_mutex_init();

int	lwp_rwlock_sys();

int	lwp_sema_post();

int	lwp_sema_wait();

int	lwp_sema_timedwait();

int	lwp_sema_trywait();

int	lwp_cond_wait();

int	lwp_cond_signal();

int	lwp_cond_broadcast();

caddr_t	schedctl();

long	pathconf();

long	fpathconf();

int	processor_bind();

int	processor_info();

int	p_online();

/*

 *	POSIX .4 system calls *

 */

int	clock_gettime();

int	clock_settime();

int	clock_getres();

int	timer_create();

int	timer_delete();

int	timer_settime();

int	timer_gettime();

int	timer_getoverrun();

int	nanosleep();

int	sigqueue();

int	signotify();

int	getdents64();

int	stat64();

int	fsat64();

int	lstat64();

int	fstatat64();

int	fstat64();

int	statvfs64();

int	fstatvfs64();

int	setrlimit64();

int	getrlimit64();

int	pread64();

int	pwrite64();

int	creat64();

int	open64();

/*

 * NTP syscalls

 */

int ntp_gettime();

int ntp_adjtime();

/*

 *	++++++++++++++++++++++++

 *	++  SunOS4.1 Buyback  ++

 *	++++++++++++++++++++++++

 *

 *	fchroot, utimes, vhangup, gettimeofday

 */

int	fchroot();

int	utimes();

int	vhangup();

int	gettimeofday();

int	getitimer();

int	setitimer();

int	corectl();

int	modctl();

int64_t loadable_syscall();

int64_t indir();

long	tasksys();

long	rctlsys();

long	zone();

int	so_socket();

int	so_socketpair();

int	bind();

int	listen();

int	accept();

int	connect();

int	shutdown();

ssize_t	recv();

ssize_t	recvfrom();

ssize_t	recvmsg();

ssize_t	send();

ssize_t	sendmsg();

ssize_t	sendto();

int	getpeername();

int	getsockname();

int	getsockopt();

int	setsockopt();

int	sockconfig();

ssize_t	sendfilev();

typedef int64_t	(*llfcn_t)();	/* for casting one-word returns */

/*

 * Sysent initialization macros.

 * 	These take the name string of the system call even though that isn't

 *	currently used in the sysent entry.  This might be useful someday.

 *

 * Initialization macro for system calls which take their args in the C style.

 * These system calls return the longlong_t return value and must call

 * set_errno() to return an error.  For SPARC, narg must be at most six.

 * For more args, use the SYSENT_AP() routine.

 *

 * We are able to return two distinct values to userland via the rval_t.

 * At this time, that corresponds to one 64-bit quantity, or two 32-bit

 * quantities.  The kernel does not currently need to return two 64-bit

 * values, or one 128 bit value(!), but we may do one day, so the calling

 * sequence between userland and the kernel should permit it.

 *

 * The interpretation of rval_t is provided by the sy_flags field

 * which is used to determine how to arrange the results in registers

 * (or on the stack) for return userland.

 */

	/* returns a 64-bit quantity for both ABIs */

#define	SYSENT_C(name, call, narg)	\

	{ (narg), SE_64RVAL, NULL, NULL, (llfcn_t)(call) }

	/* returns one 32-bit value for both ABIs: r_val1 */

#define	SYSENT_CI(name, call, narg)	\

	{ (narg), SE_32RVAL1, NULL, NULL, (llfcn_t)(call) }

	/* returns 2 32-bit values: r_val1 & r_val2 */

#define	SYSENT_2CI(name, call, narg)	\

	{ (narg), SE_32RVAL1|SE_32RVAL2, NULL, NULL, (llfcn_t)(call) }

/*

 * Initialization macro for system calls which take their args in the standard

 * Unix style of a pointer to the arg structure and a pointer to the rval_t.

 *

 * Deprecated wherever possible (slower on some architectures, and trickier

 * to maintain two flavours).

 */

#define	SYSENT_AP(name, call, narg)	\

	{ (narg), SE_64RVAL, (call), NULL, syscall_ap }

/*

 * Conditional constructors to build the tables without #ifdef clutter

 */

#if defined(_LP64)

#define	IF_LP64(true, false)	true

#else

#define	IF_LP64(true, false)	false

#endif

#if defined(__sparc)

#define	IF_sparc(true, false)	true

#else

#define	IF_sparc(true, false)	false

#endif

#if defined(__i386) && !defined(__amd64)

#define	IF_i386(true, false)	true

#else

#define	IF_i386(true, false)	false

#endif

#if defined(__i386) || defined(__amd64)

#define	IF_x86(true, false)	true

#else

#define	IF_x86(true, false)	false

#endif

#if (defined(__i386) && !defined(__amd64)) || defined(__i386_COMPAT)

#define	IF_386_ABI(true, false)	true

#else

#define	IF_386_ABI(true, false)	false

#endif

/*

 * Define system calls that return a native 'long' quantity i.e. a 32-bit

 * or 64-bit integer - depending on how the kernel is itself compiled

 * e.g. read(2) returns 'ssize_t' in the kernel and in userland.

 */

#define	SYSENT_CL(name, call, narg)	\

	IF_LP64(SYSENT_C(name, call, narg), SYSENT_CI(name, call, narg))

/*

 * Initialization macro for loadable native system calls.

 */

#define	SYSENT_LOADABLE()	\

	{ 0, SE_LOADABLE, (int (*)())nosys, NULL, loadable_syscall }

/* ONC_PLUS EXTRACT END */

/*

 * Initialization macro for loadable 32-bit compatibility system calls.

 */

#define	SYSENT_LOADABLE32()	SYSENT_LOADABLE()

#define	SYSENT_NOSYS()		SYSENT_C("nosys", nosys, 0)

struct sysent nosys_ent = SYSENT_NOSYS();

/* ONC_PLUS EXTRACT START */

/*

 * Native sysent table.

 */

struct sysent sysent[NSYSCALL] =

{

/* ONC_PLUS EXTRACT END */

	/*  0 */ IF_LP64(

			SYSENT_NOSYS(),

			SYSENT_C("indir",	indir,		1)),

	/*  1 */ SYSENT_CI("exit",		rexit,		1),

	/*  2 */ SYSENT_2CI("forkall",		forkall,	0),

	/*  3 */ SYSENT_CL("read",		read,		3),

	/*  4 */ SYSENT_CL("write",		write,		3),

	/*  5 */ SYSENT_CI("open",		open,		3),

	/*  6 */ SYSENT_CI("close",		close,		1),

	/*  7 */ SYSENT_2CI("wait",		wait,		0),

	/*  8 */ SYSENT_CI("creat",		creat,		2),

	/*  9 */ SYSENT_CI("link",		link,		2),

	/* 10 */ SYSENT_CI("unlink",		unlink,		1),

	/* 11 */ SYSENT_CI("exec",		exec,		2),

	/* 12 */ SYSENT_CI("chdir",		chdir,		1),

	/* 13 */ SYSENT_CL("time",		gtime,		0),

	/* 14 */ SYSENT_CI("mknod",		mknod,		3),

	/* 15 */ SYSENT_CI("chmod",		chmod,		2),

	/* 16 */ SYSENT_CI("chown",		chown,		3),

	/* 17 */ SYSENT_CI("brk",		brk,		1),

	/* 18 */ SYSENT_CI("stat",		stat,		2),

	/* 19 */ IF_LP64(

			SYSENT_CL("lseek",	lseek64,	3),

			SYSENT_CL("lseek",	lseek32,	3)),

	/* 20 */ SYSENT_2CI("getpid",		getpid,		0),

	/* 21 */ SYSENT_AP("mount",		mount,		8),

	/* 22 */ SYSENT_CI("umount",		umount,		1),

	/* 23 */ SYSENT_CI("setuid",		setuid,		1),

	/* 24 */ SYSENT_2CI("getuid",		getuid,		0),

	/* 25 */ SYSENT_CI("stime",		stime,		1),

	/* 26 */ SYSENT_CL("pcsample",		pcsample,	2),

	/* 27 */ SYSENT_CI("alarm",		alarm,		1),

	/* 28 */ SYSENT_CI("fstat",		fstat,		2),

	/* 29 */ SYSENT_CI("pause",		pause,		0),

	/* 30 */ SYSENT_CI("utime",		utime,		2),

	/* 31 */ SYSENT_CI("stty",		stty,		2),

	/* 32 */ SYSENT_CI("gtty",		gtty,		2),

	/* 33 */ SYSENT_CI("access",		access,		2),

	/* 34 */ SYSENT_CI("nice",		nice,		1),

	/* 35 */ IF_LP64(

			SYSENT_NOSYS(),

			SYSENT_CI("statfs",	statfs32,	4)),

	/* 36 */ SYSENT_CI("sync",		syssync,	0),

	/* 37 */ SYSENT_CI("kill",		kill,		2),

	/* 38 */ IF_LP64(

			SYSENT_NOSYS(),

			SYSENT_CI("fstatfs",	fstatfs32,	4)),

	/* 39 */ SYSENT_CI("setpgrp",		setpgrp,	3),

	/* 40 */ SYSENT_CI("uucopystr",		uucopystr,	3),

	/* 41 */ SYSENT_CI("dup",		dup,		1),

	/* 42 */ SYSENT_LOADABLE(),			/* pipe */

	/* 43 */ SYSENT_CL("times",		times,		1),

	/* 44 */ SYSENT_CI("prof",		profil,		4),

	/* 45 */ SYSENT_LOADABLE(),			/* (was proc lock) */

	/* 46 */ SYSENT_CI("setgid",		setgid,		1),

	/* 47 */ SYSENT_2CI("getgid",		getgid,		0),

	/* 48 */ SYSENT_CI("sig",		ssig,		2),

	/* 49 */ SYSENT_LOADABLE(),			/* msgsys */

	/* 50 */ IF_x86(

			SYSENT_CI("sysi86",	sysi86,		4),

			SYSENT_LOADABLE()),		/* (was sys3b) */

	/* 51 */ SYSENT_LOADABLE(),			/* sysacct */

	/* 52 */ SYSENT_LOADABLE(),			/* shmsys */

	/* 53 */ SYSENT_LOADABLE(),			/* semsys */

	/* 54 */ SYSENT_CI("ioctl",		ioctl,		3),

	/* 55 */ SYSENT_CI("uadmin",		uadmin,		3),

	/* 56 */ SYSENT_LOADABLE(),

	/* 57 */ IF_LP64(

			SYSENT_2CI("utssys",	utssys64,	4),

			SYSENT_2CI("utssys",	utssys32,	4)),

	/* 58 */ SYSENT_CI("fdsync",		fdsync,		2),

	/* 59 */ SYSENT_CI("exece",		exece,		3),

	/* 60 */ SYSENT_CI("umask",		umask,		1),

	/* 61 */ SYSENT_CI("chroot",		chroot,		1),

	/* 62 */ SYSENT_CI("fcntl",		fcntl,		3),

	/* 63 */ SYSENT_CI("ulimit",		ulimit,		2),

	/*

	 * The following 6 entries were reserved for the UNIX PC.

	 */

	/* 64 */ SYSENT_LOADABLE(),

	/* 65 */ SYSENT_LOADABLE(),

	/* 66 */ SYSENT_LOADABLE(),

	/* 67 */ SYSENT_LOADABLE(),		/* file locking call */

	/* 68 */ SYSENT_LOADABLE(),		/* local system calls */

	/* 69 */ SYSENT_LOADABLE(),		/* inode open */

	/* 70 */ SYSENT_CI("tasksys",		tasksys,	5),

	/* 71 */ SYSENT_LOADABLE(),		/* acctctl */

	/* 72 */ SYSENT_LOADABLE(),		/* exacct */

	/* 73 */ SYSENT_CI("getpagesizes",	getpagesizes,	2),

	/* 74 */ SYSENT_CI("rctlsys",		rctlsys,	6),

	/* 75 */ SYSENT_CI("issetugid",		issetugid,	0),

	/* 76 */ IF_LP64(

			SYSENT_CI("fsat",	fsat64,		6),