Return to rub.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / iutil

Annotation of 43BSD/ingres/source/iutil/rub.c, revision 1.1.1.1

1.1       root        1: # include      <useful.h>
                      2: # include      <signal.h>
                      3: # include      <sccs.h>
                      4: 
                      5: SCCSID(@(#)rub.c       8.1     12/31/84)
                      6: 
                      7: /*
                      8: **  RUB -- handle interrupt signals
                      9: **
                     10: **     This routine arranges to handle the interrupt signal
                     11: **     on behalf of the CM.  It sends SYNC blocks to everyone
                     12: **     who ought to get them, and arranges to ignore all
                     13: **     blocks except SYNC (and RESET) blocks from everyone
                     14: **     who will be sending one.  It also calls all of the
                     15: **     interrupt functions for all active modules.  It does
                     16: **     this after writing all of the sync blocks, so an
                     17: **     interrupt function can safely issue a query if it
                     18: **     wants.  It then does a non-local goto to the top of
                     19: **     the main loop.
                     20: **
                     21: **     Parameters:
                     22: **             none
                     23: **
                     24: **     Returns:
                     25: **             non-local
                     26: **
                     27: **     Side Effects:
                     28: **             Proc_name gets set to the CM name.
                     29: **             Interrupt functions for all active modules
                     30: **                     are invoked.
                     31: **             The 'Syncs' vector is updated appropriately.
                     32: **             SYNC blocks are sent to all adjacent processes.
                     33: **
                     34: **     Called By:
                     35: **             System, via 'signal' (section 2).
                     36: **
                     37: **     Trace Flags:
                     38: **             none
                     39: */
                     40: 
                     41: int    RubLevel;       /* depth of ruboff calls, -1 if off */
                     42: char   *RubWhy;        /* why are interrupts disabled */
                     43: int    RubGot;         /* set if we have an unprocessed interrupt */
                     44: 
                     45: rubcatch()
                     46: {
                     47:        /* ignore interrupts while we are processing */
                     48:        signal(SIGINT, SIG_IGN);
                     49: 
                     50:        /* find out if we are allowing interrupts */
                     51:        if (RubLevel < 0)
                     52:                syserr("bad SIGINT");
                     53:        else if (RubLevel > 0)
                     54:        {
                     55:                /* save interrupt for later processing */
                     56:                RubGot++;
                     57:                if (RubWhy != NULL)
                     58:                        printf("Rubout locked out (%s in progress)\n", RubWhy);
                     59:        }
                     60:        else
                     61:        {
                     62:                /* do other processing (either from ctlmod or standalones) */
                     63:                rubproc();
                     64:                syserr("rubcatch: rubproc");
                     65:        }
                     66: }
                     67: /*
                     68: **  TURN RUBOUTS OFF
                     69: **
                     70: **     Further rubouts will be caught by rubsave.
                     71: **     The parameter should be the name of the processor which
                     72: **     insists that rubouts do not occur.
                     73: */
                     74: 
                     75: ruboff(why)
                     76: char   *why;
                     77: {
                     78:        /* check to see if this should be ignored */
                     79:        if (RubLevel < 0 || RubLevel++ > 0)
                     80:                return;
                     81: 
                     82:        /* set up to ignore interrupts */
                     83:        RubGot = 0;
                     84:        RubWhy = why;
                     85: }
                     86: /*
                     87: **  TURN RUBOUTS BACK ON
                     88: **
                     89: **     Rubout processing is restored to the norm (calling rubcatch).
                     90: **     If any rubouts have occured while disabled, they are processed
                     91: **     now.
                     92: */
                     93: 
                     94: rubon()
                     95: {
                     96:        /* check to see if we should leave as-is */
                     97:        if (RubLevel < 0 || --RubLevel > 0)
                     98:                return;
                     99: 
                    100:        /* process any old interrupts */
                    101:        if (RubGot > 0)
                    102:                rubcatch();
                    103: 
                    104:        /* reset state */
                    105:        RubWhy = NULL;
                    106: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.