Return to dmesg.c CVS log

Up to [Research Unix] / researchv10no / cmd

Annotation of researchv10no/cmd/dmesg.c, revision 1.1

1.1     ! root        1: /*
        !             2:  *     Suck up system messages
        !             3:  *     dmesg
        !             4:  *             print current buffer
        !             5:  *     dmesg -
        !             6:  *             print and update incremental history
        !             7:  */
        !             8: 
        !             9: #include <stdio.h>
        !            10: #include <libc.h>
        !            11: #include <sys/param.h>
        !            12: #include <nlist.h>
        !            13: #include <signal.h>
        !            14: #include <sys/msgbuf.h>
        !            15: 
        !            16: long   msgptr;
        !            17: struct msgbuf msgbuf;
        !            18: char   *msgbufp;
        !            19: int    sflg;
        !            20: int    wflg;
        !            21: 
        !            22: struct msgbuf omesg;
        !            23: struct nlist nl[2] = {
        !            24:        { "_msgbuf" },
        !            25:        { 0 }
        !            26: };
        !            27: 
        !            28: #define        BUFFER  "/usr/adm/msgbuf"
        !            29: 
        !            30: main(argc, argv)
        !            31: char **argv;
        !            32: {
        !            33:        int mem;
        !            34:        int timeout();
        !            35: 
        !            36:        signal(SIGALRM, timeout);
        !            37:        alarm(60);
        !            38:        if (argc>1 && argv[1][0] == '-') {
        !            39:                sflg++;
        !            40:                switch (argv[1][1]) {
        !            41:                default:                /* ugh */
        !            42:                        wflg++;
        !            43:                        break;
        !            44: 
        !            45:                case 'i':
        !            46:                        break;
        !            47:                }
        !            48:                argc--;
        !            49:                argv++;
        !            50:        }
        !            51:        if (sflg)
        !            52:                openbuf();
        !            53:        sflg = 0;
        !            54:        timeout("can't read namelist\n");
        !            55:        nlist(argc>2? argv[2]:"/unix", nl);
        !            56:        if (nl[0].n_type==0)
        !            57:                done("No namelist\n");
        !            58:        if ((mem = open((argc>1? argv[1]: "/dev/kmem"), 0)) < 0)
        !            59:                done("No /dev/kmem\n");
        !            60:        lseek(mem, (long)nl[0].n_value, 0);
        !            61:        read(mem, &msgptr, sizeof(msgptr));
        !            62:        lseek(mem, msgptr, 0);
        !            63:        read(mem, &msgbuf, sizeof (msgbuf));
        !            64:        if (msgbuf.msg_magic != MSG_MAGIC)
        !            65:                done("Magic number wrong (namelist mismatch?)\n");
        !            66:        if (bufdiff(&omesg, &msgbuf) == 0)
        !            67:                exit(0);
        !            68:        prdiff(&omesg, &msgbuf);
        !            69:        done((char *)NULL);
        !            70: }
        !            71: 
        !            72: bufdiff(om, nm)
        !            73: register struct msgbuf *om, *nm;
        !            74: {
        !            75: 
        !            76:        if (om->msg_bufx != nm->msg_bufx)
        !            77:                return (1);
        !            78:        return (memcmp(om->msg_bufc, nm->msg_bufc, MSG_BSIZE));
        !            79: }
        !            80: 
        !            81: prdiff(om, nm)
        !            82: register struct msgbuf *om, *nm;
        !            83: {
        !            84:        register int ox, nx;
        !            85:        register int c;
        !            86: 
        !            87:        if ((ox = om->msg_bufx) < 0 || ox >= MSG_BSIZE)
        !            88:                ox = 0;
        !            89:        if ((nx = nm->msg_bufx) < 0 || nx >= MSG_BSIZE)
        !            90:                nx = 0;
        !            91:        pdate();
        !            92:        /*
        !            93:         * did we lose something?
        !            94:         */
        !            95:        if (ox < nx) {
        !            96:                if (memcmp(&om->msg_bufc[0], &nm->msg_bufc[0], ox)
        !            97:                ||  memcmp(&om->msg_bufc[nx], &nm->msg_bufc[nx], MSG_BSIZE - nx)) {
        !            98:                        ox = nx;
        !            99:                        printf("...\n");
        !           100:                }
        !           101:        } else if (ox > nx) {
        !           102:                if (memcmp(&om->msg_bufc[ox], &nm->msg_bufc[ox], nx - ox)) {
        !           103:                        ox = nx;
        !           104:                        printf("...\n");
        !           105:                }
        !           106:        }
        !           107:        /*
        !           108:         * else ox == nx; something might be lost, but assume not
        !           109:         * now print the new part: from ox to nx-1
        !           110:         */
        !           111:        do {
        !           112:                c = nm->msg_bufc[ox++];
        !           113:                if ((c & 0200) == 0 && c != 0)  /* sanity */
        !           114:                        putchar(c);
        !           115:                if (ox >= MSG_BSIZE)
        !           116:                        ox = 0;
        !           117:        } while (ox != nx);
        !           118: }
        !           119: 
        !           120: done(s)
        !           121: char *s;
        !           122: {
        !           123: 
        !           124:        if (s && s!=(char *)omesg.msg_magic && sflg==0) {
        !           125:                pdate();
        !           126:                printf(s);
        !           127:        }
        !           128:        if (wflg) {
        !           129:                wflg = 0;
        !           130:                writebuf();
        !           131:        }
        !           132:        exit(s!=NULL);
        !           133: }
        !           134: 
        !           135: openbuf()
        !           136: {
        !           137:        int f;
        !           138: 
        !           139:        timeout("can't read buffer file\n");
        !           140:        if ((f = open(BUFFER, 0)) < 0)
        !           141:                return;
        !           142:        if (read(f, (char *)&omesg, sizeof(omesg)) != sizeof(omesg)
        !           143:        ||  omesg.msg_magic != MSG_MAGIC)
        !           144:                memset((char *)&omesg, sizeof(omesg), 0);
        !           145:        close(f);
        !           146: }
        !           147: 
        !           148: writebuf()
        !           149: {
        !           150:        int f;
        !           151: 
        !           152:        timeout("can't write buffer file\n");
        !           153:        if ((f = open(BUFFER, 1)) < 0)
        !           154:                done("can't open buffer\n");
        !           155:        if (write(f, (char *)&msgbuf, sizeof(msgbuf)) != sizeof(msgbuf))
        !           156:                done("error writing buffer\n");
        !           157:        close(f);
        !           158: }
        !           159: 
        !           160: pdate()
        !           161: {
        !           162:        extern char *ctime();
        !           163:        static firstime;
        !           164:        time_t tbuf;
        !           165: 
        !           166:        if (firstime==0) {
        !           167:                firstime++;
        !           168:                time(&tbuf);
        !           169:                printf("\n%.12s\n", ctime(&tbuf)+4);
        !           170:        }
        !           171: }
        !           172: 
        !           173: char *terr;
        !           174: 
        !           175: timeout(s)
        !           176: char *s;
        !           177: {
        !           178:        extern ttrap();
        !           179: 
        !           180:        terr = s;
        !           181:        signal(SIGALRM, ttrap);
        !           182:        alarm(60);
        !           183: }
        !           184: 
        !           185: ttrap()
        !           186: {
        !           187:        char buf[100];
        !           188: 
        !           189:        sprintf(buf, "timeout: %s", terr);
        !           190:        done(buf);
        !           191: }

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