.sv_trap	= NULL,

		if (*p->p_sysent->sv_trap)

			if ((*p->p_sysent->sv_trap)(td, frame) == 0)

				goto userout;

# Makefile for syscall tables

#

# $FreeBSD$

all:

	@echo "make sysent only"

sysent:  linux_sysent.c linux_syscall.h linux_proto.h linux_syscalls.c linux_systrace_args.c

linux_sysent.c linux_syscall.h linux_proto.h linux_syscalls.c linux_systrace_args.c: \

		../../kern/makesyscalls.sh syscalls.master syscalls.conf

	-mv -f linux_sysent.c linux_sysent.c.bak

	-mv -f linux_syscall.h linux_syscall.h.bak

	-mv -f linux_proto.h linux_proto.h.bak

	-mv -f linux_syscalls.c linux_syscalls.c.bak

	-mv -f linux_systrace_args.c linux_systrace_args.c.bak

	sh ../../kern/makesyscalls.sh syscalls.master syscalls.conf

/*-

 * Copyright (c) 2013 Dmitry Chagin

 * Copyright (c) 1994-1996 Søren Schmidt

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * $FreeBSD$

 */

#ifndef _AMD64_LINUX_H_

#define	_AMD64_LINUX_H_

#include <compat/linux/linux.h>

#include <amd64/linux/linux_syscall.h>

/*

 * debugging support

 */

extern u_char linux_debug_map[];

#define	ldebug(name)	isclr(linux_debug_map, LINUX_SYS_linux_ ## name)

#define	ARGS(nm, fmt)	"linux(%ld/%ld): "#nm"("fmt")\n",			\

			(long)td->td_proc->p_pid, (long)td->td_tid

#define	LMSG(fmt)	"linux(%ld/%ld): "fmt"\n",				\

			(long)td->td_proc->p_pid, (long)td->td_tid

#define	LINUX_DTRACE	linuxulator

#define	PTRIN(v)	(void *)(v)

#define	PTROUT(v)	(uintptr_t)(v)

#define	CP(src,dst,fld) do { (dst).fld = (src).fld; } while (0)

#define	CP2(src,dst,sfld,dfld) do { (dst).dfld = (src).sfld; } while (0)

#define	PTRIN_CP(src,dst,fld) \

	do { (dst).fld = PTRIN((src).fld); } while (0)

/*

 * Provide a separate set of types for the Linux types.

 */

typedef int32_t		l_int;

typedef int64_t		l_long;

typedef int16_t		l_short;

typedef uint32_t	l_uint;

typedef uint64_t	l_ulong;

typedef uint16_t	l_ushort;

typedef l_ulong		l_uintptr_t;

typedef l_long		l_clock_t;

typedef l_int		l_daddr_t;

typedef l_ulong		l_dev_t;

typedef l_uint		l_gid_t;

typedef l_uint		l_uid_t;

typedef l_ulong		l_ino_t;

typedef l_int		l_key_t;

typedef l_long		l_loff_t;

typedef l_uint		l_mode_t;

typedef l_long		l_off_t;

typedef l_int		l_pid_t;

typedef l_ulong		l_size_t;

typedef l_long		l_ssize_t;

typedef l_long		l_suseconds_t;

typedef l_long		l_time_t;

typedef l_int		l_timer_t;

typedef l_int		l_mqd_t;

typedef l_size_t	l_socklen_t;

typedef	l_ulong		l_fd_mask;

typedef struct {

	l_int		val[2];

} l_fsid_t;

typedef struct {

	l_time_t	tv_sec;

	l_suseconds_t	tv_usec;

} l_timeval;

#define	l_fd_set	fd_set

/*

 * Miscellaneous

 */

#define	LINUX_NAME_MAX		255

#define	LINUX_CTL_MAXNAME	10

#define LINUX_AT_COUNT		19	/* Count of used aux entry types. */

struct l___sysctl_args

{

	l_uintptr_t	name;

	l_int		nlen;

	l_uintptr_t	oldval;

	l_uintptr_t	oldlenp;

	l_uintptr_t	newval;

	l_size_t	newlen;

	l_ulong		__spare[4];

};

/* Scheduling policies */

#define	LINUX_SCHED_OTHER	0

#define	LINUX_SCHED_FIFO	1

#define	LINUX_SCHED_RR		2

/* Resource limits */

#define	LINUX_RLIMIT_CPU	0

#define	LINUX_RLIMIT_FSIZE	1

#define	LINUX_RLIMIT_DATA	2

#define	LINUX_RLIMIT_STACK	3

#define	LINUX_RLIMIT_CORE	4

#define	LINUX_RLIMIT_RSS	5

#define	LINUX_RLIMIT_NPROC	6

#define	LINUX_RLIMIT_NOFILE	7

#define	LINUX_RLIMIT_MEMLOCK	8

#define	LINUX_RLIMIT_AS		9	/* Address space limit */

#define	LINUX_RLIM_NLIMITS	10

struct l_rlimit {

	l_ulong		rlim_cur;

	l_ulong		rlim_max;

};

/* mmap options */

#define	LINUX_MAP_SHARED	0x0001

#define	LINUX_MAP_PRIVATE	0x0002

#define	LINUX_MAP_FIXED		0x0010

#define	LINUX_MAP_ANON		0x0020

#define	LINUX_MAP_GROWSDOWN	0x0100

/*

 * stat family of syscalls

 */

struct l_timespec {

	l_time_t	tv_sec;

	l_long		tv_nsec;

};

struct l_newstat {

	l_dev_t		st_dev;

	l_ino_t		st_ino;

	l_ulong		st_nlink;

	l_uint		st_mode;

	l_uid_t		st_uid;

	l_gid_t		st_gid;

	l_uint		__st_pad1;

	l_dev_t		st_rdev;

	l_off_t		st_size;

	l_long		st_blksize;

	l_long		st_blocks;

	struct l_timespec	st_atim;

	struct l_timespec	st_mtim;

	struct l_timespec	st_ctim;

	l_long		__unused1;

	l_long		__unused2;

	l_long		__unused3;

};

/* sigaction flags */

#define	LINUX_SA_NOCLDSTOP	0x00000001

#define	LINUX_SA_NOCLDWAIT	0x00000002

#define	LINUX_SA_SIGINFO	0x00000004

#define	LINUX_SA_RESTORER	0x04000000

#define	LINUX_SA_ONSTACK	0x08000000

#define	LINUX_SA_RESTART	0x10000000

#define	LINUX_SA_INTERRUPT	0x20000000

#define	LINUX_SA_NOMASK		0x40000000

#define	LINUX_SA_ONESHOT	0x80000000

/* sigprocmask actions */

#define	LINUX_SIG_BLOCK		0

#define	LINUX_SIG_UNBLOCK	1

#define	LINUX_SIG_SETMASK	2

/* sigaltstack */

#define	LINUX_MINSIGSTKSZ	2048

typedef void	(*l_handler_t)(l_int);

typedef struct {

	l_handler_t	lsa_handler;

	l_ulong		lsa_flags;

	l_uintptr_t	lsa_restorer;

	l_sigset_t	lsa_mask;

} l_sigaction_t;

typedef struct {

	l_uintptr_t	ss_sp;

	l_int		ss_flags;

	l_size_t	ss_size;

} l_stack_t;

struct l_fpstate {

	u_int16_t cwd;

	u_int16_t swd;

	u_int16_t twd;

	u_int16_t fop;

	u_int64_t rip;

	u_int64_t rdp;

	u_int32_t mxcsr;

	u_int32_t mxcsr_mask;

	u_int32_t st_space[32];

	u_int32_t xmm_space[64];

	u_int32_t reserved2[24];

};

struct l_sigcontext {

	l_ulong		sc_r8;

	l_ulong		sc_r9;

	l_ulong		sc_r10;

	l_ulong		sc_r11;

	l_ulong		sc_r12;

	l_ulong		sc_r13;

	l_ulong		sc_r14;

	l_ulong		sc_r15;

	l_ulong		sc_rdi;

	l_ulong		sc_rsi;

	l_ulong		sc_rbp;

	l_ulong		sc_rbx;

	l_ulong		sc_rdx;

	l_ulong		sc_rax;

	l_ulong		sc_rcx;

	l_ulong		sc_rsp;

	l_ulong		sc_rip;

	l_ulong		sc_rflags;

	l_ushort	sc_cs;

	l_ushort	sc_gs;

	l_ushort	sc_fs;

	l_ushort	sc___pad0;

	l_ulong		sc_err;

	l_ulong		sc_trapno;

	l_sigset_t	sc_mask;

	l_ulong		sc_cr2;

	struct l_fpstate *sc_fpstate;

	l_ulong		sc_reserved1[8];

};

struct l_ucontext {

	l_ulong		uc_flags;

	l_uintptr_t	uc_link;

	l_stack_t	uc_stack;

	struct l_sigcontext	uc_mcontext;

	l_sigset_t	uc_sigmask;

};

#define LINUX_SI_PREAMBLE_SIZE	(4 * sizeof(int))

#define	LINUX_SI_MAX_SIZE	128

#define	LINUX_SI_PAD_SIZE	((LINUX_SI_MAX_SIZE - \

				    LINUX_SI_PREAMBLE_SIZE) / sizeof(l_int))

typedef union l_sigval {

	l_int		sival_int;

	l_uintptr_t	sival_ptr;

} l_sigval_t;

typedef struct l_siginfo {

	l_int		lsi_signo;

	l_int		lsi_errno;

	l_int		lsi_code;

	union {

		l_int	_pad[LINUX_SI_PAD_SIZE];

		struct {

			l_pid_t		_pid;

			l_uid_t		_uid;

		} _kill;

		struct {

			l_timer_t	_tid;

			l_int		_overrun;

			char		_pad[sizeof(l_uid_t) - sizeof(int)];

			union l_sigval	_sigval;

			l_uint		_sys_private;

		} _timer;

		struct {

			l_pid_t		_pid;		/* sender's pid */

			l_uid_t		_uid;		/* sender's uid */

			union l_sigval	_sigval;

		} _rt;

		struct {

			l_pid_t		_pid;		/* which child */

			l_uid_t		_uid;		/* sender's uid */

			l_int		_status;	/* exit code */

			l_clock_t	_utime;

			l_clock_t	_stime;

		} _sigchld;

		struct {

			l_uintptr_t	_addr;	/* Faulting insn/memory ref. */

		} _sigfault;

		struct {

			l_long		_band;	/* POLL_IN,POLL_OUT,POLL_MSG */

			l_int		_fd;

		} _sigpoll;

	} _sifields;

} l_siginfo_t;

#define	lsi_pid		_sifields._kill._pid

#define	lsi_uid		_sifields._kill._uid

#define	lsi_tid		_sifields._timer._tid

#define	lsi_overrun	_sifields._timer._overrun

#define	lsi_sys_private	_sifields._timer._sys_private

#define	lsi_status	_sifields._sigchld._status

#define	lsi_utime	_sifields._sigchld._utime

#define	lsi_stime	_sifields._sigchld._stime

#define	lsi_value	_sifields._rt._sigval

#define	lsi_int		_sifields._rt._sigval.sival_int

#define	lsi_ptr		_sifields._rt._sigval.sival_ptr

#define	lsi_addr	_sifields._sigfault._addr

#define	lsi_band	_sifields._sigpoll._band

#define	lsi_fd		_sifields._sigpoll._fd

/*

 * We make the stack look like Linux expects it when calling a signal

 * handler, but use the BSD way of calling the handler and sigreturn().

 * This means that we need to pass the pointer to the handler too.

 * It is appended to the frame to not interfere with the rest of it.

 */

struct l_rt_sigframe {

	struct l_ucontext	sf_sc;

	struct l_siginfo	sf_si;

	l_handler_t		sf_handler;

};

/*

 * mount flags

 */

#define	LINUX_MS_RDONLY		0x0001

#define	LINUX_MS_NOSUID		0x0002

#define	LINUX_MS_NODEV		0x0004

#define	LINUX_MS_NOEXEC		0x0008

#define	LINUX_MS_REMOUNT	0x0020

/*

 * SystemV IPC defines

 */

#define	LINUX_IPC_RMID		0

#define	LINUX_IPC_SET		1

#define	LINUX_IPC_STAT		2

#define	LINUX_IPC_INFO		3

#define	LINUX_SHM_LOCK		11

#define	LINUX_SHM_UNLOCK	12

#define	LINUX_SHM_STAT		13

#define	LINUX_SHM_INFO		14

#define	LINUX_SHM_RDONLY	0x1000

#define	LINUX_SHM_RND		0x2000

#define	LINUX_SHM_REMAP		0x4000

/* semctl commands */

#define	LINUX_GETPID		11

#define	LINUX_GETVAL		12

#define	LINUX_GETALL		13

#define	LINUX_GETNCNT		14

#define	LINUX_GETZCNT		15

#define	LINUX_SETVAL		16

#define	LINUX_SETALL		17

#define	LINUX_SEM_STAT		18

#define	LINUX_SEM_INFO		19

union l_semun {

	l_int		val;

	l_uintptr_t	buf;

	l_uintptr_t	array;

	l_uintptr_t	__buf;

	l_uintptr_t	__pad;

};

struct l_ipc_perm {

	l_key_t		key;

	l_uid_t		uid;

	l_gid_t		gid;

	l_uid_t		cuid;

	l_gid_t		cgid;

	l_ushort	mode;

	l_ushort	seq;

};

/*

 * Socket defines

 */

#define	LINUX_SOL_SOCKET	1

#define	LINUX_SOL_IP		0

#define	LINUX_SOL_IPX		256

#define	LINUX_SOL_AX25		257

#define	LINUX_SOL_TCP		6

#define	LINUX_SOL_UDP		17

#define	LINUX_SO_DEBUG		1

#define	LINUX_SO_REUSEADDR	2

#define	LINUX_SO_TYPE		3

#define	LINUX_SO_ERROR		4

#define	LINUX_SO_DONTROUTE	5

#define	LINUX_SO_BROADCAST	6

#define	LINUX_SO_SNDBUF		7

#define	LINUX_SO_RCVBUF		8

#define	LINUX_SO_KEEPALIVE	9

#define	LINUX_SO_OOBINLINE	10

#define	LINUX_SO_NO_CHECK	11

#define	LINUX_SO_PRIORITY	12

#define	LINUX_SO_LINGER		13

#define	LINUX_SO_PASSCRED	16

#define	LINUX_SO_PEERCRED	17

#define	LINUX_SO_RCVLOWAT	18

#define	LINUX_SO_SNDLOWAT	19

#define	LINUX_SO_RCVTIMEO	20

#define	LINUX_SO_SNDTIMEO	21

#define	LINUX_SO_TIMESTAMP	29

#define	LINUX_SO_ACCEPTCONN	30

#define	LINUX_IP_TOS		1

#define	LINUX_IP_TTL		2

#define	LINUX_IP_HDRINCL	3

#define	LINUX_IP_OPTIONS	4

#define	LINUX_IP_MULTICAST_IF		32

#define	LINUX_IP_MULTICAST_TTL		33

#define	LINUX_IP_MULTICAST_LOOP		34

#define	LINUX_IP_ADD_MEMBERSHIP		35

#define	LINUX_IP_DROP_MEMBERSHIP	36

struct l_sockaddr {

	l_ushort	sa_family;

	char		sa_data[14];

};

struct l_ifmap {

	l_ulong		mem_start;

	l_ulong		mem_end;

	l_ushort	base_addr;

	u_char		irq;

	u_char		dma;

	u_char		port;

} __packed;

#define	LINUX_IFHWADDRLEN	6

#define	LINUX_IFNAMSIZ		16

struct l_ifreq {

	union {

		char	ifrn_name[LINUX_IFNAMSIZ];

	} ifr_ifrn;

	union {

		struct l_sockaddr	ifru_addr;

		struct l_sockaddr	ifru_dstaddr;

		struct l_sockaddr	ifru_broadaddr;

		struct l_sockaddr	ifru_netmask;

		struct l_sockaddr	ifru_hwaddr;

		l_short		ifru_flags[1];

		l_int		ifru_metric;

		l_int		ifru_mtu;

		struct l_ifmap	ifru_map;

		char		ifru_slave[LINUX_IFNAMSIZ];

		l_uintptr_t	ifru_data;

	} ifr_ifru;

} __packed;

#define	ifr_name	ifr_ifrn.ifrn_name	/* Interface name */

#define	ifr_hwaddr	ifr_ifru.ifru_hwaddr	/* MAC address */

struct l_ifconf {

	int	ifc_len;

	union {

		l_uintptr_t	ifcu_buf;

		l_uintptr_t	ifcu_req;

	} ifc_ifcu;

};

#define	ifc_buf		ifc_ifcu.ifcu_buf

#define	ifc_req		ifc_ifcu.ifcu_req

/*

 * poll()

 */

#define	LINUX_POLLIN		0x0001

#define	LINUX_POLLPRI		0x0002

#define	LINUX_POLLOUT		0x0004

#define	LINUX_POLLERR		0x0008

#define	LINUX_POLLHUP		0x0010

#define	LINUX_POLLNVAL		0x0020

#define	LINUX_POLLRDNORM	0x0040

#define	LINUX_POLLRDBAND	0x0080

#define	LINUX_POLLWRNORM	0x0100

#define	LINUX_POLLWRBAND	0x0200

#define	LINUX_POLLMSG		0x0400

struct l_pollfd {

	l_int		fd;

	l_short		events;

	l_short		revents;

};

#define	LINUX_CLONE_VM			0x00000100

#define	LINUX_CLONE_FS			0x00000200

#define	LINUX_CLONE_FILES		0x00000400

#define	LINUX_CLONE_SIGHAND		0x00000800

#define	LINUX_CLONE_PID			0x00001000	/* No longer exist in Linux */

#define	LINUX_CLONE_VFORK		0x00004000

#define	LINUX_CLONE_PARENT		0x00008000

#define	LINUX_CLONE_THREAD		0x00010000

#define	LINUX_CLONE_SETTLS		0x00080000

#define	LINUX_CLONE_PARENT_SETTID	0x00100000

#define	LINUX_CLONE_CHILD_CLEARTID	0x00200000

#define	LINUX_CLONE_CHILD_SETTID	0x01000000

#define LINUX_ARCH_SET_GS		0x1001

#define LINUX_ARCH_SET_FS		0x1002

#define LINUX_ARCH_GET_GS		0x1003

#define LINUX_ARCH_GET_FS		0x1004

/* robust futexes */

struct linux_robust_list {

	l_uintptr_t			next;

};

struct linux_robust_list_head {

	struct linux_robust_list	list;

	l_long				futex_offset;

	l_uintptr_t			pending_list;

};

#endif /* !_AMD64_LINUX_H_ */

/*-

 * Copyright (c) 2013 Dmitry Chagin

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/cdefs.h>

__FBSDID("$FreeBSD$");

#include "opt_compat.h"

#include "opt_kdtrace.h"

#include <sys/param.h>

#include <sys/kernel.h>

#include <sys/sdt.h>

#include <sys/systm.h>

#include <sys/proc.h>

#include <amd64/linux/linux.h>

#include <amd64/linux/linux_proto.h>

#include <compat/linux/linux_dtrace.h>

#include <compat/linux/linux_util.h>

/* DTrace init */

LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);

DUMMY(mincore);

DUMMY(sendfile);

DUMMY(ptrace);

DUMMY(syslog);

DUMMY(setfsuid);

DUMMY(setfsgid);

DUMMY(sysfs);

DUMMY(vhangup);

DUMMY(pivot_root);

DUMMY(adjtimex);

DUMMY(swapoff);

DUMMY(create_module);

DUMMY(init_module);

DUMMY(delete_module);

DUMMY(get_kernel_syms);

DUMMY(query_module);

DUMMY(quotactl);

DUMMY(nfsservctl);

DUMMY(getpmsg);

DUMMY(putpmsg);

DUMMY(afs_syscall);

DUMMY(tuxcall);

DUMMY(security);

DUMMY(set_thread_area);

DUMMY(lookup_dcookie);

DUMMY(epoll_ctl_old);

DUMMY(epoll_wait_old);

DUMMY(remap_file_pages);

DUMMY(semtimedop);

DUMMY(mbind);

DUMMY(get_mempolicy);

DUMMY(set_mempolicy);

DUMMY(mq_open);

DUMMY(mq_unlink);

DUMMY(mq_timedsend);

DUMMY(mq_timedreceive);

DUMMY(mq_notify);

DUMMY(mq_getsetattr);

DUMMY(kexec_load);

DUMMY(add_key);

DUMMY(request_key);

DUMMY(keyctl);

DUMMY(ioprio_set);

DUMMY(ioprio_get);

DUMMY(inotify_init);

DUMMY(inotify_add_watch);

DUMMY(inotify_rm_watch);

DUMMY(migrate_pages);

DUMMY(unshare);

DUMMY(splice);

DUMMY(tee);

DUMMY(sync_file_range);

DUMMY(vmsplice);

DUMMY(move_pages);

DUMMY(signalfd);

DUMMY(timerfd);

DUMMY(timerfd_settime);

DUMMY(timerfd_gettime);

DUMMY(signalfd4);

DUMMY(inotify_init1);

DUMMY(preadv);

DUMMY(pwritev);

DUMMY(rt_tsigqueueinfo);

DUMMY(perf_event_open);

DUMMY(fanotify_init);

DUMMY(fanotify_mark);

DUMMY(name_to_handle_at);

DUMMY(open_by_handle_at);

DUMMY(clock_adjtime);

DUMMY(setns);

DUMMY(process_vm_readv);

DUMMY(process_vm_writev);

DUMMY(kcmp);

DUMMY(finit_module);

#define DUMMY_XATTR(s)						\

int								\

linux_ ## s ## xattr(						\

    struct thread *td, struct linux_ ## s ## xattr_args *arg)	\

{								\

								\

	return (ENOATTR);					\

}

DUMMY_XATTR(set);

DUMMY_XATTR(lset);

DUMMY_XATTR(fset);

DUMMY_XATTR(get);

DUMMY_XATTR(lget);

DUMMY_XATTR(fget);

DUMMY_XATTR(list);

DUMMY_XATTR(llist);

DUMMY_XATTR(flist);

DUMMY_XATTR(remove);

DUMMY_XATTR(lremove);

DUMMY_XATTR(fremove);

#include <sys/cdefs.h>

__FBSDID("$FreeBSD$");

#include <sys/param.h>

#include <sys/assym.h>

#include <sys/systm.h>

#include <amd64/linux/linux.h>

#include <compat/linux/linux_mib.h>

ASSYM(LINUX_RT_SIGF_HANDLER, offsetof(struct l_rt_sigframe, sf_handler));

ASSYM(LINUX_RT_SIGF_UC, offsetof(struct l_rt_sigframe, sf_sc));

ASSYM(LINUX_RT_SIGF_SC, offsetof(struct l_ucontext, uc_mcontext));

ASSYM(LINUX_VERSION_CODE, LINUX_VERSION_CODE);

ASSYM(LINUX_SC_RSP, offsetof(struct l_sigcontext, sc_rsp));

/*-

 * Copyright (c) 2002 Maxim Sobolev <sobomax@FreeBSD.org>

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 *

 * $FreeBSD$

 */

#ifndef _AMD64_LINUX_LINUX_IPC64_H_

#define	_AMD64_LINUX_LINUX_IPC64_H_

/*

 * The ipc64_perm structure for i386 architecture.

 * Note extra padding because this structure is passed back and forth

 * between kernel and user space.

 *

 * Pad space is left for:

 * - 32-bit mode_t and seq

 * - 2 miscellaneous 32-bit values

 */

struct l_ipc64_perm

{

	l_key_t		key;

	l_uid_t		uid;

	l_gid_t		gid;

	l_uid_t		cuid;

	l_gid_t		cgid;

	l_mode_t	mode;

	l_ushort	__pad1;

	l_ushort	seq;

	l_ushort	__pad2;

	l_ulong		__unused1;

	l_ulong		__unused2;

};

/*

 * The msqid64_ds structure for i386 architecture.

 * Note extra padding because this structure is passed back and forth

 * between kernel and user space.

 *

 * Pad space is left for:

 * - 64-bit time_t to solve y2038 problem

 * - 2 miscellaneous 32-bit values

 */

struct l_msqid64_ds {

	struct l_ipc64_perm msg_perm;

	l_time_t	msg_stime;	/* last msgsnd time */

	l_ulong		__unused1;

	l_time_t	msg_rtime;	/* last msgrcv time */

	l_ulong		__unused2;

	l_time_t	msg_ctime;	/* last change time */

	l_ulong		__unused3;

	l_ulong		msg_cbytes;	/* current number of bytes on queue */

	l_ulong		msg_qnum;	/* number of messages in queue */

	l_ulong		msg_qbytes;	/* max number of bytes on queue */

	l_pid_t		msg_lspid;	/* pid of last msgsnd */

	l_pid_t		msg_lrpid;	/* last receive pid */

	l_ulong		__unused4;

	l_ulong		__unused5;

};

/*

 * The semid64_ds structure for i386 architecture.

 * Note extra padding because this structure is passed back and forth

 * between kernel and user space.

 *

 * Pad space is left for:

 * - 64-bit time_t to solve y2038 problem

 * - 2 miscellaneous 32-bit values

 */

struct l_semid64_ds {

	struct l_ipc64_perm sem_perm;	/* permissions */

	l_time_t	sem_otime;	/* last semop time */

	l_ulong		__unused1;

	l_time_t	sem_ctime;	/* last change time */

	l_ulong		__unused2;

	l_ulong		sem_nsems;	/* no. of semaphores in array */

	l_ulong		__unused3;

	l_ulong		__unused4;

};

/*

 * The shmid64_ds structure for i386 architecture.

 * Note extra padding because this structure is passed back and forth

 * between kernel and user space.

 *

 * Pad space is left for:

 * - 64-bit time_t to solve y2038 problem

 * - 2 miscellaneous 32-bit values

 */

struct l_shmid64_ds {

	struct l_ipc64_perm shm_perm;	/* operation perms */

	l_size_t	shm_segsz;	/* size of segment (bytes) */

	l_time_t	shm_atime;	/* last attach time */

	l_time_t	shm_dtime;	/* last detach time */

	l_time_t	shm_ctime;	/* last change time */

	l_pid_t		shm_cpid;	/* pid of creator */

	l_pid_t		shm_lpid;	/* pid of last operator */

	l_ulong		shm_nattch;	/* no. of current attaches */

	l_ulong		__unused4;

	l_ulong		__unused5;

};

struct l_shminfo64 {

	l_ulong		shmmax;

	l_ulong		shmmin;

	l_ulong		shmmni;

	l_ulong		shmseg;

	l_ulong		shmall;

	l_ulong   	__unused1;

	l_ulong		__unused2;

	l_ulong		__unused3;

	l_ulong		__unused4;

};

#endif /* !_AMD64_LINUX_LINUX_IPC64_H_ */

/* $FreeBSD$ */

#include "linux_assym.h"			/* system definitions */

#include <machine/asmacros.h>			/* miscellaneous asm macros */

#include <amd64/linux/linux_syscall.h>		/* system call numbers */

	.data

	.globl linux_platform

linux_platform:

	.asciz "x86_64"

	.text

/*

 * To avoid excess stack frame the signal trampoline code emulates

 * the 'call' instruction.

 */

NON_GPROF_ENTRY(linux_rt_sigcode)

	movq	%rsp, %rbx			/* preserve sigframe */

	call	.getip

.getip:

	popq	%rax

	add	$.startrtsigcode-.getip, %rax	/* ret address */

	pushq	%rax

	jmp	*LINUX_RT_SIGF_HANDLER(%rbx)

.startrtsigcode:

	movq	$LINUX_SYS_linux_rt_sigreturn,%rax   /* linux_rt_sigreturn() */

	syscall					/* enter kernel with args */

	hlt

0:	jmp	0b

NON_GPROF_ENTRY(__vdso_clock_gettime)

.startclockgettime:

	movq	$LINUX_SYS_linux_clock_gettime,%rax

	syscall

	ret

.endclockgettime:

.weak clock_gettime

.set clock_gettime, __vdso_clock_gettime

NON_GPROF_ENTRY(__vdso_time)

.starttime:

	movq	$LINUX_SYS_linux_time,%rax

	syscall

	ret

.endtime:

.weak time

.set time, __vdso_time

NON_GPROF_ENTRY(__vdso_gettimeofday)

.startgettimeofday:

	movq	$LINUX_SYS_gettimeofday,%rax

	syscall

	ret

.endgettimeofday:

.weak gettimeofday

.set gettimeofday, __vdso_gettimeofday

NON_GPROF_ENTRY(__vdso_getcpu)

.startgetcpu:

	movq	$-38,%rax	/* not implemented */

	ret

.endgetcpu:

.weak getcpu

.set getcpu, __vdso_getcpu

#if 0

	.section .note.Linux, "a",@note

	.long 2f - 1f		/* namesz */

	.balign 4

	.long 4f - 3f		/* descsz */

	.long 0

1:

	.asciz "Linux"

2:

	.balign 4

3:

	.long LINUX_VERSION_CODE

4:

	.balign 4

	.previous

#endif

#define do_cfa_expr(offset)                                             \

	.byte 0x0f;			/* DW_CFA_def_cfa_expression */ \

	.uleb128 11f-10f;		/*   length */                  \

10:	.byte 0x74;			/*     DW_OP_breg4 */           \

	.sleb128 offset;		/*      offset */               \

	.byte 0x06;			/*     DW_OP_deref */           \

11:

	.section .eh_frame,"a",@progbits

.LSTARTFRAMEDLSI0:

	.long .LENDCIEDLSI0-.LSTARTCIEDLSI0

.LSTARTCIEDLSI0:

	.long 0					/* CIE ID */

	.byte 1					/* Version number */

	.string "zR"				/* NULL-terminated

						 * augmentation string

						 */

	.uleb128 1				/* Code alignment factor */

	.sleb128 -4				/* Data alignment factor */

	.byte 8					/* Return address register column */

	.uleb128 1				/* Augmentation value length */

	.byte 0x1b				/* DW_EH_PE_pcrel|DW_EH_PE_sdata4. */

	.byte 0x0c				/* DW_CFA_def_cfa */

	.uleb128 4

	.uleb128 4

	.byte 0x88				/* DW_CFA_offset, column 0x8 */

	.uleb128 1

	.align 4

.LENDCIEDLSI0:

	.long .LENDFDEDLSI0-.LSTARTFDEDLSI0	/* Length FDE */

.LSTARTFDEDLSI0:

	.long .LSTARTFDEDLSI0-.LSTARTFRAMEDLSI0	/* CIE pointer */

	.long .startclockgettime-.		/* PC-relative start address */

	.long .endclockgettime-.startclockgettime

	.uleb128 0

	.align 4

.LENDFDEDLSI0:

	.previous

/*-

 * Copyright (c) 2013 Dmitry Chagin

 * Copyright (c) 2004 Tim J. Robbins

 * Copyright (c) 2002 Doug Rabson

 * Copyright (c) 2000 Marcel Moolenaar

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer

 *    in this position and unchanged.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. The name of the author may not be used to endorse or promote products

 *    derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/cdefs.h>

__FBSDID("$FreeBSD$");

#include <sys/param.h>

#include <sys/kernel.h>

#include <sys/systm.h>

#include <sys/capability.h>

#include <sys/dirent.h>

#include <sys/file.h>

#include <sys/fcntl.h>

#include <sys/filedesc.h>

#include <sys/clock.h>

#include <sys/imgact.h>

#include <sys/ktr.h>

#include <sys/limits.h>

#include <sys/lock.h>

#include <sys/malloc.h>

#include <sys/mman.h>

#include <sys/mutex.h>

#include <sys/priv.h>

#include <sys/proc.h>

#include <sys/resource.h>

#include <sys/resourcevar.h>

#include <sys/sched.h>

#include <sys/syscallsubr.h>

#include <sys/sysproto.h>

#include <sys/vnode.h>

#include <sys/unistd.h>

#include <sys/wait.h>

#include <security/mac/mac_framework.h>

#include <ufs/ufs/extattr.h>

#include <ufs/ufs/quota.h>

#include <ufs/ufs/ufsmount.h>

#include <machine/frame.h>

#include <machine/md_var.h>

#include <machine/pcb.h>

#include <machine/psl.h>

#include <machine/segments.h>

#include <machine/specialreg.h>

#include <vm/vm.h>

#include <vm/pmap.h>

#include <vm/vm_extern.h>

#include <vm/vm_kern.h>

#include <vm/vm_map.h>

#include <amd64/linux/linux.h>

#include <amd64/linux/linux_proto.h>

#include <compat/linux/linux_ipc.h>

#include <compat/linux/linux_file.h>

#include <compat/linux/linux_misc.h>

#include <compat/linux/linux_signal.h>

#include <compat/linux/linux_util.h>

#include <compat/linux/linux_emul.h>

int

linux_execve(struct thread *td, struct linux_execve_args *args)

{

	struct image_args eargs;

	char *path;

	int error;

	LCONVPATHEXIST(td, args->path, &path);

	LINUX_CTR(execve);

	error = exec_copyin_args(&eargs, path, UIO_SYSSPACE, args->argp,

	    args->envp);

	free(path, M_TEMP);

	if (error == 0)

		error = linux_common_execve(td, &eargs);

	return (error);

}

int

linux_set_upcall_kse(struct thread *td, register_t stack)

{

	if (stack)

		td->td_frame->tf_rsp = stack;

	/*

	 * The newly created Linux thread returns

	 * to the user space by the same path that a parent do.

	 */

	td->td_frame->tf_rax = 0;

	return (0);

}

#define STACK_SIZE  (2 * 1024 * 1024)

#define GUARD_SIZE  (4 * PAGE_SIZE)

int

linux_mmap2(struct thread *td, struct linux_mmap2_args *args)

{

	struct proc *p = td->td_proc;

	struct mmap_args /* {

		caddr_t addr;

		size_t len;

		int prot;

		int flags;

		int fd;

		long pad;

		off_t pos;

	} */ bsd_args;

	int error;

	struct file *fp;

	cap_rights_t rights;

	LINUX_CTR6(mmap2, "0x%lx, %ld, %ld, 0x%08lx, %ld, 0x%lx",

	    args->addr, args->len, args->prot,

	    args->flags, args->fd, args->pgoff);

	error = 0;

	bsd_args.flags = 0;

	fp = NULL;

	/*

	 * Linux mmap(2):

	 * You must specify exactly one of MAP_SHARED and MAP_PRIVATE

	 */

	if (! ((args->flags & LINUX_MAP_SHARED) ^

	    (args->flags & LINUX_MAP_PRIVATE)))

		return (EINVAL);

	if (args->flags & LINUX_MAP_SHARED)

		bsd_args.flags |= MAP_SHARED;

	if (args->flags & LINUX_MAP_PRIVATE)

		bsd_args.flags |= MAP_PRIVATE;

	if (args->flags & LINUX_MAP_FIXED)

		bsd_args.flags |= MAP_FIXED;

	if (args->flags & LINUX_MAP_ANON)

		bsd_args.flags |= MAP_ANON;

	else

		bsd_args.flags |= MAP_NOSYNC;

	if (args->flags & LINUX_MAP_GROWSDOWN)

		bsd_args.flags |= MAP_STACK;

	/*

	 * PROT_READ, PROT_WRITE, or PROT_EXEC implies PROT_READ and PROT_EXEC

	 * on Linux/i386. We do this to ensure maximum compatibility.

	 * Linux/ia64 does the same in i386 emulation mode.

	 */

	bsd_args.prot = args->prot;

	if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC))

		bsd_args.prot |= PROT_READ | PROT_EXEC;

	/* Linux does not check file descriptor when MAP_ANONYMOUS is set. */

	bsd_args.fd = (bsd_args.flags & MAP_ANON) ? -1 : args->fd;

	if (bsd_args.fd != -1) {

		/*

		 * Linux follows Solaris mmap(2) description:

		 * The file descriptor fildes is opened with

		 * read permission, regardless of the

		 * protection options specified.

		 */

		error = fget(td, bsd_args.fd,

		    cap_rights_init(&rights, CAP_MMAP), &fp);

		if (error != 0 )

			return (error);

		if (fp->f_type != DTYPE_VNODE) {

			fdrop(fp, td);

			return (EINVAL);

		}

		/* Linux mmap() just fails for O_WRONLY files */

		if (!(fp->f_flag & FREAD)) {

			fdrop(fp, td);

			return (EACCES);

		}

		fdrop(fp, td);

	}

	if (args->flags & LINUX_MAP_GROWSDOWN) {

		/*

		 * The Linux MAP_GROWSDOWN option does not limit auto

		 * growth of the region.  Linux mmap with this option

		 * takes as addr the inital BOS, and as len, the initial

		 * region size.  It can then grow down from addr without

		 * limit.  However, Linux threads has an implicit internal

		 * limit to stack size of STACK_SIZE.  Its just not

		 * enforced explicitly in Linux.  But, here we impose

		 * a limit of (STACK_SIZE - GUARD_SIZE) on the stack

		 * region, since we can do this with our mmap.

		 *

		 * Our mmap with MAP_STACK takes addr as the maximum

		 * downsize limit on BOS, and as len the max size of

		 * the region.  It then maps the top SGROWSIZ bytes,

		 * and auto grows the region down, up to the limit

		 * in addr.

		 *

		 * If we don't use the MAP_STACK option, the effect

		 * of this code is to allocate a stack region of a

		 * fixed size of (STACK_SIZE - GUARD_SIZE).

		 */

		if ((caddr_t)PTRIN(args->addr) + args->len >

		    p->p_vmspace->vm_maxsaddr) {

			/*

			 * Some Linux apps will attempt to mmap

			 * thread stacks near the top of their

			 * address space.  If their TOS is greater

			 * than vm_maxsaddr, vm_map_growstack()

			 * will confuse the thread stack with the

			 * process stack and deliver a SEGV if they

			 * attempt to grow the thread stack past their

			 * current stacksize rlimit.  To avoid this,

			 * adjust vm_maxsaddr upwards to reflect

			 * the current stacksize rlimit rather

			 * than the maximum possible stacksize.

			 * It would be better to adjust the

			 * mmap'ed region, but some apps do not check

			 * mmap's return value.

			 */

			PROC_LOCK(p);

			p->p_vmspace->vm_maxsaddr = (char *)USRSTACK -

			    lim_cur(p, RLIMIT_STACK);

			PROC_UNLOCK(p);

		}

		/*

		 * This gives us our maximum stack size and a new BOS.

		 * If we're using VM_STACK, then mmap will just map

		 * the top SGROWSIZ bytes, and let the stack grow down

		 * to the limit at BOS.  If we're not using VM_STACK

		 * we map the full stack, since we don't have a way

		 * to autogrow it.

		 */

		if (args->len > STACK_SIZE - GUARD_SIZE) {

			bsd_args.addr = (caddr_t)PTRIN(args->addr);

			bsd_args.len = args->len;

		} else {

			bsd_args.addr = (caddr_t)PTRIN(args->addr) -

			    (STACK_SIZE - GUARD_SIZE - args->len);

			bsd_args.len = STACK_SIZE - GUARD_SIZE;

		}

	} else {

		bsd_args.addr = (caddr_t)PTRIN(args->addr);

		bsd_args.len  = args->len;

	}

	bsd_args.pos = (off_t)args->pgoff;

	error = sys_mmap(td, &bsd_args);

	LINUX_CTR2(mmap2, "return: %d (%p)",

	    error, td->td_retval[0]);

	return (error);

}

int

linux_mprotect(struct thread *td, struct linux_mprotect_args *uap)

{

	struct mprotect_args bsd_args;

	LINUX_CTR(mprotect);

	bsd_args.addr = uap->addr;

	bsd_args.len = uap->len;

	bsd_args.prot = uap->prot;

	if (bsd_args.prot & (PROT_READ | PROT_WRITE | PROT_EXEC))

		bsd_args.prot |= PROT_READ | PROT_EXEC;

	return (sys_mprotect(td, &bsd_args));

}

int

linux_iopl(struct thread *td, struct linux_iopl_args *args)

{

	int error;

	LINUX_CTR(iopl);

	if (args->level > 3)

		return (EINVAL);

	if ((error = priv_check(td, PRIV_IO)) != 0)

		return (error);

	if ((error = securelevel_gt(td->td_ucred, 0)) != 0)

		return (error);

	td->td_frame->tf_rflags = (td->td_frame->tf_rflags & ~PSL_IOPL) |

	    (args->level * (PSL_IOPL / 3));

	return (0);

}

int

linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap)

{

	l_sigset_t lmask;

	sigset_t sigmask;

	int error;

	LINUX_CTR2(rt_sigsuspend, "%p, %ld",

	    uap->newset, uap->sigsetsize);

	if (uap->sigsetsize != sizeof(l_sigset_t))

		return (EINVAL);

	error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));

	if (error)

		return (error);

	linux_to_bsd_sigset(&lmask, &sigmask);

	return (kern_sigsuspend(td, sigmask));

}

int

linux_pause(struct thread *td, struct linux_pause_args *args)

{

	struct proc *p = td->td_proc;

	sigset_t sigmask;

	LINUX_CTR(pause);

	PROC_LOCK(p);

	sigmask = td->td_sigmask;

	PROC_UNLOCK(p);

	return (kern_sigsuspend(td, sigmask));

}

int

linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)

{

	stack_t ss, oss;

	l_stack_t lss;

	int error;

	LINUX_CTR2(sigaltstack, "%p, %p", uap->uss, uap->uoss);

	if (uap->uss != NULL) {

		error = copyin(uap->uss, &lss, sizeof(l_stack_t));

		if (error)

			return (error);

		ss.ss_sp = PTRIN(lss.ss_sp);

		ss.ss_size = lss.ss_size;

		ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);

	}

	error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,

	    (uap->uoss != NULL) ? &oss : NULL);

	if (!error && uap->uoss != NULL) {

		lss.ss_sp = PTROUT(oss.ss_sp);

		lss.ss_size = oss.ss_size;

		lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);

		error = copyout(&lss, uap->uoss, sizeof(l_stack_t));

	}

	return (error);

}

/* XXX do all */

int

linux_arch_prctl(struct thread *td, struct linux_arch_prctl_args *args)

{

	int error;

	struct pcb *pcb;

	LINUX_CTR2(arch_prctl, "0x%x, %p", args->code, args->addr);

	error = ENOTSUP;

	pcb = td->td_pcb;

	switch (args->code) {

	case LINUX_ARCH_GET_GS:

		error = copyout(&pcb->pcb_gsbase, (unsigned long *)args->addr,

		    sizeof(args->addr));

		break;

	case LINUX_ARCH_SET_GS:

		if (args->addr >= VM_MAXUSER_ADDRESS)

			return(EPERM);

		break;

	case LINUX_ARCH_GET_FS:

		error = copyout(&pcb->pcb_fsbase, (unsigned long *)args->addr,

		    sizeof(args->addr));

		break;

	case LINUX_ARCH_SET_FS:

		error = linux_set_cloned_tls(td, (void *)args->addr);

		break;

	default:

		error = EINVAL;

	}

	return (error);

}

int

linux_set_cloned_tls(struct thread *td, void *desc)

{

	struct pcb *pcb;

	if ((uint64_t)desc >= VM_MAXUSER_ADDRESS)

		return (EPERM);

	pcb = td->td_pcb;

	pcb->pcb_fsbase = (register_t)desc;

	td->td_frame->tf_fs = _ufssel;

	return (0);

}

int

linux_wait4(struct thread *td, struct linux_wait4_args *args)

{

	int error, options;

	struct rusage ru, *rup;

#ifdef DEBUG

	if (ldebug(wait4))

		printf(ARGS(wait4, "%d, %p, %d, %p"),

		    args->pid, (void *)args->status, args->options,

		    (void *)args->rusage);

#endif

	if (args->options & ~(LINUX_WUNTRACED | LINUX_WNOHANG |

	    LINUX_WCONTINUED | __WCLONE | __WNOTHREAD | __WALL))

		return (EINVAL);

	options = WEXITED;

	linux_to_bsd_waitopts(args->options, &options);

	if (args->rusage != NULL)

		rup = &ru;

	else

		rup = NULL;

	error = linux_common_wait(td, args->pid, args->status, options, rup);

	if (error)

		return (error);

	if (args->rusage != NULL)

		error = copyout(&ru, args->rusage, sizeof(ru));

	return (error);

}

int

linux_waitid(struct thread *td, struct linux_waitid_args *args)

{

	int status, options, sig;

	struct __wrusage wru;

	siginfo_t siginfo;

	l_siginfo_t lsi;

	idtype_t idtype;

	struct proc *p;

	int error;

	options = 0;

	linux_to_bsd_waitopts(args->options, &options);

	if (options & ~(WNOHANG | WNOWAIT | WEXITED | WUNTRACED | WCONTINUED))

		return (EINVAL);

	if (!(options & (WEXITED | WUNTRACED | WCONTINUED)))

		return (EINVAL);

	switch (args->idtype) {

	case LINUX_P_ALL:

		idtype = P_ALL;

		break;

	case LINUX_P_PID:

		if (args->id <= 0)

			return (EINVAL);

		idtype = P_PID;

		break;

	case LINUX_P_PGID:

		if (args->id <= 0)

			return (EINVAL);

		idtype = P_PGID;

		break;

	default:

		return (EINVAL);

	}

	error = kern_wait6(td, idtype, args->id, &status, options,

	    &wru, &siginfo);

	if (error)

		return (error);

	if (args->rusage != NULL) {

		error = copyout(&wru.wru_children, args->rusage,

		    sizeof(wru.wru_children));

		if (error)

			return (error);

	}

	if (args->info != NULL) {

		p = td->td_proc;

		if (td->td_retval[0] == 0)

			bzero(&lsi, sizeof(lsi));

		else {

			sig = bsd_to_linux_signal(siginfo.si_signo);

			siginfo_to_lsiginfo(&siginfo, &lsi, sig);

		}

		error = copyout(&lsi, args->info, sizeof(lsi));

	}

	td->td_retval[0] = 0;

	return (error);

}

/*

 * System call prototypes.

 *

 * DO NOT EDIT-- this file is automatically generated.

 * $FreeBSD$

 * created from FreeBSD

 */

#ifndef _LINUX_SYSPROTO_H_

#define	_LINUX_SYSPROTO_H_

#include <sys/signal.h>

#include <sys/acl.h>

#include <sys/cpuset.h>

#include <sys/_ffcounter.h>

#include <sys/_semaphore.h>

#include <sys/ucontext.h>

#include <sys/wait.h>

#include <bsm/audit_kevents.h>

struct proc;

struct thread;

#define	PAD_(t)	(sizeof(register_t) <= sizeof(t) ? \

		0 : sizeof(register_t) - sizeof(t))

#if BYTE_ORDER == LITTLE_ENDIAN

#define	PADL_(t)	0

#define	PADR_(t)	PAD_(t)

#else

#define	PADL_(t)	PAD_(t)

#define	PADR_(t)	0

#endif

#define	nosys	linux_nosys

struct linux_open_args {

	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];

	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];

	char mode_l_[PADL_(l_int)]; l_int mode; char mode_r_[PADR_(l_int)];

};

struct linux_newstat_args {

	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];

	char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)];

};

struct linux_newfstat_args {

	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];

	char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)];

};

struct linux_newlstat_args {

	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];

	char buf_l_[PADL_(struct l_newstat *)]; struct l_newstat * buf; char buf_r_[PADR_(struct l_newstat *)];

};

struct linux_lseek_args {

	char fdes_l_[PADL_(l_uint)]; l_uint fdes; char fdes_r_[PADR_(l_uint)];

	char off_l_[PADL_(l_off_t)]; l_off_t off; char off_r_[PADR_(l_off_t)];

	char whence_l_[PADL_(l_int)]; l_int whence; char whence_r_[PADR_(l_int)];

};

struct linux_mmap2_args {

	char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)];

	char len_l_[PADL_(l_ulong)]; l_ulong len; char len_r_[PADR_(l_ulong)];

	char prot_l_[PADL_(l_ulong)]; l_ulong prot; char prot_r_[PADR_(l_ulong)];

	char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)];

	char fd_l_[PADL_(l_ulong)]; l_ulong fd; char fd_r_[PADR_(l_ulong)];

	char pgoff_l_[PADL_(l_ulong)]; l_ulong pgoff; char pgoff_r_[PADR_(l_ulong)];

};

struct linux_mprotect_args {

	char addr_l_[PADL_(caddr_t)]; caddr_t addr; char addr_r_[PADR_(caddr_t)];

	char len_l_[PADL_(int)]; int len; char len_r_[PADR_(int)];

	char prot_l_[PADL_(int)]; int prot; char prot_r_[PADR_(int)];

};

struct linux_brk_args {

	char dsend_l_[PADL_(l_ulong)]; l_ulong dsend; char dsend_r_[PADR_(l_ulong)];

};

struct linux_rt_sigaction_args {

	char sig_l_[PADL_(l_int)]; l_int sig; char sig_r_[PADR_(l_int)];

	char act_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * act; char act_r_[PADR_(l_sigaction_t *)];

	char oact_l_[PADL_(l_sigaction_t *)]; l_sigaction_t * oact; char oact_r_[PADR_(l_sigaction_t *)];

	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];

};

struct linux_rt_sigprocmask_args {

	char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)];

	char mask_l_[PADL_(l_sigset_t *)]; l_sigset_t * mask; char mask_r_[PADR_(l_sigset_t *)];

	char omask_l_[PADL_(l_sigset_t *)]; l_sigset_t * omask; char omask_r_[PADR_(l_sigset_t *)];

	char sigsetsize_l_[PADL_(l_size_t)]; l_size_t sigsetsize; char sigsetsize_r_[PADR_(l_size_t)];

};

struct linux_rt_sigreturn_args {

	char ucp_l_[PADL_(struct l_ucontext *)]; struct l_ucontext * ucp; char ucp_r_[PADR_(struct l_ucontext *)];

};

struct linux_ioctl_args {

	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];

	char cmd_l_[PADL_(l_uint)]; l_uint cmd; char cmd_r_[PADR_(l_uint)];

	char arg_l_[PADL_(uintptr_t)]; uintptr_t arg; char arg_r_[PADR_(uintptr_t)];

};

struct linux_pread_args {

	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];

	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];

	char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)];

	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];

};

struct linux_pwrite_args {

	char fd_l_[PADL_(l_uint)]; l_uint fd; char fd_r_[PADR_(l_uint)];

	char buf_l_[PADL_(char *)]; char * buf; char buf_r_[PADR_(char *)];

	char nbyte_l_[PADL_(l_size_t)]; l_size_t nbyte; char nbyte_r_[PADR_(l_size_t)];

	char offset_l_[PADL_(l_loff_t)]; l_loff_t offset; char offset_r_[PADR_(l_loff_t)];

};

struct linux_access_args {

	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];

	char amode_l_[PADL_(l_int)]; l_int amode; char amode_r_[PADR_(l_int)];

};

struct linux_pipe_args {

	char pipefds_l_[PADL_(l_ulong *)]; l_ulong * pipefds; char pipefds_r_[PADR_(l_ulong *)];

};

struct linux_select_args {

	char nfds_l_[PADL_(l_int)]; l_int nfds; char nfds_r_[PADR_(l_int)];

	char readfds_l_[PADL_(l_fd_set *)]; l_fd_set * readfds; char readfds_r_[PADR_(l_fd_set *)];

	char writefds_l_[PADL_(l_fd_set *)]; l_fd_set * writefds; char writefds_r_[PADR_(l_fd_set *)];

	char exceptfds_l_[PADL_(l_fd_set *)]; l_fd_set * exceptfds; char exceptfds_r_[PADR_(l_fd_set *)];

	char timeout_l_[PADL_(struct l_timeval *)]; struct l_timeval * timeout; char timeout_r_[PADR_(struct l_timeval *)];

};

struct linux_mremap_args {

	char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)];

	char old_len_l_[PADL_(l_ulong)]; l_ulong old_len; char old_len_r_[PADR_(l_ulong)];

	char new_len_l_[PADL_(l_ulong)]; l_ulong new_len; char new_len_r_[PADR_(l_ulong)];

	char flags_l_[PADL_(l_ulong)]; l_ulong flags; char flags_r_[PADR_(l_ulong)];

	char new_addr_l_[PADL_(l_ulong)]; l_ulong new_addr; char new_addr_r_[PADR_(l_ulong)];

};

struct linux_msync_args {

	char addr_l_[PADL_(l_ulong)]; l_ulong addr; char addr_r_[PADR_(l_ulong)];

	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];

	char fl_l_[PADL_(l_int)]; l_int fl; char fl_r_[PADR_(l_int)];

};

struct linux_mincore_args {

	char start_l_[PADL_(l_ulong)]; l_ulong start; char start_r_[PADR_(l_ulong)];

	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];

	char vec_l_[PADL_(u_char *)]; u_char * vec; char vec_r_[PADR_(u_char *)];

};

struct linux_shmget_args {

	char key_l_[PADL_(l_key_t)]; l_key_t key; char key_r_[PADR_(l_key_t)];

	char size_l_[PADL_(l_size_t)]; l_size_t size; char size_r_[PADR_(l_size_t)];

	char shmflg_l_[PADL_(l_int)]; l_int shmflg; char shmflg_r_[PADR_(l_int)];

};

struct linux_shmat_args {

	char shmid_l_[PADL_(l_int)]; l_int shmid; char shmid_r_[PADR_(l_int)];

	char shmaddr_l_[PADL_(char *)]; char * shmaddr; char shmaddr_r_[PADR_(char *)];

	char shmflg_l_[PADL_(l_int)]; l_int shmflg; char shmflg_r_[PADR_(l_int)];

};

struct linux_shmctl_args {

	char shmid_l_[PADL_(l_int)]; l_int shmid; char shmid_r_[PADR_(l_int)];

	char cmd_l_[PADL_(l_int)]; l_int cmd; char cmd_r_[PADR_(l_int)];

	char buf_l_[PADL_(struct l_shmid_ds *)]; struct l_shmid_ds * buf; char buf_r_[PADR_(struct l_shmid_ds *)];

};

struct linux_pause_args {

	register_t dummy;

};

struct linux_nanosleep_args {

	char rqtp_l_[PADL_(const struct l_timespec *)]; const struct l_timespec * rqtp; char rqtp_r_[PADR_(const struct l_timespec *)];

	char rmtp_l_[PADL_(struct l_timespec *)]; struct l_timespec * rmtp; char rmtp_r_[PADR_(struct l_timespec *)];

};

struct linux_getitimer_args {

	char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)];

	char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)];

};

struct linux_alarm_args {

	char secs_l_[PADL_(l_uint)]; l_uint secs; char secs_r_[PADR_(l_uint)];

};

struct linux_setitimer_args {

	char which_l_[PADL_(l_int)]; l_int which; char which_r_[PADR_(l_int)];

	char itv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * itv; char itv_r_[PADR_(struct l_itimerval *)];

	char oitv_l_[PADL_(struct l_itimerval *)]; struct l_itimerval * oitv; char oitv_r_[PADR_(struct l_itimerval *)];

};

struct linux_getpid_args {

	register_t dummy;

};

struct linux_sendfile_args {

	char out_l_[PADL_(int)]; int out; char out_r_[PADR_(int)];

	char in_l_[PADL_(int)]; int in; char in_r_[PADR_(int)];

	char offset_l_[PADL_(l_long *)]; l_long * offset; char offset_r_[PADR_(l_long *)];

	char count_l_[PADL_(l_size_t)]; l_size_t count; char count_r_[PADR_(l_size_t)];

};

struct linux_socket_args {

	char domain_l_[PADL_(l_int)]; l_int domain; char domain_r_[PADR_(l_int)];

	char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)];

	char protocol_l_[PADL_(l_int)]; l_int protocol; char protocol_r_[PADR_(l_int)];

};

struct linux_connect_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char name_l_[PADL_(l_uintptr_t)]; l_uintptr_t name; char name_r_[PADR_(l_uintptr_t)];

	char namelen_l_[PADL_(l_int)]; l_int namelen; char namelen_r_[PADR_(l_int)];

};

struct linux_accept_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char addr_l_[PADL_(l_uintptr_t)]; l_uintptr_t addr; char addr_r_[PADR_(l_uintptr_t)];

	char namelen_l_[PADL_(l_uintptr_t)]; l_uintptr_t namelen; char namelen_r_[PADR_(l_uintptr_t)];

};

struct linux_sendto_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)];

	char len_l_[PADL_(l_int)]; l_int len; char len_r_[PADR_(l_int)];

	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];

	char to_l_[PADL_(l_uintptr_t)]; l_uintptr_t to; char to_r_[PADR_(l_uintptr_t)];

	char tolen_l_[PADL_(l_int)]; l_int tolen; char tolen_r_[PADR_(l_int)];

};

struct linux_recvfrom_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char buf_l_[PADL_(l_uintptr_t)]; l_uintptr_t buf; char buf_r_[PADR_(l_uintptr_t)];

	char len_l_[PADL_(l_size_t)]; l_size_t len; char len_r_[PADR_(l_size_t)];

	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];

	char from_l_[PADL_(l_uintptr_t)]; l_uintptr_t from; char from_r_[PADR_(l_uintptr_t)];

	char fromlen_l_[PADL_(l_uintptr_t)]; l_uintptr_t fromlen; char fromlen_r_[PADR_(l_uintptr_t)];

};

struct linux_sendmsg_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)];

	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];

};

struct linux_recvmsg_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char msg_l_[PADL_(l_uintptr_t)]; l_uintptr_t msg; char msg_r_[PADR_(l_uintptr_t)];

	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];

};

struct linux_shutdown_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char how_l_[PADL_(l_int)]; l_int how; char how_r_[PADR_(l_int)];

};

struct linux_bind_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char name_l_[PADL_(l_uintptr_t)]; l_uintptr_t name; char name_r_[PADR_(l_uintptr_t)];

	char namelen_l_[PADL_(l_int)]; l_int namelen; char namelen_r_[PADR_(l_int)];

};

struct linux_listen_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char backlog_l_[PADL_(l_int)]; l_int backlog; char backlog_r_[PADR_(l_int)];

};

struct linux_getsockname_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char addr_l_[PADL_(l_uintptr_t)]; l_uintptr_t addr; char addr_r_[PADR_(l_uintptr_t)];

	char namelen_l_[PADL_(l_uintptr_t)]; l_uintptr_t namelen; char namelen_r_[PADR_(l_uintptr_t)];

};

struct linux_getpeername_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char addr_l_[PADL_(l_uintptr_t)]; l_uintptr_t addr; char addr_r_[PADR_(l_uintptr_t)];

	char namelen_l_[PADL_(l_uintptr_t)]; l_uintptr_t namelen; char namelen_r_[PADR_(l_uintptr_t)];

};

struct linux_socketpair_args {

	char domain_l_[PADL_(l_int)]; l_int domain; char domain_r_[PADR_(l_int)];

	char type_l_[PADL_(l_int)]; l_int type; char type_r_[PADR_(l_int)];

	char protocol_l_[PADL_(l_int)]; l_int protocol; char protocol_r_[PADR_(l_int)];

	char rsv_l_[PADL_(l_uintptr_t)]; l_uintptr_t rsv; char rsv_r_[PADR_(l_uintptr_t)];

};

struct linux_setsockopt_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char level_l_[PADL_(l_int)]; l_int level; char level_r_[PADR_(l_int)];

	char optname_l_[PADL_(l_int)]; l_int optname; char optname_r_[PADR_(l_int)];

	char optval_l_[PADL_(l_uintptr_t)]; l_uintptr_t optval; char optval_r_[PADR_(l_uintptr_t)];

	char optlen_l_[PADL_(l_int)]; l_int optlen; char optlen_r_[PADR_(l_int)];

};

struct linux_getsockopt_args {

	char s_l_[PADL_(l_int)]; l_int s; char s_r_[PADR_(l_int)];

	char level_l_[PADL_(l_int)]; l_int level; char level_r_[PADR_(l_int)];

	char optname_l_[PADL_(l_int)]; l_int optname; char optname_r_[PADR_(l_int)];

	char optval_l_[PADL_(l_uintptr_t)]; l_uintptr_t optval; char optval_r_[PADR_(l_uintptr_t)];

	char optlen_l_[PADL_(l_uintptr_t)]; l_uintptr_t optlen; char optlen_r_[PADR_(l_uintptr_t)];

};

struct linux_clone_args {

	char flags_l_[PADL_(l_int)]; l_int flags; char flags_r_[PADR_(l_int)];

	char stack_l_[PADL_(void *)]; void * stack; char stack_r_[PADR_(void *)];

	char parent_tidptr_l_[PADL_(void *)]; void * parent_tidptr; char parent_tidptr_r_[PADR_(void *)];

	char child_tidptr_l_[PADL_(void *)]; void * child_tidptr; char child_tidptr_r_[PADR_(void *)];

	char tls_l_[PADL_(void *)]; void * tls; char tls_r_[PADR_(void *)];

};

struct linux_fork_args {

	register_t dummy;

};

struct linux_vfork_args {

	register_t dummy;

};

struct linux_execve_args {

	char path_l_[PADL_(char *)]; char * path; char path_r_[PADR_(char *)];

	char argp_l_[PADL_(char **)]; char ** argp; char argp_r_[PADR_(char **)];

	char envp_l_[PADL_(char **)]; char ** envp; char envp_r_[PADR_(char **)];

};

struct linux_exit_args {

	char rval_l_[PADL_(int)]; int rval; char rval_r_[PADR_(int)];

};

struct linux_wait4_args {