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     ! 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.