proc->thread stage 4: rework the VFS and DEVICE subsystems to take thread
[dragonfly.git] / sys / emulation / linux / i386 / linux_machdep.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright (c) 2000 Marcel Moolenaar
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer
10 * in this position and unchanged.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote products
15 * derived from this software without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 *
28 * $FreeBSD: src/sys/i386/linux/linux_machdep.c,v 1.6.2.4 2001/11/05 19:08:23 marcel Exp $
dadab5e9 29 * $DragonFly: src/sys/emulation/linux/i386/linux_machdep.c,v 1.4 2003/06/25 03:55:55 dillon Exp $
984263bc
MD
30 */
31
32#include <sys/param.h>
33#include <sys/systm.h>
34#include <sys/lock.h>
35#include <sys/mman.h>
36#include <sys/proc.h>
37#include <sys/resource.h>
38#include <sys/resourcevar.h>
39#include <sys/sysproto.h>
40#include <sys/unistd.h>
41
42#include <machine/frame.h>
43#include <machine/psl.h>
44#include <machine/segments.h>
45#include <machine/sysarch.h>
46
47#include <vm/vm.h>
48#include <vm/pmap.h>
49#include <vm/vm_map.h>
50
51#include <i386/linux/linux.h>
52#include <i386/linux/linux_proto.h>
53#include <compat/linux/linux_ipc.h>
54#include <compat/linux/linux_signal.h>
55#include <compat/linux/linux_util.h>
56
57struct l_descriptor {
58 l_uint entry_number;
59 l_ulong base_addr;
60 l_uint limit;
61 l_uint seg_32bit:1;
62 l_uint contents:2;
63 l_uint read_exec_only:1;
64 l_uint limit_in_pages:1;
65 l_uint seg_not_present:1;
66 l_uint useable:1;
67};
68
69struct l_old_select_argv {
70 l_int nfds;
71 l_fd_set *readfds;
72 l_fd_set *writefds;
73 l_fd_set *exceptfds;
74 struct l_timeval *timeout;
75};
76
77int
78linux_to_bsd_sigaltstack(int lsa)
79{
80 int bsa = 0;
81
82 if (lsa & LINUX_SS_DISABLE)
83 bsa |= SS_DISABLE;
84 if (lsa & LINUX_SS_ONSTACK)
85 bsa |= SS_ONSTACK;
86 return (bsa);
87}
88
89int
90bsd_to_linux_sigaltstack(int bsa)
91{
92 int lsa = 0;
93
94 if (bsa & SS_DISABLE)
95 lsa |= LINUX_SS_DISABLE;
96 if (bsa & SS_ONSTACK)
97 lsa |= LINUX_SS_ONSTACK;
98 return (lsa);
99}
100
101int
41c20dac 102linux_execve(struct linux_execve_args *args)
984263bc
MD
103{
104 struct execve_args bsd;
105 caddr_t sg;
106
107 sg = stackgap_init();
41c20dac 108 CHECKALTEXIST(&sg, args->path);
984263bc
MD
109
110#ifdef DEBUG
111 if (ldebug(execve))
112 printf(ARGS(execve, "%s"), args->path);
113#endif
114
115 bsd.fname = args->path;
116 bsd.argv = args->argp;
117 bsd.envv = args->envp;
41c20dac 118 return (execve(&bsd));
984263bc
MD
119}
120
121struct l_ipc_kludge {
122 struct l_msgbuf *msgp;
123 l_long msgtyp;
124};
125
126int
41c20dac 127linux_ipc(struct linux_ipc_args *args)
984263bc
MD
128{
129
130 switch (args->what & 0xFFFF) {
131 case LINUX_SEMOP: {
132 struct linux_semop_args a;
133
134 a.semid = args->arg1;
135 a.tsops = args->ptr;
136 a.nsops = args->arg2;
41c20dac 137 return (linux_semop(&a));
984263bc
MD
138 }
139 case LINUX_SEMGET: {
140 struct linux_semget_args a;
141
142 a.key = args->arg1;
143 a.nsems = args->arg2;
144 a.semflg = args->arg3;
41c20dac 145 return (linux_semget(&a));
984263bc
MD
146 }
147 case LINUX_SEMCTL: {
148 struct linux_semctl_args a;
149 int error;
150
151 a.semid = args->arg1;
152 a.semnum = args->arg2;
153 a.cmd = args->arg3;
154 error = copyin((caddr_t)args->ptr, &a.arg, sizeof(a.arg));
155 if (error)
156 return (error);
41c20dac 157 return (linux_semctl(&a));
984263bc
MD
158 }
159 case LINUX_MSGSND: {
160 struct linux_msgsnd_args a;
161
162 a.msqid = args->arg1;
163 a.msgp = args->ptr;
164 a.msgsz = args->arg2;
165 a.msgflg = args->arg3;
41c20dac 166 return (linux_msgsnd(&a));
984263bc
MD
167 }
168 case LINUX_MSGRCV: {
169 struct linux_msgrcv_args a;
170
171 a.msqid = args->arg1;
172 a.msgsz = args->arg2;
173 a.msgflg = args->arg3;
174 if ((args->what >> 16) == 0) {
175 struct l_ipc_kludge tmp;
176 int error;
177
178 if (args->ptr == NULL)
179 return (EINVAL);
180 error = copyin((caddr_t)args->ptr, &tmp, sizeof(tmp));
181 if (error)
182 return (error);
183 a.msgp = tmp.msgp;
184 a.msgtyp = tmp.msgtyp;
185 } else {
186 a.msgp = args->ptr;
187 a.msgtyp = args->arg5;
188 }
41c20dac 189 return (linux_msgrcv(&a));
984263bc
MD
190 }
191 case LINUX_MSGGET: {
192 struct linux_msgget_args a;
193
194 a.key = args->arg1;
195 a.msgflg = args->arg2;
41c20dac 196 return (linux_msgget(&a));
984263bc
MD
197 }
198 case LINUX_MSGCTL: {
199 struct linux_msgctl_args a;
200
201 a.msqid = args->arg1;
202 a.cmd = args->arg2;
203 a.buf = args->ptr;
41c20dac 204 return (linux_msgctl(&a));
984263bc
MD
205 }
206 case LINUX_SHMAT: {
207 struct linux_shmat_args a;
208
209 a.shmid = args->arg1;
210 a.shmaddr = args->ptr;
211 a.shmflg = args->arg2;
212 a.raddr = (l_ulong *)args->arg3;
41c20dac 213 return (linux_shmat(&a));
984263bc
MD
214 }
215 case LINUX_SHMDT: {
216 struct linux_shmdt_args a;
217
218 a.shmaddr = args->ptr;
41c20dac 219 return (linux_shmdt(&a));
984263bc
MD
220 }
221 case LINUX_SHMGET: {
222 struct linux_shmget_args a;
223
224 a.key = args->arg1;
225 a.size = args->arg2;
226 a.shmflg = args->arg3;
41c20dac 227 return (linux_shmget(&a));
984263bc
MD
228 }
229 case LINUX_SHMCTL: {
230 struct linux_shmctl_args a;
231
232 a.shmid = args->arg1;
233 a.cmd = args->arg2;
234 a.buf = args->ptr;
41c20dac 235 return (linux_shmctl(&a));
984263bc
MD
236 }
237 default:
238 break;
239 }
240
241 return (EINVAL);
242}
243
244int
41c20dac 245linux_old_select(struct linux_old_select_args *args)
984263bc
MD
246{
247 struct l_old_select_argv linux_args;
248 struct linux_select_args newsel;
249 int error;
250
251#ifdef DEBUG
252 if (ldebug(old_select))
253 printf(ARGS(old_select, "%x"), args->ptr);
254#endif
255
256 error = copyin((caddr_t)args->ptr, &linux_args, sizeof(linux_args));
257 if (error)
258 return (error);
259
260 newsel.nfds = linux_args.nfds;
261 newsel.readfds = linux_args.readfds;
262 newsel.writefds = linux_args.writefds;
263 newsel.exceptfds = linux_args.exceptfds;
264 newsel.timeout = linux_args.timeout;
41c20dac 265 return (linux_select(&newsel));
984263bc
MD
266}
267
268int
41c20dac 269linux_fork(struct linux_fork_args *args)
984263bc 270{
41c20dac 271 struct proc *p = curproc;
984263bc
MD
272 int error;
273
274#ifdef DEBUG
275 if (ldebug(fork))
276 printf(ARGS(fork, ""));
277#endif
278
41c20dac 279 if ((error = fork((struct fork_args *)args)) != 0)
984263bc
MD
280 return (error);
281
282 if (p->p_retval[1] == 1)
283 p->p_retval[0] = 0;
284 return (0);
285}
286
287int
41c20dac 288linux_vfork(struct linux_vfork_args *args)
984263bc 289{
41c20dac 290 struct proc *p = curproc;
984263bc
MD
291 int error;
292
293#ifdef DEBUG
294 if (ldebug(vfork))
295 printf(ARGS(vfork, ""));
296#endif
297
41c20dac 298 if ((error = vfork((struct vfork_args *)args)) != 0)
984263bc
MD
299 return (error);
300 /* Are we the child? */
301 if (p->p_retval[1] == 1)
302 p->p_retval[0] = 0;
303 return (0);
304}
305
306#define CLONE_VM 0x100
307#define CLONE_FS 0x200
308#define CLONE_FILES 0x400
309#define CLONE_SIGHAND 0x800
310#define CLONE_PID 0x1000
311
312int
41c20dac 313linux_clone(struct linux_clone_args *args)
984263bc 314{
41c20dac 315 struct proc *p = curproc;
984263bc
MD
316 int error, ff = RFPROC;
317 struct proc *p2;
318 int exit_signal;
319 vm_offset_t start;
320 struct rfork_args rf_args;
321
322#ifdef DEBUG
323 if (ldebug(clone)) {
324 printf(ARGS(clone, "flags %x, stack %x"),
325 (unsigned int)args->flags, (unsigned int)args->stack);
326 if (args->flags & CLONE_PID)
327 printf(LMSG("CLONE_PID not yet supported"));
328 }
329#endif
330
331 if (!args->stack)
332 return (EINVAL);
333
334 exit_signal = args->flags & 0x000000ff;
335 if (exit_signal >= LINUX_NSIG)
336 return (EINVAL);
337
338 if (exit_signal <= LINUX_SIGTBLSZ)
339 exit_signal = linux_to_bsd_signal[_SIG_IDX(exit_signal)];
340
341 /* RFTHREAD probably not necessary here, but it shouldn't hurt */
342 ff |= RFTHREAD;
343
344 if (args->flags & CLONE_VM)
345 ff |= RFMEM;
346 if (args->flags & CLONE_SIGHAND)
347 ff |= RFSIGSHARE;
348 if (!(args->flags & CLONE_FILES))
349 ff |= RFFDG;
350
351 error = 0;
352 start = 0;
353
354 rf_args.flags = ff;
41c20dac 355 if ((error = rfork(&rf_args)) != 0)
984263bc
MD
356 return (error);
357
358 p2 = pfind(p->p_retval[0]);
359 if (p2 == 0)
360 return (ESRCH);
361
362 p2->p_sigparent = exit_signal;
363 p2->p_md.md_regs->tf_esp = (unsigned int)args->stack;
364
365#ifdef DEBUG
366 if (ldebug(clone))
367 printf(LMSG("clone: successful rfork to %ld"),
368 (long)p2->p_pid);
369#endif
370
371 return (0);
372}
373
374/* XXX move */
375struct l_mmap_argv {
376 l_caddr_t addr;
377 l_int len;
378 l_int prot;
379 l_int flags;
380 l_int fd;
381 l_int pos;
382};
383
384#define STACK_SIZE (2 * 1024 * 1024)
385#define GUARD_SIZE (4 * PAGE_SIZE)
386
387int
41c20dac 388linux_mmap(struct linux_mmap_args *args)
984263bc 389{
41c20dac 390 struct proc *p = curproc;
984263bc
MD
391 struct mmap_args /* {
392 caddr_t addr;
393 size_t len;
394 int prot;
395 int flags;
396 int fd;
397 long pad;
398 off_t pos;
399 } */ bsd_args;
400 int error;
401 struct l_mmap_argv linux_args;
402
403 error = copyin((caddr_t)args->ptr, &linux_args, sizeof(linux_args));
404 if (error)
405 return (error);
406
407#ifdef DEBUG
408 if (ldebug(mmap))
409 printf(ARGS(mmap, "%p, %d, %d, 0x%08x, %d, %d"),
410 (void *)linux_args.addr, linux_args.len, linux_args.prot,
411 linux_args.flags, linux_args.fd, linux_args.pos);
412#endif
413
414 bsd_args.flags = 0;
415 if (linux_args.flags & LINUX_MAP_SHARED)
416 bsd_args.flags |= MAP_SHARED;
417 if (linux_args.flags & LINUX_MAP_PRIVATE)
418 bsd_args.flags |= MAP_PRIVATE;
419 if (linux_args.flags & LINUX_MAP_FIXED)
420 bsd_args.flags |= MAP_FIXED;
421 if (linux_args.flags & LINUX_MAP_ANON)
422 bsd_args.flags |= MAP_ANON;
423 else
424 bsd_args.flags |= MAP_NOSYNC;
425 if (linux_args.flags & LINUX_MAP_GROWSDOWN) {
426 bsd_args.flags |= MAP_STACK;
427
428 /* The linux MAP_GROWSDOWN option does not limit auto
429 * growth of the region. Linux mmap with this option
430 * takes as addr the inital BOS, and as len, the initial
431 * region size. It can then grow down from addr without
432 * limit. However, linux threads has an implicit internal
433 * limit to stack size of STACK_SIZE. Its just not
434 * enforced explicitly in linux. But, here we impose
435 * a limit of (STACK_SIZE - GUARD_SIZE) on the stack
436 * region, since we can do this with our mmap.
437 *
438 * Our mmap with MAP_STACK takes addr as the maximum
439 * downsize limit on BOS, and as len the max size of
440 * the region. It them maps the top SGROWSIZ bytes,
441 * and autgrows the region down, up to the limit
442 * in addr.
443 *
444 * If we don't use the MAP_STACK option, the effect
445 * of this code is to allocate a stack region of a
446 * fixed size of (STACK_SIZE - GUARD_SIZE).
447 */
448
449 /* This gives us TOS */
450 bsd_args.addr = linux_args.addr + linux_args.len;
451
452 if (bsd_args.addr > p->p_vmspace->vm_maxsaddr) {
453 /* Some linux apps will attempt to mmap
454 * thread stacks near the top of their
455 * address space. If their TOS is greater
456 * than vm_maxsaddr, vm_map_growstack()
457 * will confuse the thread stack with the
458 * process stack and deliver a SEGV if they
459 * attempt to grow the thread stack past their
460 * current stacksize rlimit. To avoid this,
461 * adjust vm_maxsaddr upwards to reflect
462 * the current stacksize rlimit rather
463 * than the maximum possible stacksize.
464 * It would be better to adjust the
465 * mmap'ed region, but some apps do not check
466 * mmap's return value.
467 */
468 p->p_vmspace->vm_maxsaddr = (char *)USRSTACK -
469 p->p_rlimit[RLIMIT_STACK].rlim_cur;
470 }
471
472 /* This gives us our maximum stack size */
473 if (linux_args.len > STACK_SIZE - GUARD_SIZE)
474 bsd_args.len = linux_args.len;
475 else
476 bsd_args.len = STACK_SIZE - GUARD_SIZE;
477
478 /* This gives us a new BOS. If we're using VM_STACK, then
479 * mmap will just map the top SGROWSIZ bytes, and let
480 * the stack grow down to the limit at BOS. If we're
481 * not using VM_STACK we map the full stack, since we
482 * don't have a way to autogrow it.
483 */
484 bsd_args.addr -= bsd_args.len;
485 } else {
486 bsd_args.addr = linux_args.addr;
487 bsd_args.len = linux_args.len;
488 }
489
490 bsd_args.prot = linux_args.prot | PROT_READ; /* always required */
491 if (linux_args.flags & LINUX_MAP_ANON)
492 bsd_args.fd = -1;
493 else
494 bsd_args.fd = linux_args.fd;
495 bsd_args.pos = linux_args.pos;
496 bsd_args.pad = 0;
497
498#ifdef DEBUG
499 if (ldebug(mmap))
500 printf("-> (%p, %d, %d, 0x%08x, %d, %d)\n",
501 (void *)bsd_args.addr, bsd_args.len, bsd_args.prot,
502 bsd_args.flags, bsd_args.fd, (int)bsd_args.pos);
503#endif
504
41c20dac 505 return (mmap(&bsd_args));
984263bc
MD
506}
507
508int
41c20dac 509linux_pipe(struct linux_pipe_args *args)
984263bc 510{
41c20dac 511 struct proc *p = curproc;
984263bc
MD
512 int error;
513 int reg_edx;
514
515#ifdef DEBUG
516 if (ldebug(pipe))
517 printf(ARGS(pipe, "*"));
518#endif
519
520 reg_edx = p->p_retval[1];
41c20dac 521 error = pipe(NULL);
984263bc
MD
522 if (error) {
523 p->p_retval[1] = reg_edx;
524 return (error);
525 }
526
527 error = copyout(p->p_retval, args->pipefds, 2*sizeof(int));
528 if (error) {
529 p->p_retval[1] = reg_edx;
530 return (error);
531 }
532
533 p->p_retval[1] = reg_edx;
534 p->p_retval[0] = 0;
535 return (0);
536}
537
538int
41c20dac 539linux_ioperm(struct linux_ioperm_args *args)
984263bc
MD
540{
541 struct sysarch_args sa;
542 struct i386_ioperm_args *iia;
543 caddr_t sg;
544
545 sg = stackgap_init();
546 iia = stackgap_alloc(&sg, sizeof(struct i386_ioperm_args));
547 iia->start = args->start;
548 iia->length = args->length;
549 iia->enable = args->enable;
550 sa.op = I386_SET_IOPERM;
551 sa.parms = (char *)iia;
41c20dac 552 return (sysarch(&sa));
984263bc
MD
553}
554
555int
41c20dac 556linux_iopl(struct linux_iopl_args *args)
984263bc 557{
dadab5e9
MD
558 struct thread *td = curthread;
559 struct proc *p = td->td_proc;
984263bc
MD
560 int error;
561
dadab5e9
MD
562 KKASSERT(p);
563
984263bc
MD
564 if (args->level < 0 || args->level > 3)
565 return (EINVAL);
dadab5e9 566 if ((error = suser(td)) != 0)
984263bc
MD
567 return (error);
568 if (securelevel > 0)
569 return (EPERM);
570 p->p_md.md_regs->tf_eflags = (p->p_md.md_regs->tf_eflags & ~PSL_IOPL) |
571 (args->level * (PSL_IOPL / 3));
572 return (0);
573}
574
575int
41c20dac 576linux_modify_ldt(struct linux_modify_ldt_args *uap)
984263bc 577{
41c20dac 578 struct proc *p = curproc;
984263bc
MD
579 int error;
580 caddr_t sg;
581 struct sysarch_args args;
582 struct i386_ldt_args *ldt;
583 struct l_descriptor ld;
584 union descriptor *desc;
585
586 sg = stackgap_init();
587
588 if (uap->ptr == NULL)
589 return (EINVAL);
590
591 switch (uap->func) {
592 case 0x00: /* read_ldt */
593 ldt = stackgap_alloc(&sg, sizeof(*ldt));
594 ldt->start = 0;
595 ldt->descs = uap->ptr;
596 ldt->num = uap->bytecount / sizeof(union descriptor);
597 args.op = I386_GET_LDT;
598 args.parms = (char*)ldt;
41c20dac 599 error = sysarch(&args);
984263bc
MD
600 p->p_retval[0] *= sizeof(union descriptor);
601 break;
602 case 0x01: /* write_ldt */
603 case 0x11: /* write_ldt */
604 if (uap->bytecount != sizeof(ld))
605 return (EINVAL);
606
607 error = copyin(uap->ptr, &ld, sizeof(ld));
608 if (error)
609 return (error);
610
611 ldt = stackgap_alloc(&sg, sizeof(*ldt));
612 desc = stackgap_alloc(&sg, sizeof(*desc));
613 ldt->start = ld.entry_number;
614 ldt->descs = desc;
615 ldt->num = 1;
616 desc->sd.sd_lolimit = (ld.limit & 0x0000ffff);
617 desc->sd.sd_hilimit = (ld.limit & 0x000f0000) >> 16;
618 desc->sd.sd_lobase = (ld.base_addr & 0x00ffffff);
619 desc->sd.sd_hibase = (ld.base_addr & 0xff000000) >> 24;
620 desc->sd.sd_type = SDT_MEMRO | ((ld.read_exec_only ^ 1) << 1) |
621 (ld.contents << 2);
622 desc->sd.sd_dpl = 3;
623 desc->sd.sd_p = (ld.seg_not_present ^ 1);
624 desc->sd.sd_xx = 0;
625 desc->sd.sd_def32 = ld.seg_32bit;
626 desc->sd.sd_gran = ld.limit_in_pages;
627 args.op = I386_SET_LDT;
628 args.parms = (char*)ldt;
41c20dac 629 error = sysarch(&args);
984263bc
MD
630 break;
631 default:
632 error = EINVAL;
633 break;
634 }
635
636 if (error == EOPNOTSUPP) {
637 printf("linux: modify_ldt needs kernel option USER_LDT\n");
638 error = ENOSYS;
639 }
640
641 return (error);
642}
643
644int
41c20dac 645linux_sigaction(struct linux_sigaction_args *args)
984263bc
MD
646{
647 l_osigaction_t osa;
648 l_sigaction_t act, oact;
649 int error;
650
651#ifdef DEBUG
652 if (ldebug(sigaction))
653 printf(ARGS(sigaction, "%d, %p, %p"),
654 args->sig, (void *)args->nsa, (void *)args->osa);
655#endif
656
657 if (args->nsa != NULL) {
658 error = copyin((caddr_t)args->nsa, &osa,
659 sizeof(l_osigaction_t));
660 if (error)
661 return (error);
662 act.lsa_handler = osa.lsa_handler;
663 act.lsa_flags = osa.lsa_flags;
664 act.lsa_restorer = osa.lsa_restorer;
665 LINUX_SIGEMPTYSET(act.lsa_mask);
666 act.lsa_mask.__bits[0] = osa.lsa_mask;
667 }
668
41c20dac 669 error = linux_do_sigaction(args->sig, args->nsa ? &act : NULL,
984263bc
MD
670 args->osa ? &oact : NULL);
671
672 if (args->osa != NULL && !error) {
673 osa.lsa_handler = oact.lsa_handler;
674 osa.lsa_flags = oact.lsa_flags;
675 osa.lsa_restorer = oact.lsa_restorer;
676 osa.lsa_mask = oact.lsa_mask.__bits[0];
677 error = copyout(&osa, (caddr_t)args->osa,
678 sizeof(l_osigaction_t));
679 }
680
681 return (error);
682}
683
684/*
685 * Linux has two extra args, restart and oldmask. We dont use these,
686 * but it seems that "restart" is actually a context pointer that
687 * enables the signal to happen with a different register set.
688 */
689int
41c20dac 690linux_sigsuspend(struct linux_sigsuspend_args *args)
984263bc
MD
691{
692 struct sigsuspend_args bsd;
693 sigset_t *sigmask;
694 l_sigset_t mask;
695 caddr_t sg = stackgap_init();
696
697#ifdef DEBUG
698 if (ldebug(sigsuspend))
699 printf(ARGS(sigsuspend, "%08lx"), (unsigned long)args->mask);
700#endif
701
702 sigmask = stackgap_alloc(&sg, sizeof(sigset_t));
703 LINUX_SIGEMPTYSET(mask);
704 mask.__bits[0] = args->mask;
705 linux_to_bsd_sigset(&mask, sigmask);
706 bsd.sigmask = sigmask;
41c20dac 707 return (sigsuspend(&bsd));
984263bc
MD
708}
709
710int
41c20dac 711linux_rt_sigsuspend(struct linux_rt_sigsuspend_args *uap)
984263bc
MD
712{
713 l_sigset_t lmask;
714 sigset_t *bmask;
715 struct sigsuspend_args bsd;
716 caddr_t sg = stackgap_init();
717 int error;
718
719#ifdef DEBUG
720 if (ldebug(rt_sigsuspend))
721 printf(ARGS(rt_sigsuspend, "%p, %d"),
722 (void *)uap->newset, uap->sigsetsize);
723#endif
724
725 if (uap->sigsetsize != sizeof(l_sigset_t))
726 return (EINVAL);
727
728 error = copyin(uap->newset, &lmask, sizeof(l_sigset_t));
729 if (error)
730 return (error);
731
732 bmask = stackgap_alloc(&sg, sizeof(sigset_t));
733 linux_to_bsd_sigset(&lmask, bmask);
734 bsd.sigmask = bmask;
41c20dac 735 return (sigsuspend(&bsd));
984263bc
MD
736}
737
738int
41c20dac 739linux_pause(struct linux_pause_args *args)
984263bc 740{
41c20dac 741 struct proc *p = curproc;
984263bc
MD
742 struct sigsuspend_args bsd;
743 sigset_t *sigmask;
744 caddr_t sg = stackgap_init();
745
746#ifdef DEBUG
747 if (ldebug(pause))
748 printf(ARGS(pause, ""));
749#endif
750
751 sigmask = stackgap_alloc(&sg, sizeof(sigset_t));
752 *sigmask = p->p_sigmask;
753 bsd.sigmask = sigmask;
41c20dac 754 return (sigsuspend(&bsd));
984263bc
MD
755}
756
757int
41c20dac 758linux_sigaltstack(struct linux_sigaltstack_args *uap)
984263bc
MD
759{
760 struct sigaltstack_args bsd;
761 stack_t *ss, *oss;
762 l_stack_t lss;
763 int error;
764 caddr_t sg = stackgap_init();
765
766#ifdef DEBUG
767 if (ldebug(sigaltstack))
768 printf(ARGS(sigaltstack, "%p, %p"), uap->uss, uap->uoss);
769#endif
770
771 if (uap->uss == NULL) {
772 ss = NULL;
773 } else {
774 error = copyin(uap->uss, &lss, sizeof(l_stack_t));
775 if (error)
776 return (error);
777
778 ss = stackgap_alloc(&sg, sizeof(stack_t));
779 ss->ss_sp = lss.ss_sp;
780 ss->ss_size = lss.ss_size;
781 ss->ss_flags = linux_to_bsd_sigaltstack(lss.ss_flags);
782 }
783 oss = (uap->uoss != NULL)
784 ? stackgap_alloc(&sg, sizeof(stack_t))
785 : NULL;
786
787 bsd.ss = ss;
788 bsd.oss = oss;
41c20dac 789 error = sigaltstack(&bsd);
984263bc
MD
790
791 if (!error && oss != NULL) {
792 lss.ss_sp = oss->ss_sp;
793 lss.ss_size = oss->ss_size;
794 lss.ss_flags = bsd_to_linux_sigaltstack(oss->ss_flags);
795 error = copyout(&lss, uap->uoss, sizeof(l_stack_t));
796 }
797
798 return (error);
799}