xref: /freebsd/sys/i386/linux/linux_machdep.c (revision 1bc85c0dea2887727b9863566041a2d42b5d3f2f)
1146aad74SMarcel Moolenaar /*-
2146aad74SMarcel Moolenaar  * Copyright (c) 2000 Marcel Moolenaar
3146aad74SMarcel Moolenaar  * All rights reserved.
4146aad74SMarcel Moolenaar  *
5146aad74SMarcel Moolenaar  * Redistribution and use in source and binary forms, with or without
6146aad74SMarcel Moolenaar  * modification, are permitted provided that the following conditions
7146aad74SMarcel Moolenaar  * are met:
8146aad74SMarcel Moolenaar  * 1. Redistributions of source code must retain the above copyright
9146aad74SMarcel Moolenaar  *    notice, this list of conditions and the following disclaimer
10146aad74SMarcel Moolenaar  *    in this position and unchanged.
11146aad74SMarcel Moolenaar  * 2. Redistributions in binary form must reproduce the above copyright
12146aad74SMarcel Moolenaar  *    notice, this list of conditions and the following disclaimer in the
13146aad74SMarcel Moolenaar  *    documentation and/or other materials provided with the distribution.
14146aad74SMarcel Moolenaar  * 3. The name of the author may not be used to endorse or promote products
15bc34729cSMarcel Moolenaar  *    derived from this software without specific prior written permission.
16146aad74SMarcel Moolenaar  *
17146aad74SMarcel Moolenaar  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18146aad74SMarcel Moolenaar  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19146aad74SMarcel Moolenaar  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20146aad74SMarcel Moolenaar  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21146aad74SMarcel Moolenaar  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22146aad74SMarcel Moolenaar  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23146aad74SMarcel Moolenaar  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24146aad74SMarcel Moolenaar  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25146aad74SMarcel Moolenaar  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26146aad74SMarcel Moolenaar  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27146aad74SMarcel Moolenaar  */
28146aad74SMarcel Moolenaar 
2927e0099cSDavid E. O'Brien #include <sys/cdefs.h>
3027e0099cSDavid E. O'Brien __FBSDID("$FreeBSD$");
3127e0099cSDavid E. O'Brien 
32146aad74SMarcel Moolenaar #include <sys/param.h>
33146aad74SMarcel Moolenaar #include <sys/systm.h>
347106ca0dSJohn Baldwin #include <sys/lock.h>
35fb919e4dSMark Murray #include <sys/mman.h>
36fb919e4dSMark Murray #include <sys/mutex.h>
37fb919e4dSMark Murray #include <sys/proc.h>
38242fae60SAndrew Gallatin #include <sys/resource.h>
39242fae60SAndrew Gallatin #include <sys/resourcevar.h>
401bc85c0dSDoug Rabson #include <sys/signalvar.h>
41206a5d3aSIan Dowse #include <sys/syscallsubr.h>
42fb919e4dSMark Murray #include <sys/sysproto.h>
43fb919e4dSMark Murray #include <sys/unistd.h>
44146aad74SMarcel Moolenaar 
45146aad74SMarcel Moolenaar #include <machine/frame.h>
46146aad74SMarcel Moolenaar #include <machine/psl.h>
47146aad74SMarcel Moolenaar #include <machine/segments.h>
48146aad74SMarcel Moolenaar #include <machine/sysarch.h>
49146aad74SMarcel Moolenaar 
50242fae60SAndrew Gallatin #include <vm/vm.h>
51242fae60SAndrew Gallatin #include <vm/pmap.h>
52242fae60SAndrew Gallatin #include <vm/vm_map.h>
53242fae60SAndrew Gallatin 
54146aad74SMarcel Moolenaar #include <i386/linux/linux.h>
55ebea8660SMarcel Moolenaar #include <i386/linux/linux_proto.h>
56146aad74SMarcel Moolenaar #include <compat/linux/linux_ipc.h>
57146aad74SMarcel Moolenaar #include <compat/linux/linux_signal.h>
58146aad74SMarcel Moolenaar #include <compat/linux/linux_util.h>
59146aad74SMarcel Moolenaar 
605002a60fSMarcel Moolenaar struct l_descriptor {
615002a60fSMarcel Moolenaar 	l_uint		entry_number;
625002a60fSMarcel Moolenaar 	l_ulong		base_addr;
635002a60fSMarcel Moolenaar 	l_uint		limit;
645002a60fSMarcel Moolenaar 	l_uint		seg_32bit:1;
655002a60fSMarcel Moolenaar 	l_uint		contents:2;
665002a60fSMarcel Moolenaar 	l_uint		read_exec_only:1;
675002a60fSMarcel Moolenaar 	l_uint		limit_in_pages:1;
685002a60fSMarcel Moolenaar 	l_uint		seg_not_present:1;
695002a60fSMarcel Moolenaar 	l_uint		useable:1;
70146aad74SMarcel Moolenaar };
71146aad74SMarcel Moolenaar 
725002a60fSMarcel Moolenaar struct l_old_select_argv {
735002a60fSMarcel Moolenaar 	l_int		nfds;
745002a60fSMarcel Moolenaar 	l_fd_set	*readfds;
755002a60fSMarcel Moolenaar 	l_fd_set	*writefds;
765002a60fSMarcel Moolenaar 	l_fd_set	*exceptfds;
775002a60fSMarcel Moolenaar 	struct l_timeval	*timeout;
78146aad74SMarcel Moolenaar };
79146aad74SMarcel Moolenaar 
80146aad74SMarcel Moolenaar int
81931a7258SAndrew Gallatin linux_to_bsd_sigaltstack(int lsa)
82931a7258SAndrew Gallatin {
83931a7258SAndrew Gallatin 	int bsa = 0;
84931a7258SAndrew Gallatin 
85931a7258SAndrew Gallatin 	if (lsa & LINUX_SS_DISABLE)
86931a7258SAndrew Gallatin 		bsa |= SS_DISABLE;
87931a7258SAndrew Gallatin 	if (lsa & LINUX_SS_ONSTACK)
88931a7258SAndrew Gallatin 		bsa |= SS_ONSTACK;
89931a7258SAndrew Gallatin 	return (bsa);
90931a7258SAndrew Gallatin }
91931a7258SAndrew Gallatin 
92931a7258SAndrew Gallatin int
93931a7258SAndrew Gallatin bsd_to_linux_sigaltstack(int bsa)
94931a7258SAndrew Gallatin {
95931a7258SAndrew Gallatin 	int lsa = 0;
96931a7258SAndrew Gallatin 
97931a7258SAndrew Gallatin 	if (bsa & SS_DISABLE)
98931a7258SAndrew Gallatin 		lsa |= LINUX_SS_DISABLE;
99931a7258SAndrew Gallatin 	if (bsa & SS_ONSTACK)
100931a7258SAndrew Gallatin 		lsa |= LINUX_SS_ONSTACK;
101931a7258SAndrew Gallatin 	return (lsa);
102931a7258SAndrew Gallatin }
103931a7258SAndrew Gallatin 
104931a7258SAndrew Gallatin int
105b40ce416SJulian Elischer linux_execve(struct thread *td, struct linux_execve_args *args)
106146aad74SMarcel Moolenaar {
107146aad74SMarcel Moolenaar 	struct execve_args bsd;
108146aad74SMarcel Moolenaar 	caddr_t sg;
109146aad74SMarcel Moolenaar 
110146aad74SMarcel Moolenaar 	sg = stackgap_init();
111b40ce416SJulian Elischer 	CHECKALTEXIST(td, &sg, args->path);
112146aad74SMarcel Moolenaar 
113146aad74SMarcel Moolenaar #ifdef DEBUG
11424593369SJonathan Lemon 	if (ldebug(execve))
11524593369SJonathan Lemon 		printf(ARGS(execve, "%s"), args->path);
116146aad74SMarcel Moolenaar #endif
117146aad74SMarcel Moolenaar 
118146aad74SMarcel Moolenaar 	bsd.fname = args->path;
119146aad74SMarcel Moolenaar 	bsd.argv = args->argp;
120146aad74SMarcel Moolenaar 	bsd.envv = args->envp;
121b40ce416SJulian Elischer 	return (execve(td, &bsd));
122146aad74SMarcel Moolenaar }
123146aad74SMarcel Moolenaar 
1245002a60fSMarcel Moolenaar struct l_ipc_kludge {
1255002a60fSMarcel Moolenaar 	struct l_msgbuf *msgp;
1265002a60fSMarcel Moolenaar 	l_long msgtyp;
1275002a60fSMarcel Moolenaar };
1285002a60fSMarcel Moolenaar 
129146aad74SMarcel Moolenaar int
130b40ce416SJulian Elischer linux_ipc(struct thread *td, struct linux_ipc_args *args)
131146aad74SMarcel Moolenaar {
1325002a60fSMarcel Moolenaar 
1335002a60fSMarcel Moolenaar 	switch (args->what & 0xFFFF) {
1345002a60fSMarcel Moolenaar 	case LINUX_SEMOP: {
1355002a60fSMarcel Moolenaar 		struct linux_semop_args a;
1365002a60fSMarcel Moolenaar 
1375002a60fSMarcel Moolenaar 		a.semid = args->arg1;
1385002a60fSMarcel Moolenaar 		a.tsops = args->ptr;
1395002a60fSMarcel Moolenaar 		a.nsops = args->arg2;
140b40ce416SJulian Elischer 		return (linux_semop(td, &a));
1415002a60fSMarcel Moolenaar 	}
1425002a60fSMarcel Moolenaar 	case LINUX_SEMGET: {
1435002a60fSMarcel Moolenaar 		struct linux_semget_args a;
1445002a60fSMarcel Moolenaar 
1455002a60fSMarcel Moolenaar 		a.key = args->arg1;
1465002a60fSMarcel Moolenaar 		a.nsems = args->arg2;
1475002a60fSMarcel Moolenaar 		a.semflg = args->arg3;
148b40ce416SJulian Elischer 		return (linux_semget(td, &a));
1495002a60fSMarcel Moolenaar 	}
1505002a60fSMarcel Moolenaar 	case LINUX_SEMCTL: {
1515002a60fSMarcel Moolenaar 		struct linux_semctl_args a;
1525002a60fSMarcel Moolenaar 		int error;
1535002a60fSMarcel Moolenaar 
1545002a60fSMarcel Moolenaar 		a.semid = args->arg1;
1555002a60fSMarcel Moolenaar 		a.semnum = args->arg2;
1565002a60fSMarcel Moolenaar 		a.cmd = args->arg3;
1574b7ef73dSDag-Erling Smørgrav 		error = copyin(args->ptr, &a.arg, sizeof(a.arg));
1585002a60fSMarcel Moolenaar 		if (error)
1595002a60fSMarcel Moolenaar 			return (error);
160b40ce416SJulian Elischer 		return (linux_semctl(td, &a));
1615002a60fSMarcel Moolenaar 	}
1625002a60fSMarcel Moolenaar 	case LINUX_MSGSND: {
1635002a60fSMarcel Moolenaar 		struct linux_msgsnd_args a;
1645002a60fSMarcel Moolenaar 
1655002a60fSMarcel Moolenaar 		a.msqid = args->arg1;
1665002a60fSMarcel Moolenaar 		a.msgp = args->ptr;
1675002a60fSMarcel Moolenaar 		a.msgsz = args->arg2;
1685002a60fSMarcel Moolenaar 		a.msgflg = args->arg3;
169b40ce416SJulian Elischer 		return (linux_msgsnd(td, &a));
1705002a60fSMarcel Moolenaar 	}
1715002a60fSMarcel Moolenaar 	case LINUX_MSGRCV: {
1725002a60fSMarcel Moolenaar 		struct linux_msgrcv_args a;
1735002a60fSMarcel Moolenaar 
1745002a60fSMarcel Moolenaar 		a.msqid = args->arg1;
1755002a60fSMarcel Moolenaar 		a.msgsz = args->arg2;
1765002a60fSMarcel Moolenaar 		a.msgflg = args->arg3;
1775002a60fSMarcel Moolenaar 		if ((args->what >> 16) == 0) {
1785002a60fSMarcel Moolenaar 			struct l_ipc_kludge tmp;
1795002a60fSMarcel Moolenaar 			int error;
1805002a60fSMarcel Moolenaar 
1815002a60fSMarcel Moolenaar 			if (args->ptr == NULL)
1825002a60fSMarcel Moolenaar 				return (EINVAL);
1834b7ef73dSDag-Erling Smørgrav 			error = copyin(args->ptr, &tmp, sizeof(tmp));
1845002a60fSMarcel Moolenaar 			if (error)
1855002a60fSMarcel Moolenaar 				return (error);
1865002a60fSMarcel Moolenaar 			a.msgp = tmp.msgp;
1875002a60fSMarcel Moolenaar 			a.msgtyp = tmp.msgtyp;
1885002a60fSMarcel Moolenaar 		} else {
1895002a60fSMarcel Moolenaar 			a.msgp = args->ptr;
1905002a60fSMarcel Moolenaar 			a.msgtyp = args->arg5;
1915002a60fSMarcel Moolenaar 		}
192b40ce416SJulian Elischer 		return (linux_msgrcv(td, &a));
1935002a60fSMarcel Moolenaar 	}
1945002a60fSMarcel Moolenaar 	case LINUX_MSGGET: {
1955002a60fSMarcel Moolenaar 		struct linux_msgget_args a;
1965002a60fSMarcel Moolenaar 
1975002a60fSMarcel Moolenaar 		a.key = args->arg1;
1985002a60fSMarcel Moolenaar 		a.msgflg = args->arg2;
199b40ce416SJulian Elischer 		return (linux_msgget(td, &a));
2005002a60fSMarcel Moolenaar 	}
2015002a60fSMarcel Moolenaar 	case LINUX_MSGCTL: {
2025002a60fSMarcel Moolenaar 		struct linux_msgctl_args a;
2035002a60fSMarcel Moolenaar 
2045002a60fSMarcel Moolenaar 		a.msqid = args->arg1;
2055002a60fSMarcel Moolenaar 		a.cmd = args->arg2;
2065002a60fSMarcel Moolenaar 		a.buf = args->ptr;
207b40ce416SJulian Elischer 		return (linux_msgctl(td, &a));
2085002a60fSMarcel Moolenaar 	}
2095002a60fSMarcel Moolenaar 	case LINUX_SHMAT: {
2105002a60fSMarcel Moolenaar 		struct linux_shmat_args a;
2115002a60fSMarcel Moolenaar 
2125002a60fSMarcel Moolenaar 		a.shmid = args->arg1;
2135002a60fSMarcel Moolenaar 		a.shmaddr = args->ptr;
2145002a60fSMarcel Moolenaar 		a.shmflg = args->arg2;
2155002a60fSMarcel Moolenaar 		a.raddr = (l_ulong *)args->arg3;
216b40ce416SJulian Elischer 		return (linux_shmat(td, &a));
2175002a60fSMarcel Moolenaar 	}
2185002a60fSMarcel Moolenaar 	case LINUX_SHMDT: {
2195002a60fSMarcel Moolenaar 		struct linux_shmdt_args a;
2205002a60fSMarcel Moolenaar 
2215002a60fSMarcel Moolenaar 		a.shmaddr = args->ptr;
222b40ce416SJulian Elischer 		return (linux_shmdt(td, &a));
2235002a60fSMarcel Moolenaar 	}
2245002a60fSMarcel Moolenaar 	case LINUX_SHMGET: {
2255002a60fSMarcel Moolenaar 		struct linux_shmget_args a;
2265002a60fSMarcel Moolenaar 
2275002a60fSMarcel Moolenaar 		a.key = args->arg1;
2285002a60fSMarcel Moolenaar 		a.size = args->arg2;
2295002a60fSMarcel Moolenaar 		a.shmflg = args->arg3;
230b40ce416SJulian Elischer 		return (linux_shmget(td, &a));
2315002a60fSMarcel Moolenaar 	}
2325002a60fSMarcel Moolenaar 	case LINUX_SHMCTL: {
2335002a60fSMarcel Moolenaar 		struct linux_shmctl_args a;
2345002a60fSMarcel Moolenaar 
2355002a60fSMarcel Moolenaar 		a.shmid = args->arg1;
2365002a60fSMarcel Moolenaar 		a.cmd = args->arg2;
2375002a60fSMarcel Moolenaar 		a.buf = args->ptr;
238b40ce416SJulian Elischer 		return (linux_shmctl(td, &a));
2395002a60fSMarcel Moolenaar 	}
2405002a60fSMarcel Moolenaar 	default:
2415002a60fSMarcel Moolenaar 		break;
242146aad74SMarcel Moolenaar 	}
243146aad74SMarcel Moolenaar 
2445002a60fSMarcel Moolenaar 	return (EINVAL);
245146aad74SMarcel Moolenaar }
246146aad74SMarcel Moolenaar 
247146aad74SMarcel Moolenaar int
248b40ce416SJulian Elischer linux_old_select(struct thread *td, struct linux_old_select_args *args)
249146aad74SMarcel Moolenaar {
2505002a60fSMarcel Moolenaar 	struct l_old_select_argv linux_args;
2515002a60fSMarcel Moolenaar 	struct linux_select_args newsel;
252146aad74SMarcel Moolenaar 	int error;
253146aad74SMarcel Moolenaar 
2545002a60fSMarcel Moolenaar #ifdef DEBUG
2555002a60fSMarcel Moolenaar 	if (ldebug(old_select))
2566aea6777SPeter Wemm 		printf(ARGS(old_select, "%p"), args->ptr);
257146aad74SMarcel Moolenaar #endif
258146aad74SMarcel Moolenaar 
2594b7ef73dSDag-Erling Smørgrav 	error = copyin(args->ptr, &linux_args, sizeof(linux_args));
260146aad74SMarcel Moolenaar 	if (error)
261146aad74SMarcel Moolenaar 		return (error);
262146aad74SMarcel Moolenaar 
263146aad74SMarcel Moolenaar 	newsel.nfds = linux_args.nfds;
264146aad74SMarcel Moolenaar 	newsel.readfds = linux_args.readfds;
265146aad74SMarcel Moolenaar 	newsel.writefds = linux_args.writefds;
266146aad74SMarcel Moolenaar 	newsel.exceptfds = linux_args.exceptfds;
267146aad74SMarcel Moolenaar 	newsel.timeout = linux_args.timeout;
268b40ce416SJulian Elischer 	return (linux_select(td, &newsel));
269146aad74SMarcel Moolenaar }
270146aad74SMarcel Moolenaar 
271146aad74SMarcel Moolenaar int
272b40ce416SJulian Elischer linux_fork(struct thread *td, struct linux_fork_args *args)
273146aad74SMarcel Moolenaar {
274146aad74SMarcel Moolenaar 	int error;
275146aad74SMarcel Moolenaar 
276146aad74SMarcel Moolenaar #ifdef DEBUG
27724593369SJonathan Lemon 	if (ldebug(fork))
27824593369SJonathan Lemon 		printf(ARGS(fork, ""));
279146aad74SMarcel Moolenaar #endif
280146aad74SMarcel Moolenaar 
281b40ce416SJulian Elischer 	if ((error = fork(td, (struct fork_args *)args)) != 0)
282146aad74SMarcel Moolenaar 		return (error);
283146aad74SMarcel Moolenaar 
284b40ce416SJulian Elischer 	if (td->td_retval[1] == 1)
285b40ce416SJulian Elischer 		td->td_retval[0] = 0;
286146aad74SMarcel Moolenaar 	return (0);
287146aad74SMarcel Moolenaar }
288146aad74SMarcel Moolenaar 
289146aad74SMarcel Moolenaar int
290b40ce416SJulian Elischer linux_vfork(struct thread *td, struct linux_vfork_args *args)
291146aad74SMarcel Moolenaar {
292146aad74SMarcel Moolenaar 	int error;
293146aad74SMarcel Moolenaar 
294146aad74SMarcel Moolenaar #ifdef DEBUG
29524593369SJonathan Lemon 	if (ldebug(vfork))
29624593369SJonathan Lemon 		printf(ARGS(vfork, ""));
297146aad74SMarcel Moolenaar #endif
298146aad74SMarcel Moolenaar 
299b40ce416SJulian Elischer 	if ((error = vfork(td, (struct vfork_args *)args)) != 0)
300146aad74SMarcel Moolenaar 		return (error);
301146aad74SMarcel Moolenaar 	/* Are we the child? */
302b40ce416SJulian Elischer 	if (td->td_retval[1] == 1)
303b40ce416SJulian Elischer 		td->td_retval[0] = 0;
304146aad74SMarcel Moolenaar 	return (0);
305146aad74SMarcel Moolenaar }
306146aad74SMarcel Moolenaar 
307146aad74SMarcel Moolenaar #define CLONE_VM	0x100
308146aad74SMarcel Moolenaar #define CLONE_FS	0x200
309146aad74SMarcel Moolenaar #define CLONE_FILES	0x400
310146aad74SMarcel Moolenaar #define CLONE_SIGHAND	0x800
311146aad74SMarcel Moolenaar #define CLONE_PID	0x1000
312146aad74SMarcel Moolenaar 
313146aad74SMarcel Moolenaar int
314b40ce416SJulian Elischer linux_clone(struct thread *td, struct linux_clone_args *args)
315146aad74SMarcel Moolenaar {
3166ad0e7c5SJohn Baldwin 	int error, ff = RFPROC | RFSTOPPED;
317146aad74SMarcel Moolenaar 	struct proc *p2;
3189eb78fcfSJohn Baldwin 	struct thread *td2;
319146aad74SMarcel Moolenaar 	int exit_signal;
320146aad74SMarcel Moolenaar 
321146aad74SMarcel Moolenaar #ifdef DEBUG
32224593369SJonathan Lemon 	if (ldebug(clone)) {
32324593369SJonathan Lemon 		printf(ARGS(clone, "flags %x, stack %x"),
32424593369SJonathan Lemon 		    (unsigned int)args->flags, (unsigned int)args->stack);
325146aad74SMarcel Moolenaar 		if (args->flags & CLONE_PID)
32624593369SJonathan Lemon 			printf(LMSG("CLONE_PID not yet supported"));
32724593369SJonathan Lemon 	}
328146aad74SMarcel Moolenaar #endif
329146aad74SMarcel Moolenaar 
330146aad74SMarcel Moolenaar 	if (!args->stack)
331146aad74SMarcel Moolenaar 		return (EINVAL);
332146aad74SMarcel Moolenaar 
333146aad74SMarcel Moolenaar 	exit_signal = args->flags & 0x000000ff;
334146aad74SMarcel Moolenaar 	if (exit_signal >= LINUX_NSIG)
335146aad74SMarcel Moolenaar 		return (EINVAL);
336146aad74SMarcel Moolenaar 
337146aad74SMarcel Moolenaar 	if (exit_signal <= LINUX_SIGTBLSZ)
338146aad74SMarcel Moolenaar 		exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)];
339146aad74SMarcel Moolenaar 
340146aad74SMarcel Moolenaar 	if (args->flags & CLONE_VM)
341146aad74SMarcel Moolenaar 		ff |= RFMEM;
342146aad74SMarcel Moolenaar 	if (args->flags & CLONE_SIGHAND)
343146aad74SMarcel Moolenaar 		ff |= RFSIGSHARE;
344146aad74SMarcel Moolenaar 	if (!(args->flags & CLONE_FILES))
345146aad74SMarcel Moolenaar 		ff |= RFFDG;
346146aad74SMarcel Moolenaar 
347316ec49aSScott Long 	error = fork1(td, ff, 0, &p2);
3489eb78fcfSJohn Baldwin 	if (error)
3499eb78fcfSJohn Baldwin 		return (error);
3509eb78fcfSJohn Baldwin 
351146aad74SMarcel Moolenaar 
352fdfdfb78SJohn Baldwin 	PROC_LOCK(p2);
353146aad74SMarcel Moolenaar 	p2->p_sigparent = exit_signal;
3549eb78fcfSJohn Baldwin 	PROC_UNLOCK(p2);
3559eb78fcfSJohn Baldwin 	td2 = FIRST_THREAD_IN_PROC(p2);
3569eb78fcfSJohn Baldwin 	td2->td_frame->tf_esp = (unsigned int)args->stack;
357146aad74SMarcel Moolenaar 
358146aad74SMarcel Moolenaar #ifdef DEBUG
35924593369SJonathan Lemon 	if (ldebug(clone))
3609eb78fcfSJohn Baldwin 		printf(LMSG("clone: successful rfork to %ld, stack %p sig = %d"),
3619eb78fcfSJohn Baldwin 		    (long)p2->p_pid, args->stack, exit_signal);
362146aad74SMarcel Moolenaar #endif
363146aad74SMarcel Moolenaar 
3646ad0e7c5SJohn Baldwin 	/*
3656ad0e7c5SJohn Baldwin 	 * Make this runnable after we are finished with it.
3666ad0e7c5SJohn Baldwin 	 */
3676ad0e7c5SJohn Baldwin 	mtx_lock_spin(&sched_lock);
3689eb78fcfSJohn Baldwin 	TD_SET_CAN_RUN(td2);
3692630e4c9SJulian Elischer 	setrunqueue(td2, SRQ_BORING);
3706ad0e7c5SJohn Baldwin 	mtx_unlock_spin(&sched_lock);
3716ad0e7c5SJohn Baldwin 
3729eb78fcfSJohn Baldwin 	td->td_retval[0] = p2->p_pid;
3739eb78fcfSJohn Baldwin 	td->td_retval[1] = 0;
3749eb78fcfSJohn Baldwin 	return (0);
375146aad74SMarcel Moolenaar }
376146aad74SMarcel Moolenaar 
377146aad74SMarcel Moolenaar /* XXX move */
3785002a60fSMarcel Moolenaar struct l_mmap_argv {
3795002a60fSMarcel Moolenaar 	l_caddr_t	addr;
3805002a60fSMarcel Moolenaar 	l_int		len;
3815002a60fSMarcel Moolenaar 	l_int		prot;
3825002a60fSMarcel Moolenaar 	l_int		flags;
3835002a60fSMarcel Moolenaar 	l_int		fd;
3845002a60fSMarcel Moolenaar 	l_int		pos;
385146aad74SMarcel Moolenaar };
386146aad74SMarcel Moolenaar 
387146aad74SMarcel Moolenaar #define STACK_SIZE  (2 * 1024 * 1024)
388146aad74SMarcel Moolenaar #define GUARD_SIZE  (4 * PAGE_SIZE)
389146aad74SMarcel Moolenaar 
3903ad9c842SMaxim Sobolev static int linux_mmap_common(struct thread *, struct l_mmap_argv *);
3913ad9c842SMaxim Sobolev 
3923ad9c842SMaxim Sobolev int
3933ad9c842SMaxim Sobolev linux_mmap2(struct thread *td, struct linux_mmap2_args *args)
3943ad9c842SMaxim Sobolev {
3953ad9c842SMaxim Sobolev 	struct l_mmap_argv linux_args;
3963ad9c842SMaxim Sobolev 
3973ad9c842SMaxim Sobolev #ifdef DEBUG
3983ad9c842SMaxim Sobolev 	if (ldebug(mmap2))
3993ad9c842SMaxim Sobolev 		printf(ARGS(mmap2, "%p, %d, %d, 0x%08x, %d, %d"),
4003ad9c842SMaxim Sobolev 		    (void *)args->addr, args->len, args->prot,
4013ad9c842SMaxim Sobolev 		    args->flags, args->fd, args->pgoff);
4023ad9c842SMaxim Sobolev #endif
4033ad9c842SMaxim Sobolev 
4043ad9c842SMaxim Sobolev 	linux_args.addr = (l_caddr_t)args->addr;
4053ad9c842SMaxim Sobolev 	linux_args.len = args->len;
4063ad9c842SMaxim Sobolev 	linux_args.prot = args->prot;
4073ad9c842SMaxim Sobolev 	linux_args.flags = args->flags;
4083ad9c842SMaxim Sobolev 	linux_args.fd = args->fd;
4093ad9c842SMaxim Sobolev 	linux_args.pos = args->pgoff * PAGE_SIZE;
4103ad9c842SMaxim Sobolev 
4113ad9c842SMaxim Sobolev 	return (linux_mmap_common(td, &linux_args));
4123ad9c842SMaxim Sobolev }
4133ad9c842SMaxim Sobolev 
414146aad74SMarcel Moolenaar int
415b40ce416SJulian Elischer linux_mmap(struct thread *td, struct linux_mmap_args *args)
416146aad74SMarcel Moolenaar {
4173ad9c842SMaxim Sobolev 	int error;
4183ad9c842SMaxim Sobolev 	struct l_mmap_argv linux_args;
4193ad9c842SMaxim Sobolev 
4204b7ef73dSDag-Erling Smørgrav 	error = copyin(args->ptr, &linux_args, sizeof(linux_args));
4213ad9c842SMaxim Sobolev 	if (error)
4223ad9c842SMaxim Sobolev 		return (error);
4233ad9c842SMaxim Sobolev 
4243ad9c842SMaxim Sobolev #ifdef DEBUG
4253ad9c842SMaxim Sobolev 	if (ldebug(mmap))
4263ad9c842SMaxim Sobolev 		printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"),
427b45bbfc3SBruce Evans 		    (void *)linux_args.addr, linux_args.len, linux_args.prot,
428b45bbfc3SBruce Evans 		    linux_args.flags, linux_args.fd, linux_args.pos);
4293ad9c842SMaxim Sobolev #endif
4303ad9c842SMaxim Sobolev 
4313ad9c842SMaxim Sobolev 	return (linux_mmap_common(td, &linux_args));
4323ad9c842SMaxim Sobolev }
4333ad9c842SMaxim Sobolev 
4343ad9c842SMaxim Sobolev static int
4353ad9c842SMaxim Sobolev linux_mmap_common(struct thread *td, struct l_mmap_argv *linux_args)
4363ad9c842SMaxim Sobolev {
437b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
438146aad74SMarcel Moolenaar 	struct mmap_args /* {
439146aad74SMarcel Moolenaar 		caddr_t addr;
440146aad74SMarcel Moolenaar 		size_t len;
441146aad74SMarcel Moolenaar 		int prot;
442146aad74SMarcel Moolenaar 		int flags;
443146aad74SMarcel Moolenaar 		int fd;
444146aad74SMarcel Moolenaar 		long pad;
445146aad74SMarcel Moolenaar 		off_t pos;
446146aad74SMarcel Moolenaar 	} */ bsd_args;
44791d631e5SMatthew N. Dodd 	int error;
448146aad74SMarcel Moolenaar 
44991d631e5SMatthew N. Dodd 	error = 0;
450146aad74SMarcel Moolenaar 	bsd_args.flags = 0;
4513ad9c842SMaxim Sobolev 	if (linux_args->flags & LINUX_MAP_SHARED)
452146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_SHARED;
4533ad9c842SMaxim Sobolev 	if (linux_args->flags & LINUX_MAP_PRIVATE)
454146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_PRIVATE;
4553ad9c842SMaxim Sobolev 	if (linux_args->flags & LINUX_MAP_FIXED)
456146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_FIXED;
4573ad9c842SMaxim Sobolev 	if (linux_args->flags & LINUX_MAP_ANON)
458146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_ANON;
4590cc3ac8bSMatthew Dillon 	else
4600cc3ac8bSMatthew Dillon 		bsd_args.flags |= MAP_NOSYNC;
4613ad9c842SMaxim Sobolev 	if (linux_args->flags & LINUX_MAP_GROWSDOWN) {
462146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_STACK;
463146aad74SMarcel Moolenaar 
464146aad74SMarcel Moolenaar 		/* The linux MAP_GROWSDOWN option does not limit auto
465146aad74SMarcel Moolenaar 		 * growth of the region.  Linux mmap with this option
466146aad74SMarcel Moolenaar 		 * takes as addr the inital BOS, and as len, the initial
467146aad74SMarcel Moolenaar 		 * region size.  It can then grow down from addr without
468146aad74SMarcel Moolenaar 		 * limit.  However, linux threads has an implicit internal
469146aad74SMarcel Moolenaar 		 * limit to stack size of STACK_SIZE.  Its just not
470146aad74SMarcel Moolenaar 		 * enforced explicitly in linux.  But, here we impose
471146aad74SMarcel Moolenaar 		 * a limit of (STACK_SIZE - GUARD_SIZE) on the stack
472146aad74SMarcel Moolenaar 		 * region, since we can do this with our mmap.
473146aad74SMarcel Moolenaar 		 *
474146aad74SMarcel Moolenaar 		 * Our mmap with MAP_STACK takes addr as the maximum
475146aad74SMarcel Moolenaar 		 * downsize limit on BOS, and as len the max size of
476146aad74SMarcel Moolenaar 		 * the region.  It them maps the top SGROWSIZ bytes,
477146aad74SMarcel Moolenaar 		 * and autgrows the region down, up to the limit
478146aad74SMarcel Moolenaar 		 * in addr.
479146aad74SMarcel Moolenaar 		 *
480146aad74SMarcel Moolenaar 		 * If we don't use the MAP_STACK option, the effect
481146aad74SMarcel Moolenaar 		 * of this code is to allocate a stack region of a
482146aad74SMarcel Moolenaar 		 * fixed size of (STACK_SIZE - GUARD_SIZE).
483146aad74SMarcel Moolenaar 		 */
484146aad74SMarcel Moolenaar 
485146aad74SMarcel Moolenaar 		/* This gives us TOS */
4863ad9c842SMaxim Sobolev 		bsd_args.addr = linux_args->addr + linux_args->len;
487146aad74SMarcel Moolenaar 
488242fae60SAndrew Gallatin 		if (bsd_args.addr > p->p_vmspace->vm_maxsaddr) {
489242fae60SAndrew Gallatin 			/* Some linux apps will attempt to mmap
490242fae60SAndrew Gallatin 			 * thread stacks near the top of their
491242fae60SAndrew Gallatin 			 * address space.  If their TOS is greater
492242fae60SAndrew Gallatin 			 * than vm_maxsaddr, vm_map_growstack()
493242fae60SAndrew Gallatin 			 * will confuse the thread stack with the
494242fae60SAndrew Gallatin 			 * process stack and deliver a SEGV if they
495242fae60SAndrew Gallatin 			 * attempt to grow the thread stack past their
496242fae60SAndrew Gallatin 			 * current stacksize rlimit.  To avoid this,
497242fae60SAndrew Gallatin 			 * adjust vm_maxsaddr upwards to reflect
498242fae60SAndrew Gallatin 			 * the current stacksize rlimit rather
499242fae60SAndrew Gallatin 			 * than the maximum possible stacksize.
500242fae60SAndrew Gallatin 			 * It would be better to adjust the
501242fae60SAndrew Gallatin 			 * mmap'ed region, but some apps do not check
502242fae60SAndrew Gallatin 			 * mmap's return value.
503242fae60SAndrew Gallatin 			 */
50491d5354aSJohn Baldwin 			PROC_LOCK(p);
505242fae60SAndrew Gallatin 			p->p_vmspace->vm_maxsaddr = (char *)USRSTACK -
50691d5354aSJohn Baldwin 			    lim_cur(p, RLIMIT_STACK);
50791d5354aSJohn Baldwin 			PROC_UNLOCK(p);
508242fae60SAndrew Gallatin 		}
509242fae60SAndrew Gallatin 
510146aad74SMarcel Moolenaar 		/* This gives us our maximum stack size */
5113ad9c842SMaxim Sobolev 		if (linux_args->len > STACK_SIZE - GUARD_SIZE)
5123ad9c842SMaxim Sobolev 			bsd_args.len = linux_args->len;
513146aad74SMarcel Moolenaar 		else
514146aad74SMarcel Moolenaar 			bsd_args.len  = STACK_SIZE - GUARD_SIZE;
515146aad74SMarcel Moolenaar 
516146aad74SMarcel Moolenaar 		/* This gives us a new BOS.  If we're using VM_STACK, then
517146aad74SMarcel Moolenaar 		 * mmap will just map the top SGROWSIZ bytes, and let
518146aad74SMarcel Moolenaar 		 * the stack grow down to the limit at BOS.  If we're
519146aad74SMarcel Moolenaar 		 * not using VM_STACK we map the full stack, since we
520146aad74SMarcel Moolenaar 		 * don't have a way to autogrow it.
521146aad74SMarcel Moolenaar 		 */
522146aad74SMarcel Moolenaar 		bsd_args.addr -= bsd_args.len;
523146aad74SMarcel Moolenaar 	} else {
5243ad9c842SMaxim Sobolev 		bsd_args.addr = linux_args->addr;
5253ad9c842SMaxim Sobolev 		bsd_args.len  = linux_args->len;
526146aad74SMarcel Moolenaar 	}
527146aad74SMarcel Moolenaar 
5283ad9c842SMaxim Sobolev 	bsd_args.prot = linux_args->prot | PROT_READ;	/* always required */
5293ad9c842SMaxim Sobolev 	if (linux_args->flags & LINUX_MAP_ANON)
530146aad74SMarcel Moolenaar 		bsd_args.fd = -1;
531146aad74SMarcel Moolenaar 	else
5323ad9c842SMaxim Sobolev 		bsd_args.fd = linux_args->fd;
5333ad9c842SMaxim Sobolev 	bsd_args.pos = linux_args->pos;
534146aad74SMarcel Moolenaar 	bsd_args.pad = 0;
535146aad74SMarcel Moolenaar 
536146aad74SMarcel Moolenaar #ifdef DEBUG
53724593369SJonathan Lemon 	if (ldebug(mmap))
53891d631e5SMatthew N. Dodd 		printf("-> %s(%p, %d, %d, 0x%08x, %d, 0x%x)\n",
53991d631e5SMatthew N. Dodd 		    __func__,
54024593369SJonathan Lemon 		    (void *)bsd_args.addr, bsd_args.len, bsd_args.prot,
54124593369SJonathan Lemon 		    bsd_args.flags, bsd_args.fd, (int)bsd_args.pos);
542146aad74SMarcel Moolenaar #endif
54391d631e5SMatthew N. Dodd 	error = mmap(td, &bsd_args);
54491d631e5SMatthew N. Dodd #ifdef DEBUG
54591d631e5SMatthew N. Dodd 	if (ldebug(mmap))
54691d631e5SMatthew N. Dodd 		printf("-> %s() return: 0x%x (0x%08x)\n",
54791d631e5SMatthew N. Dodd 			__func__, error, (u_int)td->td_retval[0]);
54891d631e5SMatthew N. Dodd #endif
54991d631e5SMatthew N. Dodd 	return (error);
550146aad74SMarcel Moolenaar }
551146aad74SMarcel Moolenaar 
552146aad74SMarcel Moolenaar int
553b40ce416SJulian Elischer linux_pipe(struct thread *td, struct linux_pipe_args *args)
554146aad74SMarcel Moolenaar {
555146aad74SMarcel Moolenaar 	int error;
556146aad74SMarcel Moolenaar 	int reg_edx;
557146aad74SMarcel Moolenaar 
558146aad74SMarcel Moolenaar #ifdef DEBUG
55924593369SJonathan Lemon 	if (ldebug(pipe))
56024593369SJonathan Lemon 		printf(ARGS(pipe, "*"));
561146aad74SMarcel Moolenaar #endif
562146aad74SMarcel Moolenaar 
563b40ce416SJulian Elischer 	reg_edx = td->td_retval[1];
564b40ce416SJulian Elischer 	error = pipe(td, 0);
565146aad74SMarcel Moolenaar 	if (error) {
566b40ce416SJulian Elischer 		td->td_retval[1] = reg_edx;
567146aad74SMarcel Moolenaar 		return (error);
568146aad74SMarcel Moolenaar 	}
569146aad74SMarcel Moolenaar 
570b40ce416SJulian Elischer 	error = copyout(td->td_retval, args->pipefds, 2*sizeof(int));
571146aad74SMarcel Moolenaar 	if (error) {
572b40ce416SJulian Elischer 		td->td_retval[1] = reg_edx;
573146aad74SMarcel Moolenaar 		return (error);
574146aad74SMarcel Moolenaar 	}
575146aad74SMarcel Moolenaar 
576b40ce416SJulian Elischer 	td->td_retval[1] = reg_edx;
577b40ce416SJulian Elischer 	td->td_retval[0] = 0;
578146aad74SMarcel Moolenaar 	return (0);
579146aad74SMarcel Moolenaar }
580146aad74SMarcel Moolenaar 
581146aad74SMarcel Moolenaar int
582b40ce416SJulian Elischer linux_ioperm(struct thread *td, struct linux_ioperm_args *args)
583146aad74SMarcel Moolenaar {
584146aad74SMarcel Moolenaar 	struct sysarch_args sa;
585146aad74SMarcel Moolenaar 	struct i386_ioperm_args *iia;
586146aad74SMarcel Moolenaar 	caddr_t sg;
587146aad74SMarcel Moolenaar 
588146aad74SMarcel Moolenaar 	sg = stackgap_init();
589146aad74SMarcel Moolenaar 	iia = stackgap_alloc(&sg, sizeof(struct i386_ioperm_args));
590146aad74SMarcel Moolenaar 	iia->start = args->start;
591146aad74SMarcel Moolenaar 	iia->length = args->length;
592146aad74SMarcel Moolenaar 	iia->enable = args->enable;
593146aad74SMarcel Moolenaar 	sa.op = I386_SET_IOPERM;
594146aad74SMarcel Moolenaar 	sa.parms = (char *)iia;
595b40ce416SJulian Elischer 	return (sysarch(td, &sa));
596146aad74SMarcel Moolenaar }
597146aad74SMarcel Moolenaar 
598146aad74SMarcel Moolenaar int
599b40ce416SJulian Elischer linux_iopl(struct thread *td, struct linux_iopl_args *args)
600146aad74SMarcel Moolenaar {
601146aad74SMarcel Moolenaar 	int error;
602146aad74SMarcel Moolenaar 
603146aad74SMarcel Moolenaar 	if (args->level < 0 || args->level > 3)
604146aad74SMarcel Moolenaar 		return (EINVAL);
60544731cabSJohn Baldwin 	if ((error = suser(td)) != 0)
606146aad74SMarcel Moolenaar 		return (error);
607a854ed98SJohn Baldwin 	if ((error = securelevel_gt(td->td_ucred, 0)) != 0)
60841c42188SRobert Watson 		return (error);
609b40ce416SJulian Elischer 	td->td_frame->tf_eflags = (td->td_frame->tf_eflags & ~PSL_IOPL) |
610146aad74SMarcel Moolenaar 	    (args->level * (PSL_IOPL / 3));
611146aad74SMarcel Moolenaar 	return (0);
612146aad74SMarcel Moolenaar }
613146aad74SMarcel Moolenaar 
614146aad74SMarcel Moolenaar int
615b07cd97eSMark Murray linux_modify_ldt(struct thread *td, struct linux_modify_ldt_args *uap)
616146aad74SMarcel Moolenaar {
617146aad74SMarcel Moolenaar 	int error;
618146aad74SMarcel Moolenaar 	caddr_t sg;
619146aad74SMarcel Moolenaar 	struct sysarch_args args;
620146aad74SMarcel Moolenaar 	struct i386_ldt_args *ldt;
6215002a60fSMarcel Moolenaar 	struct l_descriptor ld;
622146aad74SMarcel Moolenaar 	union descriptor *desc;
623146aad74SMarcel Moolenaar 
624146aad74SMarcel Moolenaar 	sg = stackgap_init();
625146aad74SMarcel Moolenaar 
626146aad74SMarcel Moolenaar 	if (uap->ptr == NULL)
627146aad74SMarcel Moolenaar 		return (EINVAL);
628146aad74SMarcel Moolenaar 
629146aad74SMarcel Moolenaar 	switch (uap->func) {
630146aad74SMarcel Moolenaar 	case 0x00: /* read_ldt */
631146aad74SMarcel Moolenaar 		ldt = stackgap_alloc(&sg, sizeof(*ldt));
632146aad74SMarcel Moolenaar 		ldt->start = 0;
633146aad74SMarcel Moolenaar 		ldt->descs = uap->ptr;
634146aad74SMarcel Moolenaar 		ldt->num = uap->bytecount / sizeof(union descriptor);
635146aad74SMarcel Moolenaar 		args.op = I386_GET_LDT;
636146aad74SMarcel Moolenaar 		args.parms = (char*)ldt;
637b40ce416SJulian Elischer 		error = sysarch(td, &args);
638b40ce416SJulian Elischer 		td->td_retval[0] *= sizeof(union descriptor);
639146aad74SMarcel Moolenaar 		break;
640146aad74SMarcel Moolenaar 	case 0x01: /* write_ldt */
641146aad74SMarcel Moolenaar 	case 0x11: /* write_ldt */
642146aad74SMarcel Moolenaar 		if (uap->bytecount != sizeof(ld))
643146aad74SMarcel Moolenaar 			return (EINVAL);
644146aad74SMarcel Moolenaar 
645146aad74SMarcel Moolenaar 		error = copyin(uap->ptr, &ld, sizeof(ld));
646146aad74SMarcel Moolenaar 		if (error)
647146aad74SMarcel Moolenaar 			return (error);
648146aad74SMarcel Moolenaar 
649146aad74SMarcel Moolenaar 		ldt = stackgap_alloc(&sg, sizeof(*ldt));
650146aad74SMarcel Moolenaar 		desc = stackgap_alloc(&sg, sizeof(*desc));
651146aad74SMarcel Moolenaar 		ldt->start = ld.entry_number;
652146aad74SMarcel Moolenaar 		ldt->descs = desc;
653146aad74SMarcel Moolenaar 		ldt->num = 1;
654146aad74SMarcel Moolenaar 		desc->sd.sd_lolimit = (ld.limit & 0x0000ffff);
655146aad74SMarcel Moolenaar 		desc->sd.sd_hilimit = (ld.limit & 0x000f0000) >> 16;
656146aad74SMarcel Moolenaar 		desc->sd.sd_lobase = (ld.base_addr & 0x00ffffff);
657146aad74SMarcel Moolenaar 		desc->sd.sd_hibase = (ld.base_addr & 0xff000000) >> 24;
658146aad74SMarcel Moolenaar 		desc->sd.sd_type = SDT_MEMRO | ((ld.read_exec_only ^ 1) << 1) |
659146aad74SMarcel Moolenaar 			(ld.contents << 2);
660146aad74SMarcel Moolenaar 		desc->sd.sd_dpl = 3;
661146aad74SMarcel Moolenaar 		desc->sd.sd_p = (ld.seg_not_present ^ 1);
662146aad74SMarcel Moolenaar 		desc->sd.sd_xx = 0;
663146aad74SMarcel Moolenaar 		desc->sd.sd_def32 = ld.seg_32bit;
664146aad74SMarcel Moolenaar 		desc->sd.sd_gran = ld.limit_in_pages;
665146aad74SMarcel Moolenaar 		args.op = I386_SET_LDT;
666146aad74SMarcel Moolenaar 		args.parms = (char*)ldt;
667b40ce416SJulian Elischer 		error = sysarch(td, &args);
668146aad74SMarcel Moolenaar 		break;
669146aad74SMarcel Moolenaar 	default:
670146aad74SMarcel Moolenaar 		error = EINVAL;
671146aad74SMarcel Moolenaar 		break;
672146aad74SMarcel Moolenaar 	}
673146aad74SMarcel Moolenaar 
674146aad74SMarcel Moolenaar 	if (error == EOPNOTSUPP) {
675146aad74SMarcel Moolenaar 		printf("linux: modify_ldt needs kernel option USER_LDT\n");
676146aad74SMarcel Moolenaar 		error = ENOSYS;
677146aad74SMarcel Moolenaar 	}
678146aad74SMarcel Moolenaar 
679146aad74SMarcel Moolenaar 	return (error);
680146aad74SMarcel Moolenaar }
681146aad74SMarcel Moolenaar 
682146aad74SMarcel Moolenaar int
683b40ce416SJulian Elischer linux_sigaction(struct thread *td, struct linux_sigaction_args *args)
684146aad74SMarcel Moolenaar {
6855002a60fSMarcel Moolenaar 	l_osigaction_t osa;
6865002a60fSMarcel Moolenaar 	l_sigaction_t act, oact;
687146aad74SMarcel Moolenaar 	int error;
688146aad74SMarcel Moolenaar 
689146aad74SMarcel Moolenaar #ifdef DEBUG
69024593369SJonathan Lemon 	if (ldebug(sigaction))
69124593369SJonathan Lemon 		printf(ARGS(sigaction, "%d, %p, %p"),
692146aad74SMarcel Moolenaar 		    args->sig, (void *)args->nsa, (void *)args->osa);
693146aad74SMarcel Moolenaar #endif
694146aad74SMarcel Moolenaar 
695146aad74SMarcel Moolenaar 	if (args->nsa != NULL) {
6964b7ef73dSDag-Erling Smørgrav 		error = copyin(args->nsa, &osa, sizeof(l_osigaction_t));
697146aad74SMarcel Moolenaar 		if (error)
698146aad74SMarcel Moolenaar 			return (error);
699146aad74SMarcel Moolenaar 		act.lsa_handler = osa.lsa_handler;
700146aad74SMarcel Moolenaar 		act.lsa_flags = osa.lsa_flags;
701146aad74SMarcel Moolenaar 		act.lsa_restorer = osa.lsa_restorer;
702146aad74SMarcel Moolenaar 		LINUX_SIGEMPTYSET(act.lsa_mask);
703146aad74SMarcel Moolenaar 		act.lsa_mask.__bits[0] = osa.lsa_mask;
704146aad74SMarcel Moolenaar 	}
705146aad74SMarcel Moolenaar 
706b40ce416SJulian Elischer 	error = linux_do_sigaction(td, args->sig, args->nsa ? &act : NULL,
707146aad74SMarcel Moolenaar 	    args->osa ? &oact : NULL);
708146aad74SMarcel Moolenaar 
709146aad74SMarcel Moolenaar 	if (args->osa != NULL && !error) {
710146aad74SMarcel Moolenaar 		osa.lsa_handler = oact.lsa_handler;
711146aad74SMarcel Moolenaar 		osa.lsa_flags = oact.lsa_flags;
712146aad74SMarcel Moolenaar 		osa.lsa_restorer = oact.lsa_restorer;
713146aad74SMarcel Moolenaar 		osa.lsa_mask = oact.lsa_mask.__bits[0];
7144b7ef73dSDag-Erling Smørgrav 		error = copyout(&osa, args->osa, sizeof(l_osigaction_t));
715146aad74SMarcel Moolenaar 	}
716146aad74SMarcel Moolenaar 
717146aad74SMarcel Moolenaar 	return (error);
718146aad74SMarcel Moolenaar }
719146aad74SMarcel Moolenaar 
720146aad74SMarcel Moolenaar /*
721146aad74SMarcel Moolenaar  * Linux has two extra args, restart and oldmask.  We dont use these,
722146aad74SMarcel Moolenaar  * but it seems that "restart" is actually a context pointer that
723146aad74SMarcel Moolenaar  * enables the signal to happen with a different register set.
724146aad74SMarcel Moolenaar  */
725146aad74SMarcel Moolenaar int
726b40ce416SJulian Elischer linux_sigsuspend(struct thread *td, struct linux_sigsuspend_args *args)
727146aad74SMarcel Moolenaar {
728206a5d3aSIan Dowse 	sigset_t sigmask;
7295002a60fSMarcel Moolenaar 	l_sigset_t mask;
730146aad74SMarcel Moolenaar 
731146aad74SMarcel Moolenaar #ifdef DEBUG
73224593369SJonathan Lemon 	if (ldebug(sigsuspend))
73324593369SJonathan Lemon 		printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask);
734146aad74SMarcel Moolenaar #endif
735146aad74SMarcel Moolenaar 
736146aad74SMarcel Moolenaar 	LINUX_SIGEMPTYSET(mask);
737146aad74SMarcel Moolenaar 	mask.__bits[0] = args->mask;
738206a5d3aSIan Dowse 	linux_to_bsd_sigset(&mask, &sigmask);
739206a5d3aSIan Dowse 	return (kern_sigsuspend(td, sigmask));
740146aad74SMarcel Moolenaar }
741146aad74SMarcel Moolenaar 
742146aad74SMarcel Moolenaar int
743b07cd97eSMark Murray linux_rt_sigsuspend(struct thread *td, struct linux_rt_sigsuspend_args *uap)
744146aad74SMarcel Moolenaar {
7455002a60fSMarcel Moolenaar 	l_sigset_t lmask;
746206a5d3aSIan Dowse 	sigset_t sigmask;
747146aad74SMarcel Moolenaar 	int error;
748146aad74SMarcel Moolenaar 
749146aad74SMarcel Moolenaar #ifdef DEBUG
75024593369SJonathan Lemon 	if (ldebug(rt_sigsuspend))
75124593369SJonathan Lemon 		printf(ARGS(rt_sigsuspend, "%p, %d"),
752146aad74SMarcel Moolenaar 		    (void *)uap->newset, uap->sigsetsize);
753146aad74SMarcel Moolenaar #endif
754146aad74SMarcel Moolenaar 
7555002a60fSMarcel Moolenaar 	if (uap->sigsetsize != sizeof(l_sigset_t))
756146aad74SMarcel Moolenaar 		return (EINVAL);
757146aad74SMarcel Moolenaar 
7585002a60fSMarcel Moolenaar 	error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
759146aad74SMarcel Moolenaar 	if (error)
760146aad74SMarcel Moolenaar 		return (error);
761146aad74SMarcel Moolenaar 
762206a5d3aSIan Dowse 	linux_to_bsd_sigset(&lmask, &sigmask);
763206a5d3aSIan Dowse 	return (kern_sigsuspend(td, sigmask));
764146aad74SMarcel Moolenaar }
765146aad74SMarcel Moolenaar 
766146aad74SMarcel Moolenaar int
767b40ce416SJulian Elischer linux_pause(struct thread *td, struct linux_pause_args *args)
768146aad74SMarcel Moolenaar {
769b40ce416SJulian Elischer 	struct proc *p = td->td_proc;
770206a5d3aSIan Dowse 	sigset_t sigmask;
771146aad74SMarcel Moolenaar 
772146aad74SMarcel Moolenaar #ifdef DEBUG
77324593369SJonathan Lemon 	if (ldebug(pause))
77424593369SJonathan Lemon 		printf(ARGS(pause, ""));
775146aad74SMarcel Moolenaar #endif
776146aad74SMarcel Moolenaar 
777fdfdfb78SJohn Baldwin 	PROC_LOCK(p);
7784093529dSJeff Roberson 	sigmask = td->td_sigmask;
779fdfdfb78SJohn Baldwin 	PROC_UNLOCK(p);
780206a5d3aSIan Dowse 	return (kern_sigsuspend(td, sigmask));
781146aad74SMarcel Moolenaar }
782146aad74SMarcel Moolenaar 
783146aad74SMarcel Moolenaar int
784b40ce416SJulian Elischer linux_sigaltstack(struct thread *td, struct linux_sigaltstack_args *uap)
785146aad74SMarcel Moolenaar {
786206a5d3aSIan Dowse 	stack_t ss, oss;
7875002a60fSMarcel Moolenaar 	l_stack_t lss;
788146aad74SMarcel Moolenaar 	int error;
789146aad74SMarcel Moolenaar 
790146aad74SMarcel Moolenaar #ifdef DEBUG
79124593369SJonathan Lemon 	if (ldebug(sigaltstack))
79224593369SJonathan Lemon 		printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss);
793146aad74SMarcel Moolenaar #endif
794146aad74SMarcel Moolenaar 
795206a5d3aSIan Dowse 	if (uap->uss != NULL) {
7965002a60fSMarcel Moolenaar 		error = copyin(uap->uss, &lss, sizeof(l_stack_t));
797146aad74SMarcel Moolenaar 		if (error)
798146aad74SMarcel Moolenaar 			return (error);
799146aad74SMarcel Moolenaar 
800206a5d3aSIan Dowse 		ss.ss_sp = lss.ss_sp;
801206a5d3aSIan Dowse 		ss.ss_size = lss.ss_size;
802206a5d3aSIan Dowse 		ss.ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
803931a7258SAndrew Gallatin 	}
804ef36ad69SJohn Baldwin 	error = kern_sigaltstack(td, (uap->uss != NULL) ? &ss : NULL,
805ef36ad69SJohn Baldwin 	    (uap->uoss != NULL) ? &oss : NULL);
806206a5d3aSIan Dowse 	if (!error && uap->uoss != NULL) {
807206a5d3aSIan Dowse 		lss.ss_sp = oss.ss_sp;
808206a5d3aSIan Dowse 		lss.ss_size = oss.ss_size;
809206a5d3aSIan Dowse 		lss.ss_flags = bsd_to_linux_sigaltstack(oss.ss_flags);
8105002a60fSMarcel Moolenaar 		error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
811146aad74SMarcel Moolenaar 	}
812146aad74SMarcel Moolenaar 
813146aad74SMarcel Moolenaar 	return (error);
814146aad74SMarcel Moolenaar }
8153ad9c842SMaxim Sobolev 
8163ad9c842SMaxim Sobolev int
8173ad9c842SMaxim Sobolev linux_ftruncate64(struct thread *td, struct linux_ftruncate64_args *args)
8183ad9c842SMaxim Sobolev {
8193ad9c842SMaxim Sobolev 	struct ftruncate_args sa;
8203ad9c842SMaxim Sobolev 
8213ad9c842SMaxim Sobolev #ifdef DEBUG
8223ad9c842SMaxim Sobolev 	if (ldebug(ftruncate64))
823b45bbfc3SBruce Evans 		printf(ARGS(ftruncate64, "%u, %jd"), args->fd,
824b45bbfc3SBruce Evans 		    (intmax_t)args->length);
8253ad9c842SMaxim Sobolev #endif
8263ad9c842SMaxim Sobolev 
8273ad9c842SMaxim Sobolev 	sa.fd = args->fd;
8283ad9c842SMaxim Sobolev 	sa.pad = 0;
8293ad9c842SMaxim Sobolev 	sa.length = args->length;
8303ad9c842SMaxim Sobolev 	return ftruncate(td, &sa);
8313ad9c842SMaxim Sobolev }
8321bc85c0dSDoug Rabson 
8331bc85c0dSDoug Rabson int
8341bc85c0dSDoug Rabson linux_set_thread_area(struct thread *td, struct linux_set_thread_area_args *args)
8351bc85c0dSDoug Rabson {
8361bc85c0dSDoug Rabson 	/*
8371bc85c0dSDoug Rabson 	 * Return an error code instead of raising a SIGSYS so that
8381bc85c0dSDoug Rabson 	 * the caller will fall back to simpler LDT methods.
8391bc85c0dSDoug Rabson 	 */
8401bc85c0dSDoug Rabson 	return (ENOSYS);
8411bc85c0dSDoug Rabson }
8421bc85c0dSDoug Rabson 
8431bc85c0dSDoug Rabson int
8441bc85c0dSDoug Rabson linux_gettid(struct thread *td, struct linux_gettid_args *args)
8451bc85c0dSDoug Rabson {
8461bc85c0dSDoug Rabson 
8471bc85c0dSDoug Rabson 	td->td_retval[0] = td->td_proc->p_pid;
8481bc85c0dSDoug Rabson 	return (0);
8491bc85c0dSDoug Rabson }
8501bc85c0dSDoug Rabson 
8511bc85c0dSDoug Rabson int
8521bc85c0dSDoug Rabson linux_tkill(struct thread *td, struct linux_tkill_args *args)
8531bc85c0dSDoug Rabson {
8541bc85c0dSDoug Rabson 
8551bc85c0dSDoug Rabson 	return (linux_kill(td, (struct linux_kill_args *) args));
8561bc85c0dSDoug Rabson }
8571bc85c0dSDoug Rabson 
858