usr/src/lib/libshell/common/sh/fault.c

   1 /***********************************************************************
   2 *                                                                      *
   3 *               This software is part of the ast package               *
   4 *          Copyright (c) 1982-2010 AT&T Intellectual Property          *
   5 *                      and is licensed under the                       *
   6 *                  Common Public License, Version 1.0                  *
   7 *                    by AT&T Intellectual Property                     *
   8 *                                                                      *
   9 *                A copy of the License is available at                 *
  10 *            http://www.opensource.org/licenses/cpl1.0.txt             *
  11 *         (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9)         *
  12 *                                                                      *
  13 *              Information and Software Systems Research               *
  14 *                            AT&T Research                             *
  15 *                           Florham Park NJ                            *
  16 *                                                                      *
  17 *                  David Korn <dgk@research.att.com>                   *
  18 *                                                                      *
  19 ***********************************************************************/
  20 #pragma prototyped
  21 /*
  22  * Fault handling routines
  23  *
  24  *   David Korn
  25  *   AT&T Labs
  26  *
  27  */
  28
  29 #include        "defs.h"
  30 #include        <fcin.h>
  31 #include        "io.h"
  32 #include        "history.h"
  33 #include        "shlex.h"
  34 #include        "variables.h"
  35 #include        "jobs.h"
  36 #include        "path.h"
  37 #include        "builtins.h"
  38
  39 #define abortsig(sig)   (sig==SIGABRT || sig==SIGBUS || sig==SIGILL || sig==SIGSEGV)
  40
  41 static char     indone;
  42
  43 #if !_std_malloc
  44 #   include     <vmalloc.h>
  45 #endif
  46 #if  defined(VMFL) && (VMALLOC_VERSION>=20031205L)
  47     /*
  48      * This exception handler is called after vmalloc() unlocks the region
  49      */
  50     static int malloc_done(Vmalloc_t* vm, int type, Void_t* val, Vmdisc_t* dp)
  51     {
  52         dp->exceptf = 0;
  53         sh_exit(SH_EXITSIG);
  54         return(0);
  55     }
  56 #endif
  57
  58 /*
  59  * Most signals caught or ignored by the shell come here
  60 */
  61 void    sh_fault(register int sig)
  62 {
  63         register Shell_t        *shp = sh_getinterp();
  64         register int            flag=0;
  65         register char           *trap;
  66         register struct checkpt *pp = (struct checkpt*)shp->jmplist;
  67         int     action=0;
  68         /* reset handler */
  69         if(!(sig&SH_TRAP))
  70                 signal(sig, sh_fault);
  71         sig &= ~SH_TRAP;
  72 #ifdef SIGWINCH
  73         if(sig==SIGWINCH)
  74         {
  75                 int rows=0, cols=0;
  76                 int32_t v;
  77                 astwinsize(2,&rows,&cols);
  78                 if(v = cols)
  79                         nv_putval(COLUMNS, (char*)&v, NV_INT32|NV_RDONLY);
  80                 if(v = rows)
  81                         nv_putval(LINES, (char*)&v, NV_INT32|NV_RDONLY);
  82                 shp->winch++;
  83         }
  84 #endif  /* SIGWINCH */
  85         if(shp->savesig)
  86         {
  87                 /* critical region, save and process later */
  88                 shp->savesig = sig;
  89                 return;
  90         }
  91         trap = shp->st.trapcom[sig];
  92         if(sig==SIGALRM && shp->bltinfun==b_sleep)
  93         {
  94                 if(trap && *trap)
  95                 {
  96                         shp->trapnote |= SH_SIGTRAP;
  97                         shp->sigflag[sig] |= SH_SIGTRAP;
  98                 }
  99                 return;
 100         }
 101         if(shp->subshell && sig!=SIGINT && sig!=SIGQUIT && sig!=SIGWINCH && sig!=SIGCONT)
 102         {
 103                 shp->exitval = SH_EXITSIG|sig;
 104                 sh_subfork();
 105                 shp->exitval = 0;
 106                 return;
 107         }
 108         /* handle ignored signals */
 109         if(trap && *trap==0)
 110                 return;
 111         flag = shp->sigflag[sig]&~SH_SIGOFF;
 112         if(!trap)
 113         {
 114                 if(sig==SIGINT && (shp->trapnote&SH_SIGIGNORE))
 115                         return;
 116                 if(flag&SH_SIGIGNORE)
 117                         return;
 118                 if(flag&SH_SIGDONE)
 119                 {
 120                         void *ptr=0;
 121                         if((flag&SH_SIGINTERACTIVE) && sh_isstate(SH_INTERACTIVE) && !sh_isstate(SH_FORKED) && ! shp->subshell)
 122                         {
 123                                 /* check for TERM signal between fork/exec */
 124                                 if(sig==SIGTERM && job.in_critical)
 125                                         shp->trapnote |= SH_SIGTERM;
 126                                 return;
 127                         }
 128                         shp->lastsig = sig;
 129                         sigrelease(sig);
 130                         if(pp->mode < SH_JMPFUN)
 131                                 pp->mode = SH_JMPFUN;
 132                         else
 133                                 pp->mode = SH_JMPEXIT;
 134                         if(sig==SIGABRT || (abortsig(sig) && (ptr = malloc(1))))
 135                         {
 136                                 free(ptr);
 137                                 if(!shp->subshell)
 138                                         sh_done(shp,sig);
 139                                 sh_exit(SH_EXITSIG);
 140                         }
 141                         /* mark signal and continue */
 142                         shp->trapnote |= SH_SIGSET;
 143                         if(sig <= shp->sigmax)
 144                                 shp->sigflag[sig] |= SH_SIGSET;
 145 #if  defined(VMFL) && (VMALLOC_VERSION>=20031205L)
 146                         if(abortsig(sig))
 147                         {
 148                                 /* abort inside malloc, process when malloc returns */
 149                                 /* VMFL defined when using vmalloc() */
 150                                 Vmdisc_t* dp = vmdisc(Vmregion,0);
 151                                 if(dp)
 152                                         dp->exceptf = malloc_done;
 153                         }
 154 #endif
 155                         return;
 156                 }
 157         }
 158         errno = 0;
 159         if(pp->mode==SH_JMPCMD)
 160                 shp->lastsig = sig;
 161         if(trap)
 162         {
 163                 /*
 164                  * propogate signal to foreground group
 165                  */
 166                 if(sig==SIGHUP && job.curpgid)
 167                         killpg(job.curpgid,SIGHUP);
 168                 flag = SH_SIGTRAP;
 169         }
 170         else
 171         {
 172                 shp->lastsig = sig;
 173                 flag = SH_SIGSET;
 174 #ifdef SIGTSTP
 175                 if(sig==SIGTSTP)
 176                 {
 177                         shp->trapnote |= SH_SIGTSTP;
 178                         if(pp->mode==SH_JMPCMD && sh_isstate(SH_STOPOK))
 179                         {
 180                                 sigrelease(sig);
 181                                 sh_exit(SH_EXITSIG);
 182                                 flag = 0;
 183                         }
 184                 }
 185 #endif /* SIGTSTP */
 186         }
 187 #ifdef ERROR_NOTIFY
 188         if((error_info.flags&ERROR_NOTIFY) && shp->bltinfun)
 189                 action = (*shp->bltinfun)(-sig,(char**)0,(void*)0);
 190         if(action>0)
 191                 return;
 192 #endif
 193         if(shp->bltinfun && shp->bltindata.notify)
 194         {
 195                 shp->bltindata.sigset = 1;
 196                 return;
 197         }
 198         shp->trapnote |= flag;
 199         if(sig <= shp->sigmax)
 200                 shp->sigflag[sig] |= flag;
 201         if(pp->mode==SH_JMPCMD && sh_isstate(SH_STOPOK))
 202         {
 203                 if(action<0)
 204                         return;
 205                 sigrelease(sig);
 206                 sh_exit(SH_EXITSIG);
 207         }
 208 }
 209
 210 /*
 211  * initialize signal handling
 212  */
 213 void sh_siginit(void *ptr)
 214 {
 215         Shell_t *shp = (Shell_t*)ptr;
 216         register int sig, n;
 217         register const struct shtable2  *tp = shtab_signals;
 218         sig_begin();
 219         /* find the largest signal number in the table */
 220 #if defined(SIGRTMIN) && defined(SIGRTMAX)
 221         if ((n = SIGRTMIN) > 0 && (sig = SIGRTMAX) > n && sig < SH_TRAP)
 222         {
 223                 shp->sigruntime[SH_SIGRTMIN] = n;
 224                 shp->sigruntime[SH_SIGRTMAX] = sig;
 225         }
 226 #endif /* SIGRTMIN && SIGRTMAX */
 227         n = SIGTERM;
 228         while(*tp->sh_name)
 229         {
 230                 sig = (tp->sh_number&((1<<SH_SIGBITS)-1));
 231                 if (!(sig-- & SH_TRAP))
 232                 {
 233                         if ((tp->sh_number>>SH_SIGBITS) & SH_SIGRUNTIME)
 234                                 sig = shp->sigruntime[sig];
 235                         if(sig>n && sig<SH_TRAP)
 236                                 n = sig;
 237                 }
 238                 tp++;
 239         }
 240         shp->sigmax = n++;
 241         shp->st.trapcom = (char**)calloc(n,sizeof(char*));
 242         shp->sigflag = (unsigned char*)calloc(n,1);
 243         shp->sigmsg = (char**)calloc(n,sizeof(char*));
 244         for(tp=shtab_signals; sig=tp->sh_number; tp++)
 245         {
 246                 n = (sig>>SH_SIGBITS);
 247                 if((sig &= ((1<<SH_SIGBITS)-1)) > (shp->sigmax+1))
 248                         continue;
 249                 sig--;
 250                 if(n&SH_SIGRUNTIME)
 251                         sig = shp->sigruntime[sig];
 252                 if(sig>=0)
 253                 {
 254                         shp->sigflag[sig] = n;
 255                         if(*tp->sh_name)
 256                                 shp->sigmsg[sig] = (char*)tp->sh_value;
 257                 }
 258         }
 259 }
 260
 261 /*
 262  * Turn on trap handler for signal <sig>
 263  */
 264 void    sh_sigtrap(register int sig)
 265 {
 266         register int flag;
 267         void (*fun)(int);
 268         sh.st.otrapcom = 0;
 269         if(sig==0)
 270                 sh_sigdone();
 271         else if(!((flag=sh.sigflag[sig])&(SH_SIGFAULT|SH_SIGOFF)))
 272         {
 273                 /* don't set signal if already set or off by parent */
 274                 if((fun=signal(sig,sh_fault))==SIG_IGN)
 275                 {
 276                         signal(sig,SIG_IGN);
 277                         flag |= SH_SIGOFF;
 278                 }
 279                 else
 280                 {
 281                         flag |= SH_SIGFAULT;
 282                         if(sig==SIGALRM && fun!=SIG_DFL && fun!=sh_fault)
 283                                 signal(sig,fun);
 284                 }
 285                 flag &= ~(SH_SIGSET|SH_SIGTRAP);
 286                 sh.sigflag[sig] = flag;
 287         }
 288 }
 289
 290 /*
 291  * set signal handler so sh_done is called for all caught signals
 292  */
 293 void    sh_sigdone(void)
 294 {
 295         register int    flag, sig = sh.sigmax;
 296         sh.sigflag[0] |= SH_SIGFAULT;
 297         for(sig=sh.sigmax; sig>0; sig--)
 298         {
 299                 flag = sh.sigflag[sig];
 300                 if((flag&(SH_SIGDONE|SH_SIGIGNORE|SH_SIGINTERACTIVE)) && !(flag&(SH_SIGFAULT|SH_SIGOFF)))
 301                         sh_sigtrap(sig);
 302         }
 303 }
 304
 305 /*
 306  * Restore to default signals
 307  * Free the trap strings if mode is non-zero
 308  * If mode>1 then ignored traps cause signal to be ignored
 309  */
 310 void    sh_sigreset(register int mode)
 311 {
 312         register char   *trap;
 313         register int    flag, sig=sh.st.trapmax;
 314         while(sig-- > 0)
 315         {
 316                 if(trap=sh.st.trapcom[sig])
 317                 {
 318                         flag  = sh.sigflag[sig]&~(SH_SIGTRAP|SH_SIGSET);
 319                         if(*trap)
 320                         {
 321                                 if(mode)
 322                                         free(trap);
 323                                 sh.st.trapcom[sig] = 0;
 324                         }
 325                         else if(sig && mode>1)
 326                         {
 327                                 if(sig!=SIGCHLD)
 328                                         signal(sig,SIG_IGN);
 329                                 flag &= ~SH_SIGFAULT;
 330                                 flag |= SH_SIGOFF;
 331                         }
 332                         sh.sigflag[sig] = flag;
 333                 }
 334         }
 335         for(sig=SH_DEBUGTRAP-1;sig>=0;sig--)
 336         {
 337                 if(trap=sh.st.trap[sig])
 338                 {
 339                         if(mode)
 340                                 free(trap);
 341                         sh.st.trap[sig] = 0;
 342                 }
 343
 344         }
 345         sh.st.trapcom[0] = 0;
 346         if(mode)
 347                 sh.st.trapmax = 0;
 348         sh.trapnote=0;
 349 }
 350
 351 /*
 352  * free up trap if set and restore signal handler if modified
 353  */
 354 void    sh_sigclear(register int sig)
 355 {
 356         register int flag = sh.sigflag[sig];
 357         register char *trap;
 358         sh.st.otrapcom=0;
 359         if(!(flag&SH_SIGFAULT))
 360                 return;
 361         flag &= ~(SH_SIGTRAP|SH_SIGSET);
 362         if(trap=sh.st.trapcom[sig])
 363         {
 364                 if(!sh.subshell)
 365                         free(trap);
 366                 sh.st.trapcom[sig]=0;
 367         }
 368         sh.sigflag[sig] = flag;
 369 }
 370
 371 /*
 372  * check for traps
 373  */
 374
 375 void    sh_chktrap(void)
 376 {
 377         register int    sig=sh.st.trapmax;
 378         register char *trap;
 379         if(!(sh.trapnote&~SH_SIGIGNORE))
 380                 sig=0;
 381         sh.trapnote &= ~SH_SIGTRAP;
 382         /* execute errexit trap first */
 383         if(sh_isstate(SH_ERREXIT) && sh.exitval)
 384         {
 385                 int     sav_trapnote = sh.trapnote;
 386                 sh.trapnote &= ~SH_SIGSET;
 387                 if(sh.st.trap[SH_ERRTRAP])
 388                 {
 389                         trap = sh.st.trap[SH_ERRTRAP];
 390                         sh.st.trap[SH_ERRTRAP] = 0;
 391                         sh_trap(trap,0);
 392                         sh.st.trap[SH_ERRTRAP] = trap;
 393                 }
 394                 sh.trapnote = sav_trapnote;
 395                 if(sh_isoption(SH_ERREXIT))
 396                 {
 397                         struct checkpt  *pp = (struct checkpt*)sh.jmplist;
 398                         pp->mode = SH_JMPEXIT;
 399                         sh_exit(sh.exitval);
 400                 }
 401         }
 402         if(sh.sigflag[SIGALRM]&SH_SIGALRM)
 403                 sh_timetraps();
 404 #ifdef SHOPT_BGX
 405         if((sh.sigflag[SIGCHLD]&SH_SIGTRAP) && sh.st.trapcom[SIGCHLD])
 406                 job_chldtrap(&sh,sh.st.trapcom[SIGCHLD],1);
 407 #endif /* SHOPT_BGX */
 408         while(--sig>=0)
 409         {
 410 #ifdef SHOPT_BGX
 411                 if(sig==SIGCHLD)
 412                         continue;
 413 #endif /* SHOPT_BGX */
 414                 if(sh.sigflag[sig]&SH_SIGTRAP)
 415                 {
 416                         sh.sigflag[sig] &= ~SH_SIGTRAP;
 417                         if(trap=sh.st.trapcom[sig])
 418                         {
 419                                 Sfio_t *fp;
 420                                 if(sig==SIGPIPE && (fp=sfpool((Sfio_t*)0,sh.outpool,SF_WRITE)) && sferror(fp))
 421                                         sfclose(fp);
 422                                 sh.oldexit = SH_EXITSIG|sig;
 423                                 sh_trap(trap,0);
 424                         }
 425                 }
 426         }
 427 }
 428
 429
 430 /*
 431  * parse and execute the given trap string, stream or tree depending on mode
 432  * mode==0 for string, mode==1 for stream, mode==2 for parse tree
 433  */
 434 int sh_trap(const char *trap, int mode)
 435 {
 436         Shell_t *shp = sh_getinterp();
 437         int     jmpval, savxit = shp->exitval;
 438         int     was_history = sh_isstate(SH_HISTORY);
 439         int     was_verbose = sh_isstate(SH_VERBOSE);
 440         int     staktop = staktell();
 441         char    *savptr = stakfreeze(0);
 442         char    ifstable[256];
 443         struct  checkpt buff;
 444         Fcin_t  savefc;
 445         fcsave(&savefc);
 446         memcpy(ifstable,shp->ifstable,sizeof(ifstable));
 447         sh_offstate(SH_HISTORY);
 448         sh_offstate(SH_VERBOSE);
 449         shp->intrap++;
 450         sh_pushcontext(&buff,SH_JMPTRAP);
 451         jmpval = sigsetjmp(buff.buff,0);
 452         if(jmpval == 0)
 453         {
 454                 if(mode==2)
 455                         sh_exec((Shnode_t*)trap,sh_isstate(SH_ERREXIT));
 456                 else
 457                 {
 458                         Sfio_t *sp;
 459                         if(mode)
 460                                 sp = (Sfio_t*)trap;
 461                         else
 462                                 sp = sfopen(NIL(Sfio_t*),trap,"s");
 463                         sh_eval(sp,0);
 464                 }
 465         }
 466         else if(indone)
 467         {
 468                 if(jmpval==SH_JMPSCRIPT)
 469                         indone=0;
 470                 else
 471                 {
 472                         if(jmpval==SH_JMPEXIT)
 473                                 savxit = shp->exitval;
 474                         jmpval=SH_JMPTRAP;
 475                 }
 476         }
 477         sh_popcontext(&buff);
 478         shp->intrap--;
 479         sfsync(shp->outpool);
 480         if(!shp->indebug && jmpval!=SH_JMPEXIT && jmpval!=SH_JMPFUN)
 481                 shp->exitval=savxit;
 482         stakset(savptr,staktop);
 483         fcrestore(&savefc);
 484         memcpy(shp->ifstable,ifstable,sizeof(ifstable));
 485         if(was_history)
 486                 sh_onstate(SH_HISTORY);
 487         if(was_verbose)
 488                 sh_onstate(SH_VERBOSE);
 489         exitset();
 490         if(jmpval>SH_JMPTRAP && (((struct checkpt*)shp->jmpbuffer)->prev || ((struct checkpt*)shp->jmpbuffer)->mode==SH_JMPSCRIPT))
 491                 siglongjmp(*shp->jmplist,jmpval);
 492         return(shp->exitval);
 493 }
 494
 495 /*
 496  * exit the current scope and jump to an earlier one based on pp->mode
 497  */
 498 void sh_exit(register int xno)
 499 {
 500         Shell_t *shp = &sh;
 501         register struct checkpt *pp = (struct checkpt*)shp->jmplist;
 502         register int            sig=0;
 503         register Sfio_t*        pool;
 504         shp->exitval=xno;
 505         if(xno==SH_EXITSIG)
 506                 shp->exitval |= (sig=shp->lastsig);
 507 #ifdef SIGTSTP
 508         if(shp->trapnote&SH_SIGTSTP)
 509         {
 510                 /* ^Z detected by the shell */
 511                 shp->trapnote = 0;
 512                 shp->sigflag[SIGTSTP] = 0;
 513                 if(!shp->subshell && sh_isstate(SH_MONITOR) && !sh_isstate(SH_STOPOK))
 514                         return;
 515                 if(sh_isstate(SH_TIMING))
 516                         return;
 517                 /* Handles ^Z for shell builtins, subshells, and functs */
 518                 shp->lastsig = 0;
 519                 sh_onstate(SH_MONITOR);
 520                 sh_offstate(SH_STOPOK);
 521                 shp->trapnote = 0;
 522                 if(!shp->subshell && (sig=sh_fork(0,NIL(int*))))
 523                 {
 524                         job.curpgid = 0;
 525                         job.parent = (pid_t)-1;
 526                         job_wait(sig);
 527                         job.parent = 0;
 528                         shp->sigflag[SIGTSTP] = 0;
 529                         /* wait for child to stop */
 530                         shp->exitval = (SH_EXITSIG|SIGTSTP);
 531                         /* return to prompt mode */
 532                         pp->mode = SH_JMPERREXIT;
 533                 }
 534                 else
 535                 {
 536                         if(shp->subshell)
 537                                 sh_subfork();
 538                         /* child process, put to sleep */
 539                         sh_offstate(SH_STOPOK);
 540                         sh_offstate(SH_MONITOR);
 541                         shp->sigflag[SIGTSTP] = 0;
 542                         /* stop child job */
 543                         killpg(job.curpgid,SIGTSTP);
 544                         /* child resumes */
 545                         job_clear();
 546                         shp->forked = 1;
 547                         shp->exitval = (xno&SH_EXITMASK);
 548                         return;
 549                 }
 550         }
 551 #endif /* SIGTSTP */
 552         /* unlock output pool */
 553         sh_offstate(SH_NOTRACK);
 554         if(!(pool=sfpool(NIL(Sfio_t*),shp->outpool,SF_WRITE)))
 555                 pool = shp->outpool; /* can't happen? */
 556         sfclrlock(pool);
 557 #ifdef SIGPIPE
 558         if(shp->lastsig==SIGPIPE)
 559                 sfpurge(pool);
 560 #endif /* SIGPIPE */
 561         sfclrlock(sfstdin);
 562         if(!pp)
 563                 sh_done(shp,sig);
 564         shp->prefix = 0;
 565 #if SHOPT_TYPEDEF
 566         shp->mktype = 0;
 567 #endif /* SHOPT_TYPEDEF*/
 568         if(pp->mode == SH_JMPSCRIPT && !pp->prev)
 569                 sh_done(shp,sig);
 570         if(pp->mode)
 571                 siglongjmp(pp->buff,pp->mode);
 572 }
 573
 574 static void array_notify(Namval_t *np, void *data)
 575 {
 576         Namarr_t        *ap = nv_arrayptr(np);
 577         NOT_USED(data);
 578         if(ap && ap->fun)
 579                 (*ap->fun)(np, 0, NV_AFREE);
 580 }
 581
 582 /*
 583  * This is the exit routine for the shell
 584  */
 585
 586 void sh_done(void *ptr, register int sig)
 587 {
 588         Shell_t *shp = (Shell_t*)ptr;
 589         register char *t;
 590         register int savxit = shp->exitval;
 591         shp->trapnote = 0;
 592         indone=1;
 593         if(sig)
 594                 savxit = SH_EXITSIG|sig;
 595         if(shp->userinit)
 596                 (*shp->userinit)(shp, -1);
 597         if(t=shp->st.trapcom[0])
 598         {
 599                 shp->st.trapcom[0]=0; /*should free but not long */
 600                 shp->oldexit = savxit;
 601                 sh_trap(t,0);
 602                 savxit = shp->exitval;
 603         }
 604         else
 605         {
 606                 /* avoid recursive call for set -e */
 607                 sh_offstate(SH_ERREXIT);
 608                 sh_chktrap();
 609         }
 610         nv_scan(shp->var_tree,array_notify,(void*)0,NV_ARRAY,NV_ARRAY);
 611         sh_freeup(shp);
 612 #if SHOPT_ACCT
 613         sh_accend();
 614 #endif  /* SHOPT_ACCT */
 615 #if SHOPT_VSH || SHOPT_ESH
 616         if(sh_isoption(SH_EMACS)||sh_isoption(SH_VI)||sh_isoption(SH_GMACS))
 617                 tty_cooked(-1);
 618 #endif
 619 #ifdef JOBS
 620         if((sh_isoption(SH_INTERACTIVE) && shp->login_sh) || (!sh_isoption(SH_INTERACTIVE) && (sig==SIGHUP)))
 621                 job_walk(sfstderr,job_terminate,SIGHUP,NIL(char**));
 622 #endif  /* JOBS */
 623         job_close(shp);
 624         if(nv_search("VMTRACE", shp->var_tree,0))
 625                 strmatch((char*)0,(char*)0);
 626         sfsync((Sfio_t*)sfstdin);
 627         sfsync((Sfio_t*)shp->outpool);
 628         sfsync((Sfio_t*)sfstdout);
 629         if(savxit&SH_EXITSIG)
 630                 sig = savxit&SH_EXITMASK;
 631         if(sig)
 632         {
 633                 /* generate fault termination code */
 634                 signal(sig,SIG_DFL);
 635                 sigrelease(sig);
 636                 kill(getpid(),sig);
 637                 pause();
 638         }
 639 #if SHOPT_KIA
 640         if(sh_isoption(SH_NOEXEC))
 641                 kiaclose((Lex_t*)shp->lex_context);
 642 #endif /* SHOPT_KIA */
 643         exit(savxit&SH_EXITMASK);
 644 }
 645