Annotation of sys/compat/linux/linux_signal.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: linux_signal.c,v 1.12 2003/02/25 09:10:27 tedu Exp $ */
! 2: /* $NetBSD: linux_signal.c,v 1.10 1996/04/04 23:51:36 christos Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1995 Frank van der Linden
! 6: * All rights reserved.
! 7: *
! 8: * Redistribution and use in source and binary forms, with or without
! 9: * modification, are permitted provided that the following conditions
! 10: * are met:
! 11: * 1. Redistributions of source code must retain the above copyright
! 12: * notice, this list of conditions and the following disclaimer.
! 13: * 2. Redistributions in binary form must reproduce the above copyright
! 14: * notice, this list of conditions and the following disclaimer in the
! 15: * documentation and/or other materials provided with the distribution.
! 16: * 3. All advertising materials mentioning features or use of this software
! 17: * must display the following acknowledgement:
! 18: * This product includes software developed for the NetBSD Project
! 19: * by Frank van der Linden
! 20: * 4. The name of the author may not be used to endorse or promote products
! 21: * derived from this software without specific prior written permission
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 24: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 25: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 26: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 27: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 28: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 29: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 30: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 31: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 32: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 33: *
! 34: * heavily from: svr4_signal.c,v 1.7 1995/01/09 01:04:21 christos Exp
! 35: */
! 36:
! 37: #include <sys/param.h>
! 38: #include <sys/systm.h>
! 39: #include <sys/namei.h>
! 40: #include <sys/proc.h>
! 41: #include <sys/filedesc.h>
! 42: #include <sys/ioctl.h>
! 43: #include <sys/mount.h>
! 44: #include <sys/kernel.h>
! 45: #include <sys/signal.h>
! 46: #include <sys/signalvar.h>
! 47: #include <sys/malloc.h>
! 48:
! 49: #include <sys/syscallargs.h>
! 50:
! 51: #include <compat/linux/linux_types.h>
! 52: #include <compat/linux/linux_signal.h>
! 53: #include <compat/linux/linux_syscallargs.h>
! 54: #include <compat/linux/linux_util.h>
! 55:
! 56: #define sigemptyset(s) bzero((s), sizeof(*(s)))
! 57: #define sigismember(s, n) (*(s) & sigmask(n))
! 58: #define sigaddset(s, n) (*(s) |= sigmask(n))
! 59:
! 60: /* Locally used defines (in bsd<->linux conversion functions): */
! 61: #define linux_sigmask(n) (1 << ((n) - 1))
! 62: #define linux_sigemptyset(s) bzero((s), sizeof(*(s)))
! 63: #define linux_sigismember(s, n) ((s)->sig[((n) - 1) / LINUX__NSIG_BPW] \
! 64: & (1 << ((n) - 1) % LINUX__NSIG_BPW))
! 65: #define linux_sigaddset(s, n) ((s)->sig[((n) - 1) / LINUX__NSIG_BPW] \
! 66: |= (1 << ((n) - 1) % LINUX__NSIG_BPW))
! 67:
! 68: int bsd_to_linux_sig[NSIG] = {
! 69: 0,
! 70: LINUX_SIGHUP,
! 71: LINUX_SIGINT,
! 72: LINUX_SIGQUIT,
! 73: LINUX_SIGILL,
! 74: LINUX_SIGTRAP,
! 75: LINUX_SIGABRT,
! 76: LINUX_NSIG, /* XXX Kludge to get RT signal #32 to work */
! 77: LINUX_SIGFPE,
! 78: LINUX_SIGKILL,
! 79: LINUX_SIGBUS,
! 80: LINUX_SIGSEGV,
! 81: LINUX_NSIG + 1, /* XXX Kludge to get RT signal #32 to work */
! 82: LINUX_SIGPIPE,
! 83: LINUX_SIGALRM,
! 84: LINUX_SIGTERM,
! 85: LINUX_SIGURG,
! 86: LINUX_SIGSTOP,
! 87: LINUX_SIGTSTP,
! 88: LINUX_SIGCONT,
! 89: LINUX_SIGCHLD,
! 90: LINUX_SIGTTIN,
! 91: LINUX_SIGTTOU,
! 92: LINUX_SIGIO,
! 93: LINUX_SIGXCPU,
! 94: LINUX_SIGXFSZ,
! 95: LINUX_SIGVTALRM,
! 96: LINUX_SIGPROF,
! 97: LINUX_SIGWINCH,
! 98: 0, /* SIGINFO */
! 99: LINUX_SIGUSR1,
! 100: LINUX_SIGUSR2,
! 101: };
! 102:
! 103: int linux_to_bsd_sig[LINUX__NSIG] = {
! 104: 0,
! 105: SIGHUP,
! 106: SIGINT,
! 107: SIGQUIT,
! 108: SIGILL,
! 109: SIGTRAP,
! 110: SIGABRT,
! 111: SIGBUS,
! 112: SIGFPE,
! 113: SIGKILL,
! 114: SIGUSR1,
! 115: SIGSEGV,
! 116: SIGUSR2,
! 117: SIGPIPE,
! 118: SIGALRM,
! 119: SIGTERM,
! 120: 0, /* SIGSTKFLT */
! 121: SIGCHLD,
! 122: SIGCONT,
! 123: SIGSTOP,
! 124: SIGTSTP,
! 125: SIGTTIN,
! 126: SIGTTOU,
! 127: SIGURG,
! 128: SIGXCPU,
! 129: SIGXFSZ,
! 130: SIGVTALRM,
! 131: SIGPROF,
! 132: SIGWINCH,
! 133: SIGIO,
! 134: 0, /* SIGUNUSED */
! 135: 0,
! 136: SIGEMT, /* XXX Gruesome hack for linuxthreads: */
! 137: SIGSYS, /* Map 1st 2 RT signals onto ones we handle. */
! 138: 0,
! 139: 0,
! 140: 0,
! 141: 0,
! 142: 0,
! 143: 0,
! 144: 0,
! 145: 0,
! 146: 0,
! 147: 0,
! 148: 0,
! 149: 0,
! 150: 0,
! 151: 0,
! 152: 0,
! 153: 0,
! 154: 0,
! 155: 0,
! 156: 0,
! 157: 0,
! 158: 0,
! 159: 0,
! 160: 0,
! 161: 0,
! 162: 0,
! 163: 0,
! 164: 0,
! 165: 0,
! 166: 0,
! 167: 0,
! 168: };
! 169:
! 170: /*
! 171: * Convert between Linux and BSD signal sets.
! 172: */
! 173: void
! 174: linux_old_to_bsd_sigset(lss, bss)
! 175: const linux_old_sigset_t *lss;
! 176: sigset_t *bss;
! 177: {
! 178: linux_old_extra_to_bsd_sigset(lss, (const unsigned long *) 0, bss);
! 179: }
! 180:
! 181: void
! 182: bsd_to_linux_old_sigset(bss, lss)
! 183: const sigset_t *bss;
! 184: linux_old_sigset_t *lss;
! 185: {
! 186: bsd_to_linux_old_extra_sigset(bss, lss, (unsigned long *) 0);
! 187: }
! 188:
! 189: void
! 190: linux_old_extra_to_bsd_sigset(lss, extra, bss)
! 191: const linux_old_sigset_t *lss;
! 192: const unsigned long *extra;
! 193: sigset_t *bss;
! 194: {
! 195: linux_sigset_t lsnew;
! 196:
! 197: /* convert old sigset to new sigset */
! 198: linux_sigemptyset(&lsnew);
! 199: lsnew.sig[0] = *lss;
! 200: if (extra)
! 201: bcopy(extra, &lsnew.sig[1],
! 202: sizeof(linux_sigset_t) - sizeof(linux_old_sigset_t));
! 203:
! 204: linux_to_bsd_sigset(&lsnew, bss);
! 205: }
! 206:
! 207: void
! 208: bsd_to_linux_old_extra_sigset(bss, lss, extra)
! 209: const sigset_t *bss;
! 210: linux_old_sigset_t *lss;
! 211: unsigned long *extra;
! 212: {
! 213: linux_sigset_t lsnew;
! 214:
! 215: bsd_to_linux_sigset(bss, &lsnew);
! 216:
! 217: /* convert new sigset to old sigset */
! 218: *lss = lsnew.sig[0];
! 219: if (extra)
! 220: bcopy(&lsnew.sig[1], extra,
! 221: sizeof(linux_sigset_t) - sizeof(linux_old_sigset_t));
! 222: }
! 223:
! 224: void
! 225: linux_to_bsd_sigset(lss, bss)
! 226: const linux_sigset_t *lss;
! 227: sigset_t *bss;
! 228: {
! 229: int i, newsig;
! 230:
! 231: sigemptyset(bss);
! 232: for (i = 1; i < LINUX__NSIG; i++) {
! 233: if (linux_sigismember(lss, i)) {
! 234: newsig = linux_to_bsd_sig[i];
! 235: if (newsig)
! 236: sigaddset(bss, newsig);
! 237: }
! 238: }
! 239: }
! 240:
! 241: void
! 242: bsd_to_linux_sigset(bss, lss)
! 243: const sigset_t *bss;
! 244: linux_sigset_t *lss;
! 245: {
! 246: int i, newsig;
! 247:
! 248: linux_sigemptyset(lss);
! 249: for (i = 1; i < NSIG; i++) {
! 250: if (sigismember(bss, i)) {
! 251: newsig = bsd_to_linux_sig[i];
! 252: if (newsig)
! 253: linux_sigaddset(lss, newsig);
! 254: }
! 255: }
! 256: }
! 257:
! 258: /*
! 259: * Convert between Linux and BSD sigaction structures. Linux has
! 260: * one extra field (sa_restorer) which we don't support.
! 261: */
! 262: void
! 263: linux_old_to_bsd_sigaction(lsa, bsa)
! 264: struct linux_old_sigaction *lsa;
! 265: struct sigaction *bsa;
! 266: {
! 267:
! 268: bsa->sa_handler = lsa->sa__handler;
! 269: linux_old_to_bsd_sigset(&lsa->sa_mask, &bsa->sa_mask);
! 270: bsa->sa_flags = 0;
! 271: if ((lsa->sa_flags & LINUX_SA_ONSTACK) != 0)
! 272: bsa->sa_flags |= SA_ONSTACK;
! 273: if ((lsa->sa_flags & LINUX_SA_RESTART) != 0)
! 274: bsa->sa_flags |= SA_RESTART;
! 275: if ((lsa->sa_flags & LINUX_SA_ONESHOT) != 0)
! 276: bsa->sa_flags |= SA_RESETHAND;
! 277: if ((lsa->sa_flags & LINUX_SA_NOCLDSTOP) != 0)
! 278: bsa->sa_flags |= SA_NOCLDSTOP;
! 279: if ((lsa->sa_flags & LINUX_SA_NOMASK) != 0)
! 280: bsa->sa_flags |= SA_NODEFER;
! 281: }
! 282:
! 283: void
! 284: bsd_to_linux_old_sigaction(bsa, lsa)
! 285: struct sigaction *bsa;
! 286: struct linux_old_sigaction *lsa;
! 287: {
! 288:
! 289: lsa->sa__handler = bsa->sa_handler;
! 290: bsd_to_linux_old_sigset(&bsa->sa_mask, &lsa->sa_mask);
! 291: lsa->sa_flags = 0;
! 292: if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
! 293: lsa->sa_flags |= LINUX_SA_NOCLDSTOP;
! 294: if ((bsa->sa_flags & SA_ONSTACK) != 0)
! 295: lsa->sa_flags |= LINUX_SA_ONSTACK;
! 296: if ((bsa->sa_flags & SA_RESTART) != 0)
! 297: lsa->sa_flags |= LINUX_SA_RESTART;
! 298: if ((bsa->sa_flags & SA_NODEFER) != 0)
! 299: lsa->sa_flags |= LINUX_SA_NOMASK;
! 300: if ((bsa->sa_flags & SA_RESETHAND) != 0)
! 301: lsa->sa_flags |= LINUX_SA_ONESHOT;
! 302: lsa->sa_restorer = NULL;
! 303: }
! 304:
! 305: void
! 306: linux_to_bsd_sigaction(lsa, bsa)
! 307: struct linux_sigaction *lsa;
! 308: struct sigaction *bsa;
! 309: {
! 310:
! 311: bsa->sa_handler = lsa->sa__handler;
! 312: linux_to_bsd_sigset(&lsa->sa_mask, &bsa->sa_mask);
! 313: bsa->sa_flags = 0;
! 314: if ((lsa->sa_flags & LINUX_SA_NOCLDSTOP) != 0)
! 315: bsa->sa_flags |= SA_NOCLDSTOP;
! 316: if ((lsa->sa_flags & LINUX_SA_ONSTACK) != 0)
! 317: bsa->sa_flags |= SA_ONSTACK;
! 318: if ((lsa->sa_flags & LINUX_SA_RESTART) != 0)
! 319: bsa->sa_flags |= SA_RESTART;
! 320: if ((lsa->sa_flags & LINUX_SA_ONESHOT) != 0)
! 321: bsa->sa_flags |= SA_RESETHAND;
! 322: if ((lsa->sa_flags & LINUX_SA_NOMASK) != 0)
! 323: bsa->sa_flags |= SA_NODEFER;
! 324: if ((lsa->sa_flags & LINUX_SA_SIGINFO) != 0)
! 325: bsa->sa_flags |= SA_SIGINFO;
! 326: }
! 327:
! 328: void
! 329: bsd_to_linux_sigaction(bsa, lsa)
! 330: struct sigaction *bsa;
! 331: struct linux_sigaction *lsa;
! 332: {
! 333:
! 334: /* Clear sa_flags and sa_restorer (if it exists) */
! 335: bzero(lsa, sizeof(struct linux_sigaction));
! 336:
! 337: /* ...and fill in the mask and flags */
! 338: bsd_to_linux_sigset(&bsa->sa_mask, &lsa->sa_mask);
! 339: if ((bsa->sa_flags & SA_NOCLDSTOP) != 0)
! 340: lsa->sa_flags |= LINUX_SA_NOCLDSTOP;
! 341: if ((bsa->sa_flags & SA_ONSTACK) != 0)
! 342: lsa->sa_flags |= LINUX_SA_ONSTACK;
! 343: if ((bsa->sa_flags & SA_RESTART) != 0)
! 344: lsa->sa_flags |= LINUX_SA_RESTART;
! 345: if ((bsa->sa_flags & SA_NODEFER) != 0)
! 346: lsa->sa_flags |= LINUX_SA_NOMASK;
! 347: if ((bsa->sa_flags & SA_RESETHAND) != 0)
! 348: lsa->sa_flags |= LINUX_SA_ONESHOT;
! 349: if ((bsa->sa_flags & SA_SIGINFO) != 0)
! 350: lsa->sa_flags |= LINUX_SA_SIGINFO;
! 351: lsa->sa__handler = bsa->sa_handler;
! 352: }
! 353:
! 354: int
! 355: linux_to_bsd_signal(int linuxsig, int *bsdsig)
! 356: {
! 357: if (linuxsig < 0 || linuxsig >= LINUX__NSIG)
! 358: return (EINVAL);
! 359:
! 360: *bsdsig = linux_to_bsd_sig[linuxsig];
! 361: return (0);
! 362: }
! 363:
! 364: int
! 365: bsd_to_linux_signal(int bsdsig, int *linuxsig)
! 366: {
! 367: if (bsdsig < 0 || bsdsig >= NSIG)
! 368: return (EINVAL);
! 369:
! 370: *linuxsig = bsd_to_linux_sig[bsdsig];
! 371: return (0);
! 372: }
! 373:
! 374: /*
! 375: * The Linux sigaction() system call. Do the usual conversions,
! 376: * and just call sigaction(). Some flags and values are silently
! 377: * ignored (see above).
! 378: */
! 379: int
! 380: linux_sys_sigaction(p, v, retval)
! 381: register struct proc *p;
! 382: void *v;
! 383: register_t *retval;
! 384: {
! 385: struct linux_sys_sigaction_args /* {
! 386: syscallarg(int) signum;
! 387: syscallarg(struct linux_old_sigaction *) nsa;
! 388: syscallarg(struct linux_old_sigaction *) osa;
! 389: } */ *uap = v;
! 390: struct linux_old_sigaction *nlsa, *olsa, tmplsa;
! 391: struct sigaction *nbsa, *obsa, tmpbsa;
! 392: struct sys_sigaction_args sa;
! 393: caddr_t sg;
! 394: int error;
! 395:
! 396: if (SCARG(uap, signum) < 0 || SCARG(uap, signum) >= LINUX__NSIG)
! 397: return (EINVAL);
! 398:
! 399: sg = stackgap_init(p->p_emul);
! 400: nlsa = SCARG(uap, nsa);
! 401: olsa = SCARG(uap, osa);
! 402:
! 403: if (olsa != NULL)
! 404: obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
! 405: else
! 406: obsa = NULL;
! 407:
! 408: if (nlsa != NULL) {
! 409: nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
! 410: if ((error = copyin(nlsa, &tmplsa, sizeof(tmplsa))) != 0)
! 411: return (error);
! 412: linux_old_to_bsd_sigaction(&tmplsa, &tmpbsa);
! 413: if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
! 414: return (error);
! 415: } else
! 416: nbsa = NULL;
! 417:
! 418: SCARG(&sa, signum) = linux_to_bsd_sig[SCARG(uap, signum)];
! 419: SCARG(&sa, nsa) = nbsa;
! 420: SCARG(&sa, osa) = obsa;
! 421:
! 422: /* Silently ignore unknown signals */
! 423: if (SCARG(&sa, signum) == 0) {
! 424: if (obsa != NULL) {
! 425: obsa->sa_handler = SIG_IGN;
! 426: sigemptyset(&obsa->sa_mask);
! 427: obsa->sa_flags = 0;
! 428: }
! 429: }
! 430: else {
! 431: if ((error = sys_sigaction(p, &sa, retval)) != 0)
! 432: return (error);
! 433: }
! 434:
! 435: if (olsa != NULL) {
! 436: if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
! 437: return (error);
! 438: bsd_to_linux_old_sigaction(&tmpbsa, &tmplsa);
! 439: if ((error = copyout(&tmplsa, olsa, sizeof(tmplsa))) != 0)
! 440: return (error);
! 441: }
! 442:
! 443: return (0);
! 444: }
! 445:
! 446: int
! 447: linux_sys_rt_sigaction(p, v, retval)
! 448: register struct proc *p;
! 449: void *v;
! 450: register_t *retval;
! 451: {
! 452: struct linux_sys_rt_sigaction_args /* {
! 453: syscallarg(int) signum;
! 454: syscallarg(struct linux_sigaction *) nsa;
! 455: syscallarg(struct linux_sigaction *) osa;
! 456: syscallarg(size_t) sigsetsize;
! 457: } */ *uap = v;
! 458: struct linux_sigaction *nlsa, *olsa, tmplsa;
! 459: struct sigaction *nbsa, *obsa, tmpbsa;
! 460: struct sys_sigaction_args sa;
! 461: caddr_t sg;
! 462: int error;
! 463:
! 464: if (SCARG(uap, sigsetsize) != sizeof(linux_sigset_t))
! 465: return (EINVAL);
! 466:
! 467: if (SCARG(uap, signum) < 0 || SCARG(uap, signum) >= LINUX__NSIG)
! 468: return (EINVAL);
! 469:
! 470: sg = stackgap_init(p->p_emul);
! 471: nlsa = SCARG(uap, nsa);
! 472: olsa = SCARG(uap, osa);
! 473:
! 474: if (olsa != NULL)
! 475: obsa = stackgap_alloc(&sg, sizeof(struct sigaction));
! 476: else
! 477: obsa = NULL;
! 478:
! 479: if (nlsa != NULL) {
! 480: nbsa = stackgap_alloc(&sg, sizeof(struct sigaction));
! 481: if ((error = copyin(nlsa, &tmplsa, sizeof(tmplsa))) != 0)
! 482: return (error);
! 483: linux_to_bsd_sigaction(&tmplsa, &tmpbsa);
! 484: if ((error = copyout(&tmpbsa, nbsa, sizeof(tmpbsa))) != 0)
! 485: return (error);
! 486: }
! 487: else
! 488: nbsa = NULL;
! 489:
! 490: SCARG(&sa, signum) = linux_to_bsd_sig[SCARG(uap, signum)];
! 491: SCARG(&sa, nsa) = nbsa;
! 492: SCARG(&sa, osa) = obsa;
! 493:
! 494: /* Silently ignore unknown signals */
! 495: if (SCARG(&sa, signum) == 0) {
! 496: if (obsa != NULL) {
! 497: obsa->sa_handler = SIG_IGN;
! 498: sigemptyset(&obsa->sa_mask);
! 499: obsa->sa_flags = 0;
! 500: }
! 501: }
! 502: else {
! 503: if ((error = sys_sigaction(p, &sa, retval)) != 0)
! 504: return (error);
! 505: }
! 506:
! 507: if (olsa != NULL) {
! 508: if ((error = copyin(obsa, &tmpbsa, sizeof(tmpbsa))) != 0)
! 509: return (error);
! 510: bsd_to_linux_sigaction(&tmpbsa, &tmplsa);
! 511: if ((error = copyout(&tmplsa, olsa, sizeof(tmplsa))) != 0)
! 512: return (error);
! 513: }
! 514:
! 515: return (0);
! 516: }
! 517:
! 518: /*
! 519: * The Linux signal() system call. I think that the signal() in the C
! 520: * library actually calls sigaction, so I doubt this one is ever used.
! 521: * But hey, it can't hurt having it here. The same restrictions as for
! 522: * sigaction() apply.
! 523: */
! 524: int
! 525: linux_sys_signal(p, v, retval)
! 526: register struct proc *p;
! 527: void *v;
! 528: register_t *retval;
! 529: {
! 530: struct linux_sys_signal_args /* {
! 531: syscallarg(int) sig;
! 532: syscallarg(linux_handler_t) handler;
! 533: } */ *uap = v;
! 534: caddr_t sg;
! 535: struct sys_sigaction_args sa_args;
! 536: struct sigaction *osa, *nsa, tmpsa;
! 537: int error;
! 538:
! 539: if (SCARG(uap, sig) < 0 || SCARG(uap, sig) >= LINUX__NSIG)
! 540: return (EINVAL);
! 541:
! 542: sg = stackgap_init(p->p_emul);
! 543: nsa = stackgap_alloc(&sg, sizeof *nsa);
! 544: osa = stackgap_alloc(&sg, sizeof *osa);
! 545:
! 546: tmpsa.sa_handler = SCARG(uap, handler);
! 547: tmpsa.sa_mask = (sigset_t) 0;
! 548: tmpsa.sa_flags = SA_RESETHAND | SA_NODEFER;
! 549: if ((error = copyout(&tmpsa, nsa, sizeof tmpsa)))
! 550: return (error);
! 551:
! 552: SCARG(&sa_args, signum) = linux_to_bsd_sig[SCARG(uap, sig)];
! 553: SCARG(&sa_args, osa) = osa;
! 554: SCARG(&sa_args, nsa) = nsa;
! 555:
! 556: /* Silently ignore unknown signals */
! 557: if (SCARG(&sa_args, signum) != 0) {
! 558: if ((error = sys_sigaction(p, &sa_args, retval)))
! 559: return (error);
! 560: }
! 561:
! 562: if ((error = copyin(osa, &tmpsa, sizeof *osa)))
! 563: return (error);
! 564: retval[0] = (register_t) tmpsa.sa_handler;
! 565:
! 566: return (0);
! 567: }
! 568:
! 569: /*
! 570: * This is just a copy of the svr4 compat one. I feel so creative now.
! 571: */
! 572: int
! 573: linux_sys_sigprocmask(p, v, retval)
! 574: register struct proc *p;
! 575: void *v;
! 576: register_t *retval;
! 577: {
! 578: struct linux_sys_sigprocmask_args /* {
! 579: syscallarg(int) how;
! 580: syscallarg(linux_old_sigset_t *) set;
! 581: syscallarg(linux_old_sigset_t *) oset;
! 582: } */ *uap = v;
! 583: linux_old_sigset_t ss;
! 584: sigset_t bs;
! 585: int error = 0;
! 586:
! 587: *retval = 0;
! 588:
! 589: if (SCARG(uap, oset) != NULL) {
! 590: /* Fix the return value first if needed */
! 591: bsd_to_linux_old_sigset(&p->p_sigmask, &ss);
! 592: if ((error = copyout(&ss, SCARG(uap, oset), sizeof(ss))) != 0)
! 593: return (error);
! 594: }
! 595:
! 596: if (SCARG(uap, set) == NULL)
! 597: /* Just examine */
! 598: return (0);
! 599:
! 600: if ((error = copyin(SCARG(uap, set), &ss, sizeof(ss))) != 0)
! 601: return (error);
! 602:
! 603: linux_old_to_bsd_sigset(&ss, &bs);
! 604:
! 605: (void) splhigh();
! 606:
! 607: switch (SCARG(uap, how)) {
! 608: case LINUX_SIG_BLOCK:
! 609: p->p_sigmask |= bs & ~sigcantmask;
! 610: break;
! 611:
! 612: case LINUX_SIG_UNBLOCK:
! 613: p->p_sigmask &= ~bs;
! 614: break;
! 615:
! 616: case LINUX_SIG_SETMASK:
! 617: p->p_sigmask = bs & ~sigcantmask;
! 618: break;
! 619:
! 620: default:
! 621: error = EINVAL;
! 622: break;
! 623: }
! 624:
! 625: (void) spl0();
! 626:
! 627: return (error);
! 628: }
! 629:
! 630: int
! 631: linux_sys_rt_sigprocmask(p, v, retval)
! 632: register struct proc *p;
! 633: void *v;
! 634: register_t *retval;
! 635: {
! 636: struct linux_sys_rt_sigprocmask_args /* {
! 637: syscallarg(int) how;
! 638: syscallarg(const linux_sigset_t *) set;
! 639: syscallarg(linux_sigset_t *) oset;
! 640: syscallarg(size_t) sigsetsize;
! 641: } */ *uap = v;
! 642: linux_sigset_t ls;
! 643: sigset_t bs;
! 644: int error = 0;
! 645:
! 646: if (SCARG(uap, sigsetsize) != sizeof(linux_sigset_t))
! 647: return (EINVAL);
! 648:
! 649: *retval = 0;
! 650:
! 651: if (SCARG(uap, oset) != NULL) {
! 652: /* Fix the return value first if needed */
! 653: bsd_to_linux_sigset(&p->p_sigmask, &ls);
! 654: if ((error = copyout(&ls, SCARG(uap, oset), sizeof(ls))) != 0)
! 655: return (error);
! 656: }
! 657:
! 658: if (SCARG(uap, set) == NULL)
! 659: /* Just examine */
! 660: return (0);
! 661:
! 662: if ((error = copyin(SCARG(uap, set), &ls, sizeof(ls))) != 0)
! 663: return (error);
! 664:
! 665: linux_to_bsd_sigset(&ls, &bs);
! 666:
! 667: (void) splhigh();
! 668:
! 669: switch (SCARG(uap, how)) {
! 670: case LINUX_SIG_BLOCK:
! 671: p->p_sigmask |= bs & ~sigcantmask;
! 672: break;
! 673:
! 674: case LINUX_SIG_UNBLOCK:
! 675: p->p_sigmask &= ~bs;
! 676: break;
! 677:
! 678: case LINUX_SIG_SETMASK:
! 679: p->p_sigmask = bs & ~sigcantmask;
! 680: break;
! 681:
! 682: default:
! 683: error = EINVAL;
! 684: break;
! 685: }
! 686:
! 687: (void) spl0();
! 688:
! 689: return (error);
! 690: }
! 691:
! 692: /*
! 693: * The functions below really make no distinction between an int
! 694: * and [linux_]sigset_t. This is ok for now, but it might break
! 695: * sometime. Then again, sigset_t is trusted to be an int everywhere
! 696: * else in the kernel too.
! 697: */
! 698: /* ARGSUSED */
! 699: int
! 700: linux_sys_siggetmask(p, v, retval)
! 701: register struct proc *p;
! 702: void *v;
! 703: register_t *retval;
! 704: {
! 705:
! 706: bsd_to_linux_old_sigset(&p->p_sigmask, (linux_old_sigset_t *)retval);
! 707: return (0);
! 708: }
! 709:
! 710: /*
! 711: * The following three functions fiddle with a process' signal mask.
! 712: * Convert the signal masks because of the different signal
! 713: * values for Linux. The need for this is the reason why
! 714: * they are here, and have not been mapped directly.
! 715: */
! 716: int
! 717: linux_sys_sigsetmask(p, v, retval)
! 718: register struct proc *p;
! 719: void *v;
! 720: register_t *retval;
! 721: {
! 722: struct linux_sys_sigsetmask_args /* {
! 723: syscallarg(linux_old_sigset_t) mask;
! 724: } */ *uap = v;
! 725: linux_old_sigset_t mask;
! 726: sigset_t bsdsig;
! 727:
! 728: bsd_to_linux_old_sigset(&p->p_sigmask, (linux_old_sigset_t *)retval);
! 729:
! 730: mask = SCARG(uap, mask);
! 731: bsd_to_linux_old_sigset(&bsdsig, &mask);
! 732:
! 733: splhigh();
! 734: p->p_sigmask = bsdsig & ~sigcantmask;
! 735: spl0();
! 736:
! 737: return (0);
! 738: }
! 739:
! 740: int
! 741: linux_sys_sigpending(p, v, retval)
! 742: register struct proc *p;
! 743: void *v;
! 744: register_t *retval;
! 745: {
! 746: struct linux_sys_sigpending_args /* {
! 747: syscallarg(linux_old_sigset_t *) mask;
! 748: } */ *uap = v;
! 749: sigset_t bs;
! 750: linux_old_sigset_t ls;
! 751:
! 752: bs = p->p_siglist & p->p_sigmask;
! 753: bsd_to_linux_old_sigset(&bs, &ls);
! 754:
! 755: return (copyout(&ls, SCARG(uap, mask), sizeof ls));
! 756: }
! 757:
! 758: int
! 759: linux_sys_rt_sigpending(p, v, retval)
! 760: register struct proc *p;
! 761: void *v;
! 762: register_t *retval;
! 763: {
! 764: struct linux_sys_rt_sigpending_args /* {
! 765: syscallarg(linux_sigset_t *) set;
! 766: syscallarg(size_t) sigsetsize;
! 767: } */ *uap = v;
! 768: sigset_t bs;
! 769: linux_sigset_t ls;
! 770:
! 771: if (SCARG(uap, sigsetsize) != sizeof(linux_sigset_t))
! 772: return (EINVAL);
! 773:
! 774: bs = p->p_siglist & p->p_sigmask;
! 775: bsd_to_linux_sigset(&bs, &ls);
! 776:
! 777: return (copyout(&ls, SCARG(uap, set), sizeof ls));
! 778: }
! 779:
! 780: int
! 781: linux_sys_sigsuspend(p, v, retval)
! 782: register struct proc *p;
! 783: void *v;
! 784: register_t *retval;
! 785: {
! 786: struct linux_sys_sigsuspend_args /* {
! 787: syscallarg(caddr_t) restart;
! 788: syscallarg(int) oldmask;
! 789: syscallarg(int) mask;
! 790: } */ *uap = v;
! 791: struct sys_sigsuspend_args sa;
! 792: linux_old_sigset_t mask = SCARG(uap, mask);
! 793:
! 794: linux_old_to_bsd_sigset(&mask, &SCARG(&sa, mask));
! 795: return (sys_sigsuspend(p, &sa, retval));
! 796: }
! 797:
! 798: int
! 799: linux_sys_rt_sigsuspend(p, v, retval)
! 800: register struct proc *p;
! 801: void *v;
! 802: register_t *retval;
! 803: {
! 804: struct linux_sys_rt_sigsuspend_args /* {
! 805: syscallarg(sigset_t *) unewset;
! 806: syscallarg(size_t) sigsetsize;
! 807: } */ *uap = v;
! 808: struct sys_sigsuspend_args sa;
! 809: linux_sigset_t mask;
! 810: int error;
! 811:
! 812: if (SCARG(uap, sigsetsize) != sizeof(linux_sigset_t))
! 813: return (EINVAL);
! 814:
! 815: error = copyin(SCARG(uap, unewset), &mask, sizeof mask);
! 816: if (error)
! 817: return (error);
! 818:
! 819: linux_to_bsd_sigset(&mask, &SCARG(&sa, mask));
! 820: return (sys_sigsuspend(p, &sa, retval));
! 821: }
! 822:
! 823: /*
! 824: * Linux' sigaltstack structure is just of a different order than BSD's
! 825: * so just shuffle the fields around and call our version.
! 826: */
! 827: int
! 828: linux_sys_sigaltstack(p, v, retval)
! 829: register struct proc *p;
! 830: void *v;
! 831: register_t *retval;
! 832: {
! 833: struct linux_sys_sigaltstack_args /* {
! 834: syscallarg(const struct linux_sigaltstack *) nss;
! 835: syscallarg(struct linux_sigaltstack *) oss;
! 836: } */ *uap = v;
! 837: struct linux_sigaltstack linux_ss;
! 838: struct sigaltstack *bsd_nss, *bsd_oss;
! 839: struct sys_sigaltstack_args sa;
! 840: int error;
! 841: caddr_t sg;
! 842:
! 843: sg = stackgap_init(p->p_emul);
! 844:
! 845: if (SCARG(uap, nss) != NULL) {
! 846: bsd_nss = stackgap_alloc(&sg, sizeof *bsd_nss);
! 847:
! 848: error = copyin(SCARG(uap, nss), &linux_ss, sizeof linux_ss);
! 849: if (error)
! 850: return (error);
! 851:
! 852: bsd_nss->ss_sp = linux_ss.ss_sp;
! 853: bsd_nss->ss_size = linux_ss.ss_size;
! 854: bsd_nss->ss_flags = (linux_ss.ss_flags & LINUX_SS_DISABLE) ?
! 855: SS_DISABLE : 0;
! 856:
! 857: SCARG(&sa, nss) = bsd_nss;
! 858: } else
! 859: SCARG(&sa, nss) = NULL;
! 860:
! 861: if (SCARG(uap, oss) == NULL) {
! 862: SCARG(&sa, oss) = NULL;
! 863: return (sys_sigaltstack(p, &sa, retval));
! 864: }
! 865: SCARG(&sa, oss) = bsd_oss = stackgap_alloc(&sg, sizeof *bsd_oss);
! 866:
! 867: error = sys_sigaltstack(p, &sa, retval);
! 868: if (error)
! 869: return (error);
! 870:
! 871: linux_ss.ss_sp = bsd_oss->ss_sp;
! 872: linux_ss.ss_size = bsd_oss->ss_size;
! 873: linux_ss.ss_flags = 0;
! 874: if (bsd_oss->ss_flags & SS_ONSTACK)
! 875: linux_ss.ss_flags |= LINUX_SS_ONSTACK;
! 876: if (bsd_oss->ss_flags & SS_DISABLE)
! 877: linux_ss.ss_flags |= LINUX_SS_DISABLE;
! 878: return (copyout(&linux_ss, SCARG(uap, oss), sizeof linux_ss));
! 879: }
! 880:
! 881: /*
! 882: * The deprecated pause(2), which is really just an instance
! 883: * of sigsuspend(2).
! 884: */
! 885: int
! 886: linux_sys_pause(p, v, retval)
! 887: register struct proc *p;
! 888: void *v;
! 889: register_t *retval;
! 890: {
! 891: struct sys_sigsuspend_args bsa;
! 892:
! 893: SCARG(&bsa, mask) = p->p_sigmask;
! 894: return (sys_sigsuspend(p, &bsa, retval));
! 895: }
! 896:
! 897: /*
! 898: * Once more: only a signal conversion is needed.
! 899: */
! 900: int
! 901: linux_sys_kill(p, v, retval)
! 902: register struct proc *p;
! 903: void *v;
! 904: register_t *retval;
! 905: {
! 906: struct linux_sys_kill_args /* {
! 907: syscallarg(int) pid;
! 908: syscallarg(int) signum;
! 909: } */ *uap = v;
! 910: struct sys_kill_args ka;
! 911:
! 912: SCARG(&ka, pid) = SCARG(uap, pid);
! 913: if (SCARG(uap, signum) < 0 || SCARG(uap, signum) >= LINUX__NSIG)
! 914: return (EINVAL);
! 915: SCARG(&ka, signum) = linux_to_bsd_sig[SCARG(uap, signum)];
! 916: return (sys_kill(p, &ka, retval));
! 917: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to linux_signal.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / linux