Return to start.c CVS log

Up to [Research Unix] / researchv8dc / netfs

Annotation of researchv8dc/netfs/start.c, revision 1.1

1.1     ! root        1: #include "fserv.h"
        !             2: #include "sys/neta.h"
        !             3: 
        !             4: char cmdbuf[256];
        !             5: int alive, rdcnt, wrcnt, dtime;
        !             6: int rdnum;
        !             7: struct senda y, nilrcv;
        !             8: int host;
        !             9: 
        !            10: work()
        !            11: {      int n;
        !            12:        struct senda *x;
        !            13:        dtime = children[myfd].dtime;
        !            14:        host = children[myfd].host;
        !            15:        silent = children[myfd].silent;
        !            16:        debugreset();
        !            17:        do {
        !            18:                /* would select be better? */
        !            19:                n = read(myfd, cmdbuf, sizeof(cmdbuf));
        !            20:                if(n < 0) {
        !            21:                        debug("read -1 on %d for %s", myfd, children[myfd].who);
        !            22:                        leave(2);
        !            23:                }
        !            24:                if(n != sizeof(struct senda)) {
        !            25:                        debug("read %d wanted %d for %s", n, sizeof(struct senda),
        !            26:                                children[myfd].who);
        !            27:                        leave(3);
        !            28:                }
        !            29:                rdnum++;
        !            30:                if(rdnum % 20 == 4)
        !            31:                        permredo();     /* every 10 minutes when idle */
        !            32:                x = (struct senda *)cmdbuf;
        !            33:                errno = 0;
        !            34:                y = nilrcv;
        !            35:                prcmd(x);
        !            36:                switch(x->cmd) {
        !            37:                default:
        !            38:                        debug("unk cmnd %d for %s", n, children[myfd].who);
        !            39:                        leave(4);
        !            40:                case NSTAT:
        !            41:                        dostat(x);
        !            42:                        break;
        !            43:                case NWRT:
        !            44:                        dowrite(x);
        !            45:                        break;
        !            46:                case NREAD:
        !            47:                        doread(x);
        !            48:                        break;
        !            49:                case NFREE:
        !            50:                        dofree(x);
        !            51:                        break;
        !            52:                case NTRUNC:
        !            53:                        dotrunc(x);
        !            54:                        break;
        !            55:                case NUPDAT:
        !            56:                        doupdat(x);
        !            57:                        break;
        !            58:                case NGET:
        !            59:                        doget(x);
        !            60:                        break;
        !            61:                case NNAMI:
        !            62:                        donami(x);
        !            63:                        break;
        !            64:                case NPUT:
        !            65:                        doput(x);
        !            66:                        break;
        !            67:                }
        !            68:        } while(alive > 0);
        !            69:        leave(0);
        !            70: }
        !            71: 
        !            72: leave(n)
        !            73: {      int i;
        !            74:        debug("leaving(%d)", n);
        !            75:        for(i = 0; i < dptr; i++) {
        !            76:                strcat(debugbuf[i], "\n");
        !            77:                write(dbgfd, debugbuf[i], strlen(debugbuf[i]));
        !            78:        }
        !            79:        exit(n);
        !            80: }
        !            81: 
        !            82: extern netf netftab[];
        !            83: extern int nnetf;
        !            84: dumpstate()
        !            85: {      struct senda *x = (struct senda *)cmdbuf;
        !            86:        netf *p;
        !            87:        int i;
        !            88:        debug("\tmesg: ver %d flags %d trannum %d\n\tuid %d gid %d dev 0x%x tag %d mode 0%o",
        !            89:        x->version, x->flags, x->trannum, x->uid, x->gid, x->dev, x->tag, x->mode);
        !            90:        debug("\t\tino %d count %d offset %d", x->ino, x->count, x->offset);
        !            91:        prcmd(x);
        !            92:        debug("\t%s: fl %d dtime %d dev 0x%x host %d",
        !            93:                children[myfd].who, children[myfd].flags, children[myfd].dtime,
        !            94:                children[myfd].dev, children[myfd].host);
        !            95:        for(i = 0; i < ndev; i++)
        !            96:                debug("\tdev: ours 0x%x his 0x%x", devtab[i].ours,
        !            97:                        devtab[i].his);
        !            98:        for(p = netftab, i = 0; i < nnetf; i++, p++) {
        !            99:                debug("\tnetf %d dev 0x%x ino %d how %d fd %d %s",
        !           100:                        p->tag, p->dev, p->ino, p->how, p->fd,
        !           101:                        p->name? p->name: "(null)");
        !           102:                debug("\tstat dev 0x%x ino %d mode 0%o nlink %d size %d",
        !           103:                        p->statb.st_dev, p->statb.st_ino, p->statb.st_mode,
        !           104:                        p->statb.st_nlink, p->statb.st_size);
        !           105:                debug("\t\tuid %d gid %d ctime %s\t\t", p->statb.st_uid,
        !           106:                        p->statb.st_gid, ctime(&p->statb.st_ctime));
        !           107:        }
        !           108: }

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