Return to errlog.c CVS log

Up to [Research Unix] / researchv10no / sys / io

Annotation of researchv10no/sys/io/errlog.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * error logging
        !             3:  *
        !             4:  * other parts of the system may call logerr to record an error
        !             5:  * reading the device recovers the error records
        !             6:  */
        !             7: 
        !             8: #include "sys/param.h"
        !             9: #include "sys/conf.h"
        !            10: #include "sys/systm.h"         /* just for time */
        !            11: #include "sys/user.h"
        !            12: #include "sys/buf.h"
        !            13: #include "sys/errlog.h"
        !            14: 
        !            15: /*
        !            16:  * hackish use of overlays:
        !            17:  * if this device isn't configured,
        !            18:  * errcnt will be zero, errlog will be 1 item long (so it won't be undefined)
        !            19:  * if the device is configured,
        !            20:  * errcnt is the number of errlog buffers
        !            21:  */
        !            22: 
        !            23: int errcnt;
        !            24: struct errlog errlog[1];       /* 1 or more */
        !            25: 
        !            26: static int errlost;
        !            27: static char erptr, ewptr;
        !            28: 
        !            29: int erropen(), errread(), errwrite();
        !            30: struct cdevsw errcdev = cdinit(erropen, nodev, errread, errwrite, nodev);
        !            31: 
        !            32: #define        PERROR  (PUSER-1)
        !            33: 
        !            34: erropen(dev, flag)
        !            35: dev_t dev;
        !            36: int flag;
        !            37: {
        !            38: 
        !            39:        if (errcnt == 0)
        !            40:                u.u_error = ENXIO;
        !            41: }
        !            42: 
        !            43: errread(dev)
        !            44: dev_t dev;
        !            45: {
        !            46:        register int s;
        !            47: 
        !            48:        if (u.u_count < sizeof(errlog)) {
        !            49:                u.u_error = EINVAL;
        !            50:                return;
        !            51:        }
        !            52:        s = spl7();
        !            53:        while (erptr == ewptr)
        !            54:                sleep((caddr_t)errlog, PERROR);
        !            55:        splx(s);
        !            56:        s = errlog[erptr].e_hdr.e_len + sizeof(struct errhdr);
        !            57:        iomove((caddr_t)&errlog[erptr], s, B_READ);
        !            58:        if (++erptr >= errcnt)
        !            59:                erptr = 0;
        !            60: }
        !            61: 
        !            62: /*
        !            63:  * mostly for debugging
        !            64:  */
        !            65: 
        !            66: errwrite(dev)
        !            67: dev_t dev;
        !            68: {
        !            69:        char b[MAXEDATA+20];
        !            70:        register int len;
        !            71:        register char *p;
        !            72: 
        !            73:        if ((len = u.u_count) > sizeof(b)) {
        !            74:                u.u_error = EINVAL;
        !            75:                return;
        !            76:        }
        !            77:        iomove(b, len, B_WRITE);
        !            78:        if (u.u_error)
        !            79:                return;
        !            80:        p = b;
        !            81:        while (--len >= 0)
        !            82:                if (*p++ == '\n')
        !            83:                        break;
        !            84:        p[-1] = 0;
        !            85:        if (len < 0)
        !            86:                len = 0;
        !            87:        logerr(b, 0, p, len, 0);
        !            88: }
        !            89: 
        !            90: /*
        !            91:  * here to log an error:
        !            92:  * dev is the name of the device or circumstance
        !            93:  * unit is a unit number, e.g. which disk number broke
        !            94:  * data is the stuff to be logged; there are len bytes
        !            95:  * data should be something bcopy can copy (maybe not device registers)
        !            96:  * `hard' is nonzero if this was a hard error
        !            97:  */
        !            98: 
        !            99: logerr(dev, unit, data, len, hard)
        !           100: char *dev;
        !           101: int unit;
        !           102: char *data;
        !           103: int len;
        !           104: int hard;
        !           105: {
        !           106:        register struct errlog *ep;
        !           107:        register int s, i;
        !           108:        register char *p;
        !           109: 
        !           110:        s = spl7();
        !           111:        if ((i = ewptr + 1) >= errcnt)
        !           112:                i = 0;
        !           113:        if (i == erptr) {               /* buffer full */
        !           114:                splx(s);
        !           115:                errlost++;
        !           116:                return;
        !           117:        }
        !           118:        ep = &errlog[ewptr];
        !           119:        ewptr = i;
        !           120:        splx(s);
        !           121:        ep->e_hdr.e_1magic = E_1MAGIC;
        !           122:        ep->e_hdr.e_2magic = E_2MAGIC;
        !           123:        len = min(len, MAXEDATA);
        !           124:        ep->e_hdr.e_len = len;
        !           125:        if (hard)
        !           126:                ep->e_hdr.e_len |= E_HARD;
        !           127:        ep->e_hdr.e_unit = unit;
        !           128:        ep->e_hdr.e_time = time;
        !           129:        p = dev;
        !           130:        while (*p++)            /* should be strlen */
        !           131:                ;
        !           132:        bcopy(dev, ep->e_hdr.e_dev, min(p - dev, sizeof(ep->e_hdr.e_dev)));
        !           133:        if (len)
        !           134:                bcopy(data, ep->e_data, len);
        !           135:        wakeup((caddr_t)errlog);
        !           136: }

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