sys/emulation/linux/i386/linux_machdep.c

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