xref: /freebsd/sys/i386/linux/linux_machdep.c (revision ebea8660558a023284f04ba30aa2e6e173d7d544)
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  * $FreeBSD$
29146aad74SMarcel Moolenaar  */
30146aad74SMarcel Moolenaar 
31146aad74SMarcel Moolenaar #include <sys/param.h>
32146aad74SMarcel Moolenaar #include <sys/mman.h>
33146aad74SMarcel Moolenaar #include <sys/proc.h>
34146aad74SMarcel Moolenaar #include <sys/sysproto.h>
35146aad74SMarcel Moolenaar #include <sys/systm.h>
36146aad74SMarcel Moolenaar #include <sys/unistd.h>
37242fae60SAndrew Gallatin #include <sys/resource.h>
38242fae60SAndrew Gallatin #include <sys/resourcevar.h>
39146aad74SMarcel Moolenaar 
40146aad74SMarcel Moolenaar #include <machine/frame.h>
41146aad74SMarcel Moolenaar #include <machine/psl.h>
42146aad74SMarcel Moolenaar #include <machine/segments.h>
43146aad74SMarcel Moolenaar #include <machine/sysarch.h>
44146aad74SMarcel Moolenaar 
45242fae60SAndrew Gallatin #include <vm/vm.h>
46242fae60SAndrew Gallatin #include <sys/lock.h>
47242fae60SAndrew Gallatin #include <vm/pmap.h>
48242fae60SAndrew Gallatin #include <vm/vm_map.h>
49242fae60SAndrew Gallatin 
50146aad74SMarcel Moolenaar #include <i386/linux/linux.h>
51ebea8660SMarcel Moolenaar #include <i386/linux/linux_proto.h>
52146aad74SMarcel Moolenaar #include <compat/linux/linux_ipc.h>
53146aad74SMarcel Moolenaar #include <compat/linux/linux_signal.h>
54146aad74SMarcel Moolenaar #include <compat/linux/linux_util.h>
55146aad74SMarcel Moolenaar 
56146aad74SMarcel Moolenaar struct linux_descriptor {
57146aad74SMarcel Moolenaar 	unsigned int  entry_number;
58146aad74SMarcel Moolenaar 	unsigned long base_addr;
59146aad74SMarcel Moolenaar 	unsigned int  limit;
60146aad74SMarcel Moolenaar 	unsigned int  seg_32bit:1;
61146aad74SMarcel Moolenaar 	unsigned int  contents:2;
62146aad74SMarcel Moolenaar 	unsigned int  read_exec_only:1;
63146aad74SMarcel Moolenaar 	unsigned int  limit_in_pages:1;
64146aad74SMarcel Moolenaar 	unsigned int  seg_not_present:1;
65146aad74SMarcel Moolenaar 	unsigned int  useable:1;
66146aad74SMarcel Moolenaar };
67146aad74SMarcel Moolenaar 
68146aad74SMarcel Moolenaar struct linux_select_argv {
69146aad74SMarcel Moolenaar 	int nfds;
70146aad74SMarcel Moolenaar 	fd_set *readfds;
71146aad74SMarcel Moolenaar 	fd_set *writefds;
72146aad74SMarcel Moolenaar 	fd_set *exceptfds;
73146aad74SMarcel Moolenaar 	struct timeval *timeout;
74146aad74SMarcel Moolenaar };
75146aad74SMarcel Moolenaar 
76146aad74SMarcel Moolenaar int
77931a7258SAndrew Gallatin linux_to_bsd_sigaltstack(int lsa)
78931a7258SAndrew Gallatin {
79931a7258SAndrew Gallatin 	int bsa = 0;
80931a7258SAndrew Gallatin 
81931a7258SAndrew Gallatin 	if (lsa & LINUX_SS_DISABLE)
82931a7258SAndrew Gallatin 		bsa |= SS_DISABLE;
83931a7258SAndrew Gallatin 	if (lsa & LINUX_SS_ONSTACK)
84931a7258SAndrew Gallatin 		bsa |= SS_ONSTACK;
85931a7258SAndrew Gallatin 	if (lsa == LINUX_SS_ONSTACK_BC)
86931a7258SAndrew Gallatin 		bsa = SS_ONSTACK;
87931a7258SAndrew Gallatin 	return (bsa);
88931a7258SAndrew Gallatin }
89931a7258SAndrew Gallatin 
90931a7258SAndrew Gallatin int
91931a7258SAndrew Gallatin bsd_to_linux_sigaltstack(int bsa)
92931a7258SAndrew Gallatin {
93931a7258SAndrew Gallatin 	int lsa = 0;
94931a7258SAndrew Gallatin 
95931a7258SAndrew Gallatin 	if (bsa & SS_DISABLE)
96931a7258SAndrew Gallatin 		lsa |= LINUX_SS_DISABLE;
97931a7258SAndrew Gallatin 	if (bsa & SS_ONSTACK)
98931a7258SAndrew Gallatin 		lsa |= LINUX_SS_ONSTACK;
99931a7258SAndrew Gallatin 	return (lsa);
100931a7258SAndrew Gallatin }
101931a7258SAndrew Gallatin 
102931a7258SAndrew Gallatin int
103146aad74SMarcel Moolenaar linux_execve(struct proc *p, struct linux_execve_args *args)
104146aad74SMarcel Moolenaar {
105146aad74SMarcel Moolenaar 	struct execve_args bsd;
106146aad74SMarcel Moolenaar 	caddr_t sg;
107146aad74SMarcel Moolenaar 
108146aad74SMarcel Moolenaar 	sg = stackgap_init();
109146aad74SMarcel Moolenaar 	CHECKALTEXIST(p, &sg, args->path);
110146aad74SMarcel Moolenaar 
111146aad74SMarcel Moolenaar #ifdef DEBUG
112146aad74SMarcel Moolenaar         printf("Linux-emul(%d): execve(%s)\n",
113146aad74SMarcel Moolenaar 	    p->p_pid, args->path);
114146aad74SMarcel Moolenaar #endif
115146aad74SMarcel Moolenaar 
116146aad74SMarcel Moolenaar 	bsd.fname = args->path;
117146aad74SMarcel Moolenaar 	bsd.argv = args->argp;
118146aad74SMarcel Moolenaar 	bsd.envv = args->envp;
119146aad74SMarcel Moolenaar 	return (execve(p, &bsd));
120146aad74SMarcel Moolenaar }
121146aad74SMarcel Moolenaar 
122146aad74SMarcel Moolenaar int
123146aad74SMarcel Moolenaar linux_ipc(struct proc *p, struct linux_ipc_args *args)
124146aad74SMarcel Moolenaar {
125146aad74SMarcel Moolenaar 	switch (args->what) {
126146aad74SMarcel Moolenaar 	case LINUX_SEMOP:
127146aad74SMarcel Moolenaar 		return (linux_semop(p, args));
128146aad74SMarcel Moolenaar 	case LINUX_SEMGET:
129146aad74SMarcel Moolenaar 		return (linux_semget(p, args));
130146aad74SMarcel Moolenaar 	case LINUX_SEMCTL:
131146aad74SMarcel Moolenaar 		return (linux_semctl(p, args));
132146aad74SMarcel Moolenaar 	case LINUX_MSGSND:
133146aad74SMarcel Moolenaar 		return (linux_msgsnd(p, args));
134146aad74SMarcel Moolenaar 	case LINUX_MSGRCV:
135146aad74SMarcel Moolenaar 		return (linux_msgrcv(p, args));
136146aad74SMarcel Moolenaar 	case LINUX_MSGGET:
137146aad74SMarcel Moolenaar 		return (linux_msgget(p, args));
138146aad74SMarcel Moolenaar 	case LINUX_MSGCTL:
139146aad74SMarcel Moolenaar 		return (linux_msgctl(p, args));
140146aad74SMarcel Moolenaar 	case LINUX_SHMAT:
141146aad74SMarcel Moolenaar 		return (linux_shmat(p, args));
142146aad74SMarcel Moolenaar 	case LINUX_SHMDT:
143146aad74SMarcel Moolenaar 		return (linux_shmdt(p, args));
144146aad74SMarcel Moolenaar 	case LINUX_SHMGET:
145146aad74SMarcel Moolenaar 		return (linux_shmget(p, args));
146146aad74SMarcel Moolenaar 	case LINUX_SHMCTL:
147146aad74SMarcel Moolenaar 		return (linux_shmctl(p, args));
148146aad74SMarcel Moolenaar 	}
149146aad74SMarcel Moolenaar 
150146aad74SMarcel Moolenaar 	uprintf("LINUX: 'ipc' typ=%d not implemented\n", args->what);
151146aad74SMarcel Moolenaar 	return (ENOSYS);
152146aad74SMarcel Moolenaar }
153146aad74SMarcel Moolenaar 
154146aad74SMarcel Moolenaar int
155146aad74SMarcel Moolenaar linux_select(struct proc *p, struct linux_select_args *args)
156146aad74SMarcel Moolenaar {
157146aad74SMarcel Moolenaar 	struct linux_select_argv linux_args;
158146aad74SMarcel Moolenaar 	struct linux_newselect_args newsel;
159146aad74SMarcel Moolenaar 	int error;
160146aad74SMarcel Moolenaar 
161146aad74SMarcel Moolenaar #ifdef SELECT_DEBUG
162146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): select(%x)\n", (long)p->p_pid, args->ptr);
163146aad74SMarcel Moolenaar #endif
164146aad74SMarcel Moolenaar 
165146aad74SMarcel Moolenaar 	error = copyin(args->ptr, &linux_args, sizeof(linux_args));
166146aad74SMarcel Moolenaar 	if (error)
167146aad74SMarcel Moolenaar 		return (error);
168146aad74SMarcel Moolenaar 
169146aad74SMarcel Moolenaar 	newsel.nfds = linux_args.nfds;
170146aad74SMarcel Moolenaar 	newsel.readfds = linux_args.readfds;
171146aad74SMarcel Moolenaar 	newsel.writefds = linux_args.writefds;
172146aad74SMarcel Moolenaar 	newsel.exceptfds = linux_args.exceptfds;
173146aad74SMarcel Moolenaar 	newsel.timeout = linux_args.timeout;
174146aad74SMarcel Moolenaar 	return (linux_newselect(p, &newsel));
175146aad74SMarcel Moolenaar }
176146aad74SMarcel Moolenaar 
177146aad74SMarcel Moolenaar int
178146aad74SMarcel Moolenaar linux_fork(struct proc *p, struct linux_fork_args *args)
179146aad74SMarcel Moolenaar {
180146aad74SMarcel Moolenaar 	int error;
181146aad74SMarcel Moolenaar 
182146aad74SMarcel Moolenaar #ifdef DEBUG
183146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): fork()\n", (long)p->p_pid);
184146aad74SMarcel Moolenaar #endif
185146aad74SMarcel Moolenaar 
186146aad74SMarcel Moolenaar 	if ((error = fork(p, (struct fork_args *)args)) != 0)
187146aad74SMarcel Moolenaar 		return (error);
188146aad74SMarcel Moolenaar 
189146aad74SMarcel Moolenaar 	if (p->p_retval[1] == 1)
190146aad74SMarcel Moolenaar 		p->p_retval[0] = 0;
191146aad74SMarcel Moolenaar 	return (0);
192146aad74SMarcel Moolenaar }
193146aad74SMarcel Moolenaar 
194146aad74SMarcel Moolenaar int
195146aad74SMarcel Moolenaar linux_vfork(struct proc *p, struct linux_vfork_args *args)
196146aad74SMarcel Moolenaar {
197146aad74SMarcel Moolenaar 	int error;
198146aad74SMarcel Moolenaar 
199146aad74SMarcel Moolenaar #ifdef DEBUG
200146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): vfork()\n", (long)p->p_pid);
201146aad74SMarcel Moolenaar #endif
202146aad74SMarcel Moolenaar 
203146aad74SMarcel Moolenaar 	if ((error = vfork(p, (struct vfork_args *)args)) != 0)
204146aad74SMarcel Moolenaar 		return (error);
205146aad74SMarcel Moolenaar 	/* Are we the child? */
206146aad74SMarcel Moolenaar 	if (p->p_retval[1] == 1)
207146aad74SMarcel Moolenaar 		p->p_retval[0] = 0;
208146aad74SMarcel Moolenaar 	return (0);
209146aad74SMarcel Moolenaar }
210146aad74SMarcel Moolenaar 
211146aad74SMarcel Moolenaar #define CLONE_VM	0x100
212146aad74SMarcel Moolenaar #define CLONE_FS	0x200
213146aad74SMarcel Moolenaar #define CLONE_FILES	0x400
214146aad74SMarcel Moolenaar #define CLONE_SIGHAND	0x800
215146aad74SMarcel Moolenaar #define CLONE_PID	0x1000
216146aad74SMarcel Moolenaar 
217146aad74SMarcel Moolenaar int
218146aad74SMarcel Moolenaar linux_clone(struct proc *p, struct linux_clone_args *args)
219146aad74SMarcel Moolenaar {
220146aad74SMarcel Moolenaar 	int error, ff = RFPROC;
221146aad74SMarcel Moolenaar 	struct proc *p2;
222146aad74SMarcel Moolenaar 	int exit_signal;
223146aad74SMarcel Moolenaar 	vm_offset_t start;
224146aad74SMarcel Moolenaar 	struct rfork_args rf_args;
225146aad74SMarcel Moolenaar 
226146aad74SMarcel Moolenaar #ifdef DEBUG
227146aad74SMarcel Moolenaar 	if (args->flags & CLONE_PID)
228146aad74SMarcel Moolenaar 		printf("linux_clone(%ld): CLONE_PID not yet supported\n",
229146aad74SMarcel Moolenaar 		    (long)p->p_pid);
230146aad74SMarcel Moolenaar 	printf("linux_clone(%ld): invoked with flags %x and stack %x\n",
231146aad74SMarcel Moolenaar 	    (long)p->p_pid, (unsigned int)args->flags,
232146aad74SMarcel Moolenaar 	    (unsigned int)args->stack);
233146aad74SMarcel Moolenaar #endif
234146aad74SMarcel Moolenaar 
235146aad74SMarcel Moolenaar 	if (!args->stack)
236146aad74SMarcel Moolenaar 		return (EINVAL);
237146aad74SMarcel Moolenaar 
238146aad74SMarcel Moolenaar 	exit_signal = args->flags & 0x000000ff;
239146aad74SMarcel Moolenaar 	if (exit_signal >= LINUX_NSIG)
240146aad74SMarcel Moolenaar 		return (EINVAL);
241146aad74SMarcel Moolenaar 
242146aad74SMarcel Moolenaar 	if (exit_signal <= LINUX_SIGTBLSZ)
243146aad74SMarcel Moolenaar 		exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)];
244146aad74SMarcel Moolenaar 
245146aad74SMarcel Moolenaar 	/* RFTHREAD probably not necessary here, but it shouldn't hurt */
246146aad74SMarcel Moolenaar 	ff |= RFTHREAD;
247146aad74SMarcel Moolenaar 
248146aad74SMarcel Moolenaar 	if (args->flags & CLONE_VM)
249146aad74SMarcel Moolenaar 		ff |= RFMEM;
250146aad74SMarcel Moolenaar 	if (args->flags & CLONE_SIGHAND)
251146aad74SMarcel Moolenaar 		ff |= RFSIGSHARE;
252146aad74SMarcel Moolenaar 	if (!(args->flags & CLONE_FILES))
253146aad74SMarcel Moolenaar 		ff |= RFFDG;
254146aad74SMarcel Moolenaar 
255146aad74SMarcel Moolenaar 	error = 0;
256146aad74SMarcel Moolenaar 	start = 0;
257146aad74SMarcel Moolenaar 
258146aad74SMarcel Moolenaar 	rf_args.flags = ff;
259146aad74SMarcel Moolenaar 	if ((error = rfork(p, &rf_args)) != 0)
260146aad74SMarcel Moolenaar 		return (error);
261146aad74SMarcel Moolenaar 
262146aad74SMarcel Moolenaar 	p2 = pfind(p->p_retval[0]);
263146aad74SMarcel Moolenaar 	if (p2 == 0)
264146aad74SMarcel Moolenaar 		return (ESRCH);
265146aad74SMarcel Moolenaar 
266146aad74SMarcel Moolenaar 	p2->p_sigparent = exit_signal;
267146aad74SMarcel Moolenaar 	p2->p_md.md_regs->tf_esp = (unsigned int)args->stack;
268146aad74SMarcel Moolenaar 
269146aad74SMarcel Moolenaar #ifdef DEBUG
270146aad74SMarcel Moolenaar 	printf ("linux_clone(%ld): successful rfork to %ld\n", (long)p->p_pid,
271146aad74SMarcel Moolenaar 	    (long)p2->p_pid);
272146aad74SMarcel Moolenaar #endif
273146aad74SMarcel Moolenaar 
274146aad74SMarcel Moolenaar 	return (0);
275146aad74SMarcel Moolenaar }
276146aad74SMarcel Moolenaar 
277146aad74SMarcel Moolenaar /* XXX move */
278146aad74SMarcel Moolenaar struct linux_mmap_argv {
279146aad74SMarcel Moolenaar 	linux_caddr_t addr;
280146aad74SMarcel Moolenaar 	int len;
281146aad74SMarcel Moolenaar 	int prot;
282146aad74SMarcel Moolenaar 	int flags;
283146aad74SMarcel Moolenaar 	int fd;
284146aad74SMarcel Moolenaar 	int pos;
285146aad74SMarcel Moolenaar };
286146aad74SMarcel Moolenaar 
287146aad74SMarcel Moolenaar #define STACK_SIZE  (2 * 1024 * 1024)
288146aad74SMarcel Moolenaar #define GUARD_SIZE  (4 * PAGE_SIZE)
289146aad74SMarcel Moolenaar 
290146aad74SMarcel Moolenaar int
291146aad74SMarcel Moolenaar linux_mmap(struct proc *p, struct linux_mmap_args *args)
292146aad74SMarcel Moolenaar {
293146aad74SMarcel Moolenaar 	struct mmap_args /* {
294146aad74SMarcel Moolenaar 		caddr_t addr;
295146aad74SMarcel Moolenaar 		size_t len;
296146aad74SMarcel Moolenaar 		int prot;
297146aad74SMarcel Moolenaar 		int flags;
298146aad74SMarcel Moolenaar 		int fd;
299146aad74SMarcel Moolenaar 		long pad;
300146aad74SMarcel Moolenaar 		off_t pos;
301146aad74SMarcel Moolenaar 	} */ bsd_args;
302146aad74SMarcel Moolenaar 	int error;
303146aad74SMarcel Moolenaar 	struct linux_mmap_argv linux_args;
304146aad74SMarcel Moolenaar 
305146aad74SMarcel Moolenaar 	error = copyin(args->ptr, &linux_args, sizeof(linux_args));
306146aad74SMarcel Moolenaar 	if (error)
307146aad74SMarcel Moolenaar 		return (error);
308146aad74SMarcel Moolenaar 
309146aad74SMarcel Moolenaar #ifdef DEBUG
310146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): mmap(%p, %d, %d, 0x%08x, %d, %d)",
311146aad74SMarcel Moolenaar 	    (long)p->p_pid, (void *)linux_args.addr, linux_args.len,
312146aad74SMarcel Moolenaar 	    linux_args.prot, linux_args.flags, linux_args.fd, linux_args.pos);
313146aad74SMarcel Moolenaar #endif
314146aad74SMarcel Moolenaar 
315146aad74SMarcel Moolenaar 	bsd_args.flags = 0;
316146aad74SMarcel Moolenaar 	if (linux_args.flags & LINUX_MAP_SHARED)
317146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_SHARED;
318146aad74SMarcel Moolenaar 	if (linux_args.flags & LINUX_MAP_PRIVATE)
319146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_PRIVATE;
320146aad74SMarcel Moolenaar 	if (linux_args.flags & LINUX_MAP_FIXED)
321146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_FIXED;
322146aad74SMarcel Moolenaar 	if (linux_args.flags & LINUX_MAP_ANON)
323146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_ANON;
324146aad74SMarcel Moolenaar 	if (linux_args.flags & LINUX_MAP_GROWSDOWN) {
325146aad74SMarcel Moolenaar 		bsd_args.flags |= MAP_STACK;
326146aad74SMarcel Moolenaar 
327146aad74SMarcel Moolenaar 		/* The linux MAP_GROWSDOWN option does not limit auto
328146aad74SMarcel Moolenaar 		 * growth of the region.  Linux mmap with this option
329146aad74SMarcel Moolenaar 		 * takes as addr the inital BOS, and as len, the initial
330146aad74SMarcel Moolenaar 		 * region size.  It can then grow down from addr without
331146aad74SMarcel Moolenaar 		 * limit.  However, linux threads has an implicit internal
332146aad74SMarcel Moolenaar 		 * limit to stack size of STACK_SIZE.  Its just not
333146aad74SMarcel Moolenaar 		 * enforced explicitly in linux.  But, here we impose
334146aad74SMarcel Moolenaar 		 * a limit of (STACK_SIZE - GUARD_SIZE) on the stack
335146aad74SMarcel Moolenaar 		 * region, since we can do this with our mmap.
336146aad74SMarcel Moolenaar 		 *
337146aad74SMarcel Moolenaar 		 * Our mmap with MAP_STACK takes addr as the maximum
338146aad74SMarcel Moolenaar 		 * downsize limit on BOS, and as len the max size of
339146aad74SMarcel Moolenaar 		 * the region.  It them maps the top SGROWSIZ bytes,
340146aad74SMarcel Moolenaar 		 * and autgrows the region down, up to the limit
341146aad74SMarcel Moolenaar 		 * in addr.
342146aad74SMarcel Moolenaar 		 *
343146aad74SMarcel Moolenaar 		 * If we don't use the MAP_STACK option, the effect
344146aad74SMarcel Moolenaar 		 * of this code is to allocate a stack region of a
345146aad74SMarcel Moolenaar 		 * fixed size of (STACK_SIZE - GUARD_SIZE).
346146aad74SMarcel Moolenaar 		 */
347146aad74SMarcel Moolenaar 
348146aad74SMarcel Moolenaar 		/* This gives us TOS */
349146aad74SMarcel Moolenaar 		bsd_args.addr = linux_args.addr + linux_args.len;
350146aad74SMarcel Moolenaar 
351242fae60SAndrew Gallatin 		if (bsd_args.addr > p->p_vmspace->vm_maxsaddr) {
352242fae60SAndrew Gallatin 			/* Some linux apps will attempt to mmap
353242fae60SAndrew Gallatin 			 * thread stacks near the top of their
354242fae60SAndrew Gallatin 			 * address space.  If their TOS is greater
355242fae60SAndrew Gallatin 			 * than vm_maxsaddr, vm_map_growstack()
356242fae60SAndrew Gallatin 			 * will confuse the thread stack with the
357242fae60SAndrew Gallatin 			 * process stack and deliver a SEGV if they
358242fae60SAndrew Gallatin 			 * attempt to grow the thread stack past their
359242fae60SAndrew Gallatin 			 * current stacksize rlimit.  To avoid this,
360242fae60SAndrew Gallatin 			 * adjust vm_maxsaddr upwards to reflect
361242fae60SAndrew Gallatin 			 * the current stacksize rlimit rather
362242fae60SAndrew Gallatin 			 * than the maximum possible stacksize.
363242fae60SAndrew Gallatin 			 * It would be better to adjust the
364242fae60SAndrew Gallatin 			 * mmap'ed region, but some apps do not check
365242fae60SAndrew Gallatin 			 * mmap's return value.
366242fae60SAndrew Gallatin 			 */
367242fae60SAndrew Gallatin 			p->p_vmspace->vm_maxsaddr = (char *)USRSTACK -
368242fae60SAndrew Gallatin 			    p->p_rlimit[RLIMIT_STACK].rlim_cur;
369242fae60SAndrew Gallatin 		}
370242fae60SAndrew Gallatin 
371146aad74SMarcel Moolenaar 		/* This gives us our maximum stack size */
372146aad74SMarcel Moolenaar 		if (linux_args.len > STACK_SIZE - GUARD_SIZE)
373146aad74SMarcel Moolenaar 			bsd_args.len = linux_args.len;
374146aad74SMarcel Moolenaar 		else
375146aad74SMarcel Moolenaar 			bsd_args.len  = STACK_SIZE - GUARD_SIZE;
376146aad74SMarcel Moolenaar 
377146aad74SMarcel Moolenaar 		/* This gives us a new BOS.  If we're using VM_STACK, then
378146aad74SMarcel Moolenaar 		 * mmap will just map the top SGROWSIZ bytes, and let
379146aad74SMarcel Moolenaar 		 * the stack grow down to the limit at BOS.  If we're
380146aad74SMarcel Moolenaar 		 * not using VM_STACK we map the full stack, since we
381146aad74SMarcel Moolenaar 		 * don't have a way to autogrow it.
382146aad74SMarcel Moolenaar 		 */
383146aad74SMarcel Moolenaar 		bsd_args.addr -= bsd_args.len;
384146aad74SMarcel Moolenaar 	} else {
385146aad74SMarcel Moolenaar 		bsd_args.addr = linux_args.addr;
386146aad74SMarcel Moolenaar 		bsd_args.len  = linux_args.len;
387146aad74SMarcel Moolenaar 	}
388146aad74SMarcel Moolenaar 
389146aad74SMarcel Moolenaar 	bsd_args.prot = linux_args.prot | PROT_READ;	/* always required */
390146aad74SMarcel Moolenaar 	if (linux_args.flags & LINUX_MAP_ANON)
391146aad74SMarcel Moolenaar 		bsd_args.fd = -1;
392146aad74SMarcel Moolenaar 	else
393146aad74SMarcel Moolenaar 		bsd_args.fd = linux_args.fd;
394146aad74SMarcel Moolenaar 	bsd_args.pos = linux_args.pos;
395146aad74SMarcel Moolenaar 	bsd_args.pad = 0;
396146aad74SMarcel Moolenaar 
397146aad74SMarcel Moolenaar #ifdef DEBUG
398146aad74SMarcel Moolenaar 	printf("-> (%p, %d, %d, 0x%08x, %d, %d)\n", (void *)bsd_args.addr,
399146aad74SMarcel Moolenaar 	    bsd_args.len, bsd_args.prot, bsd_args.flags, bsd_args.fd,
400146aad74SMarcel Moolenaar 	    (int)bsd_args.pos);
401146aad74SMarcel Moolenaar #endif
402146aad74SMarcel Moolenaar 
403146aad74SMarcel Moolenaar 	return (mmap(p, &bsd_args));
404146aad74SMarcel Moolenaar }
405146aad74SMarcel Moolenaar 
406146aad74SMarcel Moolenaar int
407146aad74SMarcel Moolenaar linux_pipe(struct proc *p, struct linux_pipe_args *args)
408146aad74SMarcel Moolenaar {
409146aad74SMarcel Moolenaar 	int error;
410146aad74SMarcel Moolenaar 	int reg_edx;
411146aad74SMarcel Moolenaar 
412146aad74SMarcel Moolenaar #ifdef DEBUG
413146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): pipe(*)\n", (long)p->p_pid);
414146aad74SMarcel Moolenaar #endif
415146aad74SMarcel Moolenaar 
416146aad74SMarcel Moolenaar 	reg_edx = p->p_retval[1];
417146aad74SMarcel Moolenaar 	error = pipe(p, 0);
418146aad74SMarcel Moolenaar 	if (error) {
419146aad74SMarcel Moolenaar 		p->p_retval[1] = reg_edx;
420146aad74SMarcel Moolenaar 		return (error);
421146aad74SMarcel Moolenaar 	}
422146aad74SMarcel Moolenaar 
423146aad74SMarcel Moolenaar 	error = copyout(p->p_retval, args->pipefds, 2*sizeof(int));
424146aad74SMarcel Moolenaar 	if (error) {
425146aad74SMarcel Moolenaar 		p->p_retval[1] = reg_edx;
426146aad74SMarcel Moolenaar 		return (error);
427146aad74SMarcel Moolenaar 	}
428146aad74SMarcel Moolenaar 
429146aad74SMarcel Moolenaar 	p->p_retval[1] = reg_edx;
430146aad74SMarcel Moolenaar 	p->p_retval[0] = 0;
431146aad74SMarcel Moolenaar 	return (0);
432146aad74SMarcel Moolenaar }
433146aad74SMarcel Moolenaar 
434146aad74SMarcel Moolenaar int
435146aad74SMarcel Moolenaar linux_ioperm(struct proc *p, struct linux_ioperm_args *args)
436146aad74SMarcel Moolenaar {
437146aad74SMarcel Moolenaar 	struct sysarch_args sa;
438146aad74SMarcel Moolenaar 	struct i386_ioperm_args *iia;
439146aad74SMarcel Moolenaar 	caddr_t sg;
440146aad74SMarcel Moolenaar 
441146aad74SMarcel Moolenaar 	sg = stackgap_init();
442146aad74SMarcel Moolenaar 	iia = stackgap_alloc(&sg, sizeof(struct i386_ioperm_args));
443146aad74SMarcel Moolenaar 	iia->start = args->start;
444146aad74SMarcel Moolenaar 	iia->length = args->length;
445146aad74SMarcel Moolenaar 	iia->enable = args->enable;
446146aad74SMarcel Moolenaar 	sa.op = I386_SET_IOPERM;
447146aad74SMarcel Moolenaar 	sa.parms = (char *)iia;
448146aad74SMarcel Moolenaar 	return (sysarch(p, &sa));
449146aad74SMarcel Moolenaar }
450146aad74SMarcel Moolenaar 
451146aad74SMarcel Moolenaar int
452146aad74SMarcel Moolenaar linux_iopl(struct proc *p, struct linux_iopl_args *args)
453146aad74SMarcel Moolenaar {
454146aad74SMarcel Moolenaar 	int error;
455146aad74SMarcel Moolenaar 
456146aad74SMarcel Moolenaar 	if (args->level < 0 || args->level > 3)
457146aad74SMarcel Moolenaar 		return (EINVAL);
458146aad74SMarcel Moolenaar 	if ((error = suser(p)) != 0)
459146aad74SMarcel Moolenaar 		return (error);
460146aad74SMarcel Moolenaar 	if (securelevel > 0)
461146aad74SMarcel Moolenaar 		return (EPERM);
462146aad74SMarcel Moolenaar 	p->p_md.md_regs->tf_eflags = (p->p_md.md_regs->tf_eflags & ~PSL_IOPL) |
463146aad74SMarcel Moolenaar 	    (args->level * (PSL_IOPL / 3));
464146aad74SMarcel Moolenaar 	return (0);
465146aad74SMarcel Moolenaar }
466146aad74SMarcel Moolenaar 
467146aad74SMarcel Moolenaar int
468146aad74SMarcel Moolenaar linux_modify_ldt(p, uap)
469146aad74SMarcel Moolenaar 	struct proc *p;
470146aad74SMarcel Moolenaar 	struct linux_modify_ldt_args *uap;
471146aad74SMarcel Moolenaar {
472146aad74SMarcel Moolenaar 	int error;
473146aad74SMarcel Moolenaar 	caddr_t sg;
474146aad74SMarcel Moolenaar 	struct sysarch_args args;
475146aad74SMarcel Moolenaar 	struct i386_ldt_args *ldt;
476146aad74SMarcel Moolenaar 	struct linux_descriptor ld;
477146aad74SMarcel Moolenaar 	union descriptor *desc;
478146aad74SMarcel Moolenaar 
479146aad74SMarcel Moolenaar 	sg = stackgap_init();
480146aad74SMarcel Moolenaar 
481146aad74SMarcel Moolenaar 	if (uap->ptr == NULL)
482146aad74SMarcel Moolenaar 		return (EINVAL);
483146aad74SMarcel Moolenaar 
484146aad74SMarcel Moolenaar 	switch (uap->func) {
485146aad74SMarcel Moolenaar 	case 0x00: /* read_ldt */
486146aad74SMarcel Moolenaar 		ldt = stackgap_alloc(&sg, sizeof(*ldt));
487146aad74SMarcel Moolenaar 		ldt->start = 0;
488146aad74SMarcel Moolenaar 		ldt->descs = uap->ptr;
489146aad74SMarcel Moolenaar 		ldt->num = uap->bytecount / sizeof(union descriptor);
490146aad74SMarcel Moolenaar 		args.op = I386_GET_LDT;
491146aad74SMarcel Moolenaar 		args.parms = (char*)ldt;
492146aad74SMarcel Moolenaar 		error = sysarch(p, &args);
493146aad74SMarcel Moolenaar 		p->p_retval[0] *= sizeof(union descriptor);
494146aad74SMarcel Moolenaar 		break;
495146aad74SMarcel Moolenaar 	case 0x01: /* write_ldt */
496146aad74SMarcel Moolenaar 	case 0x11: /* write_ldt */
497146aad74SMarcel Moolenaar 		if (uap->bytecount != sizeof(ld))
498146aad74SMarcel Moolenaar 			return (EINVAL);
499146aad74SMarcel Moolenaar 
500146aad74SMarcel Moolenaar 		error = copyin(uap->ptr, &ld, sizeof(ld));
501146aad74SMarcel Moolenaar 		if (error)
502146aad74SMarcel Moolenaar 			return (error);
503146aad74SMarcel Moolenaar 
504146aad74SMarcel Moolenaar 		ldt = stackgap_alloc(&sg, sizeof(*ldt));
505146aad74SMarcel Moolenaar 		desc = stackgap_alloc(&sg, sizeof(*desc));
506146aad74SMarcel Moolenaar 		ldt->start = ld.entry_number;
507146aad74SMarcel Moolenaar 		ldt->descs = desc;
508146aad74SMarcel Moolenaar 		ldt->num = 1;
509146aad74SMarcel Moolenaar 		desc->sd.sd_lolimit = (ld.limit & 0x0000ffff);
510146aad74SMarcel Moolenaar 		desc->sd.sd_hilimit = (ld.limit & 0x000f0000) >> 16;
511146aad74SMarcel Moolenaar 		desc->sd.sd_lobase = (ld.base_addr & 0x00ffffff);
512146aad74SMarcel Moolenaar 		desc->sd.sd_hibase = (ld.base_addr & 0xff000000) >> 24;
513146aad74SMarcel Moolenaar 		desc->sd.sd_type = SDT_MEMRO | ((ld.read_exec_only ^ 1) << 1) |
514146aad74SMarcel Moolenaar 			(ld.contents << 2);
515146aad74SMarcel Moolenaar 		desc->sd.sd_dpl = 3;
516146aad74SMarcel Moolenaar 		desc->sd.sd_p = (ld.seg_not_present ^ 1);
517146aad74SMarcel Moolenaar 		desc->sd.sd_xx = 0;
518146aad74SMarcel Moolenaar 		desc->sd.sd_def32 = ld.seg_32bit;
519146aad74SMarcel Moolenaar 		desc->sd.sd_gran = ld.limit_in_pages;
520146aad74SMarcel Moolenaar 		args.op = I386_SET_LDT;
521146aad74SMarcel Moolenaar 		args.parms = (char*)ldt;
522146aad74SMarcel Moolenaar 		error = sysarch(p, &args);
523146aad74SMarcel Moolenaar 		break;
524146aad74SMarcel Moolenaar 	default:
525146aad74SMarcel Moolenaar 		error = EINVAL;
526146aad74SMarcel Moolenaar 		break;
527146aad74SMarcel Moolenaar 	}
528146aad74SMarcel Moolenaar 
529146aad74SMarcel Moolenaar 	if (error == EOPNOTSUPP) {
530146aad74SMarcel Moolenaar 		printf("linux: modify_ldt needs kernel option USER_LDT\n");
531146aad74SMarcel Moolenaar 		error = ENOSYS;
532146aad74SMarcel Moolenaar 	}
533146aad74SMarcel Moolenaar 
534146aad74SMarcel Moolenaar 	return (error);
535146aad74SMarcel Moolenaar }
536146aad74SMarcel Moolenaar 
537146aad74SMarcel Moolenaar int
538146aad74SMarcel Moolenaar linux_sigaction(struct proc *p, struct linux_sigaction_args *args)
539146aad74SMarcel Moolenaar {
540146aad74SMarcel Moolenaar 	linux_osigaction_t osa;
541146aad74SMarcel Moolenaar 	linux_sigaction_t act, oact;
542146aad74SMarcel Moolenaar 	int error;
543146aad74SMarcel Moolenaar 
544146aad74SMarcel Moolenaar #ifdef DEBUG
545146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): sigaction(%d, %p, %p)\n", (long)p->p_pid,
546146aad74SMarcel Moolenaar 	       args->sig, (void *)args->nsa, (void *)args->osa);
547146aad74SMarcel Moolenaar #endif
548146aad74SMarcel Moolenaar 
549146aad74SMarcel Moolenaar 	if (args->nsa != NULL) {
550146aad74SMarcel Moolenaar 		error = copyin(args->nsa, &osa, sizeof(linux_osigaction_t));
551146aad74SMarcel Moolenaar 		if (error)
552146aad74SMarcel Moolenaar 			return (error);
553146aad74SMarcel Moolenaar 		act.lsa_handler = osa.lsa_handler;
554146aad74SMarcel Moolenaar 		act.lsa_flags = osa.lsa_flags;
555146aad74SMarcel Moolenaar 		act.lsa_restorer = osa.lsa_restorer;
556146aad74SMarcel Moolenaar 		LINUX_SIGEMPTYSET(act.lsa_mask);
557146aad74SMarcel Moolenaar 		act.lsa_mask.__bits[0] = osa.lsa_mask;
558146aad74SMarcel Moolenaar 	}
559146aad74SMarcel Moolenaar 
560146aad74SMarcel Moolenaar 	error = linux_do_sigaction(p, args->sig, args->nsa ? &act : NULL,
561146aad74SMarcel Moolenaar 	    args->osa ? &oact : NULL);
562146aad74SMarcel Moolenaar 
563146aad74SMarcel Moolenaar 	if (args->osa != NULL && !error) {
564146aad74SMarcel Moolenaar 		osa.lsa_handler = oact.lsa_handler;
565146aad74SMarcel Moolenaar 		osa.lsa_flags = oact.lsa_flags;
566146aad74SMarcel Moolenaar 		osa.lsa_restorer = oact.lsa_restorer;
567146aad74SMarcel Moolenaar 		osa.lsa_mask = oact.lsa_mask.__bits[0];
568146aad74SMarcel Moolenaar 		error = copyout(&osa, args->osa, sizeof(linux_osigaction_t));
569146aad74SMarcel Moolenaar 	}
570146aad74SMarcel Moolenaar 
571146aad74SMarcel Moolenaar 	return (error);
572146aad74SMarcel Moolenaar }
573146aad74SMarcel Moolenaar 
574146aad74SMarcel Moolenaar /*
575146aad74SMarcel Moolenaar  * Linux has two extra args, restart and oldmask.  We dont use these,
576146aad74SMarcel Moolenaar  * but it seems that "restart" is actually a context pointer that
577146aad74SMarcel Moolenaar  * enables the signal to happen with a different register set.
578146aad74SMarcel Moolenaar  */
579146aad74SMarcel Moolenaar int
580146aad74SMarcel Moolenaar linux_sigsuspend(struct proc *p, struct linux_sigsuspend_args *args)
581146aad74SMarcel Moolenaar {
582146aad74SMarcel Moolenaar 	struct sigsuspend_args bsd;
583146aad74SMarcel Moolenaar 	sigset_t *sigmask;
584146aad74SMarcel Moolenaar 	linux_sigset_t mask;
585146aad74SMarcel Moolenaar 	caddr_t sg = stackgap_init();
586146aad74SMarcel Moolenaar 
587146aad74SMarcel Moolenaar #ifdef DEBUG
588146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): sigsuspend(%08lx)\n",
589146aad74SMarcel Moolenaar 	       (long)p->p_pid, (unsigned long)args->mask);
590146aad74SMarcel Moolenaar #endif
591146aad74SMarcel Moolenaar 
592146aad74SMarcel Moolenaar 	sigmask = stackgap_alloc(&sg, sizeof(sigset_t));
593146aad74SMarcel Moolenaar 	LINUX_SIGEMPTYSET(mask);
594146aad74SMarcel Moolenaar 	mask.__bits[0] = args->mask;
595146aad74SMarcel Moolenaar 	linux_to_bsd_sigset(&mask, sigmask);
596146aad74SMarcel Moolenaar 	bsd.sigmask = sigmask;
597146aad74SMarcel Moolenaar 	return (sigsuspend(p, &bsd));
598146aad74SMarcel Moolenaar }
599146aad74SMarcel Moolenaar 
600146aad74SMarcel Moolenaar int
601146aad74SMarcel Moolenaar linux_rt_sigsuspend(p, uap)
602146aad74SMarcel Moolenaar 	struct proc *p;
603146aad74SMarcel Moolenaar 	struct linux_rt_sigsuspend_args *uap;
604146aad74SMarcel Moolenaar {
605146aad74SMarcel Moolenaar 	linux_sigset_t lmask;
606146aad74SMarcel Moolenaar 	sigset_t *bmask;
607146aad74SMarcel Moolenaar 	struct sigsuspend_args bsd;
608146aad74SMarcel Moolenaar 	caddr_t sg = stackgap_init();
609146aad74SMarcel Moolenaar 	int error;
610146aad74SMarcel Moolenaar 
611146aad74SMarcel Moolenaar #ifdef DEBUG
612146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): rt_sigsuspend(%p, %d)\n", (long)p->p_pid,
613146aad74SMarcel Moolenaar 	       (void *)uap->newset, uap->sigsetsize);
614146aad74SMarcel Moolenaar #endif
615146aad74SMarcel Moolenaar 
616146aad74SMarcel Moolenaar 	if (uap->sigsetsize != sizeof(linux_sigset_t))
617146aad74SMarcel Moolenaar 		return (EINVAL);
618146aad74SMarcel Moolenaar 
619146aad74SMarcel Moolenaar 	error = copyin(uap->newset, &lmask, sizeof(linux_sigset_t));
620146aad74SMarcel Moolenaar 	if (error)
621146aad74SMarcel Moolenaar 		return (error);
622146aad74SMarcel Moolenaar 
623146aad74SMarcel Moolenaar 	bmask = stackgap_alloc(&sg, sizeof(sigset_t));
624146aad74SMarcel Moolenaar 	linux_to_bsd_sigset(&lmask, bmask);
625146aad74SMarcel Moolenaar 	bsd.sigmask = bmask;
626146aad74SMarcel Moolenaar 	return (sigsuspend(p, &bsd));
627146aad74SMarcel Moolenaar }
628146aad74SMarcel Moolenaar 
629146aad74SMarcel Moolenaar int
630146aad74SMarcel Moolenaar linux_pause(struct proc *p, struct linux_pause_args *args)
631146aad74SMarcel Moolenaar {
632146aad74SMarcel Moolenaar 	struct sigsuspend_args bsd;
633146aad74SMarcel Moolenaar 	sigset_t *sigmask;
634146aad74SMarcel Moolenaar 	caddr_t sg = stackgap_init();
635146aad74SMarcel Moolenaar 
636146aad74SMarcel Moolenaar #ifdef DEBUG
637146aad74SMarcel Moolenaar 	printf("Linux-emul(%d): pause()\n", p->p_pid);
638146aad74SMarcel Moolenaar #endif
639146aad74SMarcel Moolenaar 
640146aad74SMarcel Moolenaar 	sigmask = stackgap_alloc(&sg, sizeof(sigset_t));
641146aad74SMarcel Moolenaar 	*sigmask = p->p_sigmask;
642146aad74SMarcel Moolenaar 	bsd.sigmask = sigmask;
643146aad74SMarcel Moolenaar 	return (sigsuspend(p, &bsd));
644146aad74SMarcel Moolenaar }
645146aad74SMarcel Moolenaar 
646146aad74SMarcel Moolenaar int
647146aad74SMarcel Moolenaar linux_sigaltstack(p, uap)
648146aad74SMarcel Moolenaar 	struct proc *p;
649146aad74SMarcel Moolenaar 	struct linux_sigaltstack_args *uap;
650146aad74SMarcel Moolenaar {
651146aad74SMarcel Moolenaar 	struct sigaltstack_args bsd;
652146aad74SMarcel Moolenaar 	stack_t *ss, *oss;
653146aad74SMarcel Moolenaar 	linux_stack_t lss;
654146aad74SMarcel Moolenaar 	int error;
655146aad74SMarcel Moolenaar 	caddr_t sg = stackgap_init();
656146aad74SMarcel Moolenaar 
657146aad74SMarcel Moolenaar #ifdef DEBUG
658146aad74SMarcel Moolenaar 	printf("Linux-emul(%ld): sigaltstack(%p, %p)\n",
659146aad74SMarcel Moolenaar 	    (long)p->p_pid, uap->uss, uap->uoss);
660146aad74SMarcel Moolenaar #endif
661146aad74SMarcel Moolenaar 
662931a7258SAndrew Gallatin 	if (uap->uss == NULL) {
663931a7258SAndrew Gallatin 		ss = NULL;
664931a7258SAndrew Gallatin 	} else {
665146aad74SMarcel Moolenaar 		error = copyin(uap->uss, &lss, sizeof(linux_stack_t));
666146aad74SMarcel Moolenaar 		if (error)
667146aad74SMarcel Moolenaar 			return (error);
668146aad74SMarcel Moolenaar 
669146aad74SMarcel Moolenaar 		ss = stackgap_alloc(&sg, sizeof(stack_t));
670146aad74SMarcel Moolenaar 		ss->ss_sp = lss.ss_sp;
671806d7daaSMarcel Moolenaar 		ss->ss_size = lss.ss_size;
672931a7258SAndrew Gallatin 		ss->ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
673931a7258SAndrew Gallatin 	}
674146aad74SMarcel Moolenaar 	oss = (uap->uoss != NULL)
675146aad74SMarcel Moolenaar 	    ? stackgap_alloc(&sg, sizeof(stack_t))
676146aad74SMarcel Moolenaar 	    : NULL;
677146aad74SMarcel Moolenaar 
678146aad74SMarcel Moolenaar 	bsd.ss = ss;
679146aad74SMarcel Moolenaar 	bsd.oss = oss;
680146aad74SMarcel Moolenaar 	error = sigaltstack(p, &bsd);
681146aad74SMarcel Moolenaar 
682146aad74SMarcel Moolenaar 	if (!error && oss != NULL) {
683146aad74SMarcel Moolenaar 		lss.ss_sp = oss->ss_sp;
684146aad74SMarcel Moolenaar 		lss.ss_size = oss->ss_size;
685931a7258SAndrew Gallatin 		lss.ss_flags = bsd_to_linux_sigaltstack(oss->ss_flags);
686146aad74SMarcel Moolenaar 		error = copyout(&lss, uap->uoss, sizeof(linux_stack_t));
687146aad74SMarcel Moolenaar 	}
688146aad74SMarcel Moolenaar 
689146aad74SMarcel Moolenaar 	return (error);
690146aad74SMarcel Moolenaar }
691