Return to dumpld.c CVS log

Up to [Research Unix] / researchv8dc / sys / dev

Annotation of researchv8dc/sys/dev/dumpld.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  *             D U M P  L D
                      3:  *
                      4:  * This line discipline is used for debugging.
                      5:  * It passes on everything given to it, in the same order,
                      6:  * but at the same time it creates a log of the message type
                      7:  * and contents for each message.
                      8:  *
                      9:  *
                     10:  * Written by Kurt Gollhardt  (Nirvonics, Inc.)
                     11:  * Last update Sat Mar 30 15:17:01 1985
                     12:  *
                     13:  */
                     14: 
                     15: #include "../h/param.h"
                     16: #include "../h/systm.h"
                     17: #include "../h/stream.h"
                     18: #include "../h/ioctl.h"
                     19: #include "../h/ttyld.h"
                     20: #include "../h/conf.h"
                     21: #include "../h/dumpl.h"
                     22: 
                     23: #include "dumpld.h"
                     24: #if NDUMPLD > 0
                     25: 
                     26: int  dumpput(), dumpopen(), dumpclose();
                     27: 
                     28: static struct qinit rinit = { dumpput, NULL, dumpopen, dumpclose, 300, 0 },
                     29:                     winit = { dumpput, NULL, dumpopen, dumpclose, 300, 200 };
                     30: struct streamtab dumpinfo = { &rinit, &winit };
                     31: 
                     32: #define DUMPSIZE    4096
                     33: 
                     34: static char    dumpbuf[NDUMPLD*2][DUMPSIZE];
                     35: struct dumpld  dumpld[NDUMPLD*2];
                     36: struct dumpinf dumpinf[NDUMPLD*2];
                     37: 
                     38: int ndumpbuf = NDUMPLD * 2;
                     39: int dumpver = 1;
                     40: 
                     41: 
                     42: dumpopen(q, dev)
                     43:      struct queue   *q;
                     44:      dev_t          dev;
                     45: {
                     46:      register struct dumpld *di;
                     47:      register struct dumpinf *dinf;
                     48: 
                     49:      if (q->ptr)
                     50:           return 1;
                     51:      for (di = dumpld; di < &dumpld[NDUMPLD*2]; di += 2)
                     52:           if (di->base == (char *)0)
                     53:               break;
                     54:      if (di == &dumpld[NDUMPLD*2])
                     55:           return 0;
                     56: 
                     57:      dinf = &dumpinf[di - dumpld];
                     58: 
                     59:      di->fillp = di->base = dumpbuf[di - dumpld];
                     60:      di->size = DUMPSIZE;
                     61:      q->ptr = (caddr_t)di;
                     62:      ++di;
                     63:      di->fillp = di->base = dumpbuf[di - dumpld];
                     64:      di->size = DUMPSIZE;
                     65: 
                     66:      dinf->dev = dev;
                     67:      (++dinf)->dev = dev;
                     68: 
                     69:      WR(q)->ptr = (caddr_t)di;
                     70:      dumpupdate(q);
                     71:      dumpupdate(WR(q));
                     72: 
                     73:      return 1;
                     74: }
                     75: 
                     76: 
                     77: dumpclose(q)
                     78:      struct queue   *q;
                     79: {
                     80:      register struct dumpld *di = (struct dumpld *)q->ptr;
                     81: 
                     82:      dumpupdate(q);
                     83:      dumpupdate(WR(q));
                     84: 
                     85:      di->base = (char *)0;
                     86:      (di+1)->base = (char *)0;
                     87:      q->ptr = (caddr_t)0;
                     88: }
                     89: 
                     90: 
                     91: dumpput(q, bp)
                     92:      struct queue   *q;
                     93:      register struct block    *bp;
                     94: {
                     95:      register struct dumpld *di = (struct dumpld *)q->ptr;
                     96:      register u_char     *p;
                     97:      struct dumpheader  hd;
                     98:      int  ps = spl6();
                     99: 
                    100:      hd.type = bp->type;
                    101:      hd.class = bp->class;
                    102:      hd.count = bp->wptr - bp->rptr;
                    103:      for (p = (u_char *)&hd; p < (u_char *)(&hd + 1);)
                    104:          dumpchr(di, *p++);
                    105:      for (p = bp->rptr; p < bp->wptr;)
                    106:          dumpchr(di, *p++);
                    107: 
                    108:      (*q->next->qinfo->putp) (q->next, bp);
                    109:      dumpupdate(q);
                    110: 
                    111:      splx(ps);
                    112: }
                    113: 
                    114: 
                    115: dumpchr(di, c)
                    116:      register struct dumpld *di;
                    117:      char c;
                    118: {
                    119:      *(di->fillp)++ = c;
                    120:      if (di->fillp >= di->base + di->size)
                    121:           di->fillp = di->base;
                    122: }
                    123: 
                    124: 
                    125: dumpupdate(q)
                    126:      register struct queue    *q;
                    127: {
                    128:      register struct queue    *qnext = q->next;
                    129: 
                    130:      q->flag |= qnext->flag & (QFULL|QWANTR|QBIGB) | backq(q)->flag & QDELIM;
                    131:      qnext->flag |= q->flag & QWANTW;
                    132:      q->count = qnext->count;
                    133: }

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