Annotation of sys/compat/hpux/hpux_sig.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: hpux_sig.c,v 1.9 2004/09/19 21:56:18 mickey Exp $ */
! 2: /* $NetBSD: hpux_sig.c,v 1.16 1997/04/01 19:59:02 scottr Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1988 University of Utah.
! 6: * Copyright (c) 1990, 1993
! 7: * The Regents of the University of California. All rights reserved.
! 8: *
! 9: * This code is derived from software contributed to Berkeley by
! 10: * the Systems Programming Group of the University of Utah Computer
! 11: * Science Department.
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. Neither the name of the University nor the names of its contributors
! 22: * may be used to endorse or promote products derived from this software
! 23: * without specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: * from: Utah $Hdr: hpux_sig.c 1.4 92/01/20$
! 38: *
! 39: * @(#)hpux_sig.c 8.2 (Berkeley) 9/23/93
! 40: */
! 41:
! 42: /*
! 43: * Signal related HPUX compatibility routines
! 44: */
! 45:
! 46: #include <sys/param.h>
! 47: #include <sys/systm.h>
! 48: #include <sys/kernel.h>
! 49: #include <sys/mount.h>
! 50: #include <sys/proc.h>
! 51: #include <sys/signalvar.h>
! 52: #include <sys/syscallargs.h>
! 53:
! 54: #include <compat/hpux/hpux.h>
! 55: #include <compat/hpux/hpux_sig.h>
! 56: #include <compat/hpux/hpux_syscallargs.h>
! 57:
! 58: /* indexed by HPUX signal number - 1 */
! 59: char hpuxtobsdsigmap[NSIG] = {
! 60: /*01*/ SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGTRAP, SIGIOT, SIGEMT, SIGFPE,
! 61: /*09*/ SIGKILL, SIGBUS, SIGSEGV, SIGSYS, SIGPIPE, SIGALRM, SIGTERM, SIGUSR1,
! 62: /*17*/ SIGUSR2, SIGCHLD, 0, SIGVTALRM,SIGPROF, SIGIO, SIGWINCH, SIGSTOP,
! 63: /*25*/ SIGTSTP, SIGCONT,SIGTTIN, SIGTTOU, SIGURG, 0, 0, 0
! 64: };
! 65:
! 66: /* indexed by BSD signal number - 1 */
! 67: char bsdtohpuxsigmap[NSIG] = {
! 68: /*01*/ 1, 2, 3, 4, 5, 6, 7, 8,
! 69: /*09*/ 9, 10, 11, 12, 13, 14, 15, 29,
! 70: /*17*/ 24, 25, 26, 18, 27, 28, 22, 0,
! 71: /*25*/ 0, 20, 21, 23, 0, 16, 17, 0
! 72: };
! 73:
! 74: /*
! 75: * XXX: In addition to mapping the signal number we also have
! 76: * to see if the "old" style signal mechinism is needed.
! 77: * If so, we set the OUSIG flag. This is not really correct
! 78: * as under HP-UX "old" style handling can be set on a per
! 79: * signal basis and we are setting it for all signals in one
! 80: * swell foop. I suspect we can get away with this since I
! 81: * doubt any program of interest mixes the two semantics.
! 82: */
! 83: int
! 84: hpux_sys_sigvec(p, v, retval)
! 85: struct proc *p;
! 86: void *v;
! 87: register_t *retval;
! 88: {
! 89: struct hpux_sys_sigvec_args *uap = v;
! 90: struct sigvec vec;
! 91: struct sigacts *ps = p->p_sigacts;
! 92: struct sigvec *sv;
! 93: int sig;
! 94: int bit, error;
! 95:
! 96: sig = hpuxtobsdsig(SCARG(uap, signo));
! 97: if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
! 98: return (EINVAL);
! 99: sv = &vec;
! 100: if (SCARG(uap, osv)) {
! 101: sv->sv_handler = ps->ps_sigact[sig];
! 102: sv->sv_mask = ps->ps_catchmask[sig];
! 103: bit = sigmask(sig);
! 104: sv->sv_flags = 0;
! 105: if ((ps->ps_sigonstack & bit) != 0)
! 106: sv->sv_flags |= SV_ONSTACK;
! 107: if ((ps->ps_sigintr & bit) != 0)
! 108: sv->sv_flags |= SV_INTERRUPT;
! 109: if ((ps->ps_sigreset & bit) != 0)
! 110: sv->sv_flags |= HPUXSV_RESET;
! 111: sv->sv_mask &= ~bit;
! 112: error = copyout((caddr_t)sv, (caddr_t)SCARG(uap, osv),
! 113: sizeof (vec));
! 114: if (error)
! 115: return (error);
! 116: }
! 117: if (SCARG(uap, nsv)) {
! 118: error = copyin((caddr_t)SCARG(uap, nsv), (caddr_t)sv,
! 119: sizeof (vec));
! 120: if (error)
! 121: return (error);
! 122: if (sig == SIGCONT && sv->sv_handler == SIG_IGN)
! 123: return (EINVAL);
! 124: sv->sv_flags ^= SA_RESTART;
! 125: setsigvec(p, sig, (struct sigaction *)sv);
! 126: #if 0
! 127: /* XXX -- SOUSIG no longer exists, do something here */
! 128: if (sv->sv_flags & HPUXSV_RESET)
! 129: p->p_flag |= SOUSIG; /* XXX */
! 130: #endif
! 131: }
! 132: return (0);
! 133: }
! 134:
! 135: int
! 136: hpux_sys_sigblock(p, v, retval)
! 137: struct proc *p;
! 138: void *v;
! 139: register_t *retval;
! 140: {
! 141: struct hpux_sys_sigblock_args *uap = v;
! 142:
! 143: (void) splhigh();
! 144: *retval = bsdtohpuxmask(p->p_sigmask);
! 145: p->p_sigmask |= hpuxtobsdmask(SCARG(uap, mask)) &~ sigcantmask;
! 146: (void) spl0();
! 147: return (0);
! 148: }
! 149:
! 150: int
! 151: hpux_sys_sigsetmask(p, v, retval)
! 152: struct proc *p;
! 153: void *v;
! 154: register_t *retval;
! 155: {
! 156: struct hpux_sys_sigsetmask_args *uap = v;
! 157:
! 158: (void) splhigh();
! 159: *retval = bsdtohpuxmask(p->p_sigmask);
! 160: p->p_sigmask = hpuxtobsdmask(SCARG(uap, mask)) &~ sigcantmask;
! 161: (void) spl0();
! 162: return (0);
! 163: }
! 164:
! 165: int
! 166: hpux_sys_sigpause(p, v, retval)
! 167: struct proc *p;
! 168: void *v;
! 169: register_t *retval;
! 170: {
! 171: struct hpux_sys_sigpause_args *uap = v;
! 172:
! 173: SCARG(uap, mask) = hpuxtobsdmask(SCARG(uap, mask));
! 174: return (sys_sigsuspend(p, uap, retval));
! 175: }
! 176:
! 177: /* not totally correct, but close enuf' */
! 178: int
! 179: hpux_sys_kill(p, v, retval)
! 180: struct proc *p;
! 181: void *v;
! 182: register_t *retval;
! 183: {
! 184: struct hpux_sys_kill_args *uap = v;
! 185:
! 186: if (SCARG(uap, signo)) {
! 187: SCARG(uap, signo) = hpuxtobsdsig(SCARG(uap, signo));
! 188: if (SCARG(uap, signo) == 0)
! 189: SCARG(uap, signo) = NSIG;
! 190: }
! 191: return (sys_kill(p, uap, retval));
! 192: }
! 193:
! 194: /*
! 195: * The following (sigprocmask, sigpending, sigsuspend, sigaction are
! 196: * POSIX calls. Under BSD, the library routine dereferences the sigset_t
! 197: * pointers before traping. Not so under HP-UX.
! 198: */
! 199:
! 200: /*
! 201: * Manipulate signal mask.
! 202: * Note that we receive new mask, not pointer,
! 203: * and return old mask as return value;
! 204: * the library stub does the rest.
! 205: */
! 206: int
! 207: hpux_sys_sigprocmask(p, v, retval)
! 208: struct proc *p;
! 209: void *v;
! 210: register_t *retval;
! 211: {
! 212: struct hpux_sys_sigprocmask_args *uap = v;
! 213: int mask, error = 0;
! 214: hpux_sigset_t sigset;
! 215:
! 216: /*
! 217: * Copy out old mask first to ensure no errors.
! 218: * (proc sigmask should not be changed if call fails for any reason)
! 219: */
! 220: if (SCARG(uap, oset)) {
! 221: bzero((caddr_t)&sigset, sizeof(sigset));
! 222: sigset.sigset[0] = bsdtohpuxmask(p->p_sigmask);
! 223: if (copyout((caddr_t)&sigset, (caddr_t)SCARG(uap, oset),
! 224: sizeof(sigset)))
! 225: return (EFAULT);
! 226: }
! 227: if (SCARG(uap, set)) {
! 228: if (copyin((caddr_t)SCARG(uap, set), (caddr_t)&sigset,
! 229: sizeof(sigset)))
! 230: return (EFAULT);
! 231: mask = hpuxtobsdmask(sigset.sigset[0]);
! 232: (void) splhigh();
! 233: switch (SCARG(uap, how)) {
! 234: case HPUXSIG_BLOCK:
! 235: p->p_sigmask |= mask &~ sigcantmask;
! 236: break;
! 237: case HPUXSIG_UNBLOCK:
! 238: p->p_sigmask &= ~mask;
! 239: break;
! 240: case HPUXSIG_SETMASK:
! 241: p->p_sigmask = mask &~ sigcantmask;
! 242: break;
! 243: default:
! 244: error = EINVAL;
! 245: break;
! 246: }
! 247: (void) spl0();
! 248: }
! 249: return (error);
! 250: }
! 251:
! 252: int
! 253: hpux_sys_sigpending(p, v, retval)
! 254: struct proc *p;
! 255: void *v;
! 256: register_t *retval;
! 257: {
! 258: struct hpux_sys_sigpending_args *uap = v;
! 259: hpux_sigset_t sigset;
! 260:
! 261: sigset.sigset[0] = bsdtohpuxmask(p->p_siglist);
! 262: return (copyout((caddr_t)&sigset, (caddr_t)SCARG(uap, set),
! 263: sizeof(sigset)));
! 264: }
! 265:
! 266: int
! 267: hpux_sys_sigsuspend(p, v, retval)
! 268: struct proc *p;
! 269: void *v;
! 270: register_t *retval;
! 271: {
! 272: struct hpux_sys_sigsuspend_args *uap = v;
! 273: struct sigacts *ps = p->p_sigacts;
! 274: hpux_sigset_t sigset;
! 275: int mask;
! 276:
! 277: if (copyin((caddr_t)SCARG(uap, set), (caddr_t)&sigset, sizeof(sigset)))
! 278: return (EFAULT);
! 279: mask = hpuxtobsdmask(sigset.sigset[0]);
! 280: ps->ps_oldmask = p->p_sigmask;
! 281: ps->ps_flags |= SAS_OLDMASK;
! 282: p->p_sigmask = mask &~ sigcantmask;
! 283: (void) tsleep((caddr_t)ps, PPAUSE | PCATCH, "pause", 0);
! 284: /* always return EINTR rather than ERESTART... */
! 285: return (EINTR);
! 286: }
! 287:
! 288: int
! 289: hpux_sys_sigaction(p, v, retval)
! 290: struct proc *p;
! 291: void *v;
! 292: register_t *retval;
! 293: {
! 294: struct hpux_sys_sigaction_args *uap = v;
! 295: struct hpux_sigaction action;
! 296: struct sigacts *ps = p->p_sigacts;
! 297: struct hpux_sigaction *sa;
! 298: int sig;
! 299: int bit;
! 300:
! 301: sig = hpuxtobsdsig(SCARG(uap, signo));
! 302: if (sig <= 0 || sig >= NSIG || sig == SIGKILL || sig == SIGSTOP)
! 303: return (EINVAL);
! 304:
! 305: sa = &action;
! 306: if (SCARG(uap, osa)) {
! 307: sa->sa__handler = ps->ps_sigact[sig];
! 308: bzero((caddr_t)&sa->sa_mask, sizeof(sa->sa_mask));
! 309: sa->sa_mask.sigset[0] = bsdtohpuxmask(ps->ps_catchmask[sig]);
! 310: bit = sigmask(sig);
! 311: sa->sa_flags = 0;
! 312: if ((ps->ps_sigonstack & bit) != 0)
! 313: sa->sa_flags |= HPUXSA_ONSTACK;
! 314: if ((ps->ps_sigreset & bit) != 0)
! 315: sa->sa_flags |= HPUXSA_RESETHAND;
! 316: if (p->p_flag & P_NOCLDSTOP)
! 317: sa->sa_flags |= HPUXSA_NOCLDSTOP;
! 318: if (p->p_flag & P_NOCLDWAIT)
! 319: sa->sa_flags |= HPUXSA_NOCLDWAIT;
! 320: if (copyout((caddr_t)sa, (caddr_t)SCARG(uap, osa),
! 321: sizeof (action)))
! 322: return (EFAULT);
! 323: }
! 324: if (SCARG(uap, nsa)) {
! 325: struct sigaction act;
! 326:
! 327: if (copyin((caddr_t)SCARG(uap, nsa), (caddr_t)sa,
! 328: sizeof (action)))
! 329: return (EFAULT);
! 330: if (sig == SIGCONT && sa->sa__handler == SIG_IGN)
! 331: return (EINVAL);
! 332: /*
! 333: * Create a sigaction struct for setsigvec
! 334: */
! 335: act.sa_handler = sa->sa__handler;
! 336: act.sa_mask = hpuxtobsdmask(sa->sa_mask.sigset[0]);
! 337: act.sa_flags = SA_RESTART;
! 338: if (sa->sa_flags & HPUXSA_ONSTACK)
! 339: act.sa_flags |= SA_ONSTACK;
! 340: if (sa->sa_flags & HPUXSA_NOCLDSTOP)
! 341: act.sa_flags |= SA_NOCLDSTOP;
! 342: if (sa->sa_flags & HPUXSA_NOCLDWAIT)
! 343: act.sa_flags |= SA_NOCLDWAIT;
! 344: setsigvec(p, sig, &act);
! 345: #if 0
! 346: /* XXX -- SOUSIG no longer exists, do something here */
! 347: if (sa->sa_flags & HPUXSA_RESETHAND)
! 348: p->p_flag |= SOUSIG; /* XXX */
! 349: #endif
! 350: }
! 351: return (0);
! 352: }
! 353:
! 354: /* signal numbers: convert from HPUX to BSD */
! 355: int
! 356: hpuxtobsdsig(sig)
! 357: int sig;
! 358: {
! 359: if (--sig < 0 || sig >= NSIG)
! 360: return(0);
! 361: return((int)hpuxtobsdsigmap[sig]);
! 362: }
! 363:
! 364: /* signal numbers: convert from BSD to HPUX */
! 365: int
! 366: bsdtohpuxsig(sig)
! 367: int sig;
! 368: {
! 369: if (--sig < 0 || sig >= NSIG)
! 370: return(0);
! 371: return((int)bsdtohpuxsigmap[sig]);
! 372: }
! 373:
! 374: /* signal masks: convert from HPUX to BSD (not pretty or fast) */
! 375: int
! 376: hpuxtobsdmask(mask)
! 377: int mask;
! 378: {
! 379: int nmask, sig, nsig;
! 380:
! 381: if (mask == 0 || mask == -1)
! 382: return(mask);
! 383: nmask = 0;
! 384: for (sig = 1; sig < NSIG; sig++)
! 385: if ((mask & sigmask(sig)) && (nsig = hpuxtobsdsig(sig)))
! 386: nmask |= sigmask(nsig);
! 387: return(nmask);
! 388: }
! 389:
! 390: int
! 391: bsdtohpuxmask(mask)
! 392: int mask;
! 393: {
! 394: int nmask, sig, nsig;
! 395:
! 396: if (mask == 0 || mask == -1)
! 397: return(mask);
! 398: nmask = 0;
! 399: for (sig = 1; sig < NSIG; sig++)
! 400: if ((mask & sigmask(sig)) && (nsig = bsdtohpuxsig(sig)))
! 401: nmask |= sigmask(nsig);
! 402: return(nmask);
! 403: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to hpux_sig.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / compat / hpux