Return to f002541 CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/f002541, revision 1.1

1.1     ! root        1: /*
        !             2:  *  reboot stream module and device
        !             3:  */
        !             4: 
        !             5: #include       "u.h"
        !             6: #include       "../port/lib.h"
        !             7: #include       "mem.h"
        !             8: #include       "dat.h"
        !             9: #include       "fns.h"
        !            10: #include       "../port/error.h"
        !            11: 
        !            12: #include       "devtab.h"
        !            13: 
        !            14: enum{
        !            15:        Dirqid,
        !            16:        Deltatqid,
        !            17:        Zotqid,
        !            18: };
        !            19: 
        !            20: Dirtab Reboottab[]={
        !            21:        "deltat",       {Deltatqid, 0}, NUMSIZE,        0660,
        !            22:        "zot",          {Zotqid, 0},    0,              0220,
        !            23: };
        !            24: 
        !            25: #define NReboottab (sizeof(Reboottab)/sizeof(Dirtab))
        !            26: 
        !            27: /*
        !            28:  *  stream module definition
        !            29:  */
        !            30: static void rebootstopen(Queue*, Stream*);
        !            31: static void rebootiput(Queue*, Block*);
        !            32: static void rebootoput(Queue*, Block*);
        !            33: static Qinfo rebootinfo =
        !            34: {
        !            35:        rebootiput,
        !            36:        rebootoput,
        !            37:        rebootstopen,
        !            38:        0,
        !            39:        "reboot",
        !            40:        0
        !            41: };
        !            42: 
        !            43: static Rendez  timer;
        !            44: static int     deltat;
        !            45: 
        !            46: void
        !            47: rebootreset(void)
        !            48: {
        !            49:        newqinfo(&rebootinfo);
        !            50: }
        !            51: 
        !            52: void
        !            53: rebootinit(void)
        !            54: {
        !            55: }
        !            56: 
        !            57: Chan *
        !            58: rebootattach(char *spec)
        !            59: {
        !            60:        return devattach(L'↑', spec);
        !            61: }
        !            62: 
        !            63: Chan *
        !            64: rebootclone(Chan *c, Chan *nc)
        !            65: {
        !            66:        return devclone(c, nc);
        !            67: }
        !            68: 
        !            69: int
        !            70: rebootwalk(Chan *c, char *name)
        !            71: {
        !            72:        return devwalk(c, name, Reboottab, NReboottab, devgen);
        !            73: }
        !            74: 
        !            75: void
        !            76: rebootstat(Chan *c, char *db)
        !            77: {
        !            78:        devstat(c, db, Reboottab, NReboottab, devgen);
        !            79: }
        !            80: 
        !            81: Chan *
        !            82: rebootopen(Chan *c, int omode)
        !            83: {
        !            84:        return devopen(c, omode, Reboottab, NReboottab, devgen);
        !            85: }
        !            86: 
        !            87: void
        !            88: rebootcreate(Chan *c, char *name, int omode, ulong perm)
        !            89: {
        !            90:        USED(c, name, omode, perm);
        !            91:        error(Eperm);
        !            92: }
        !            93: 
        !            94: void
        !            95: rebootremove(Chan *c)
        !            96: {
        !            97:        USED(c);
        !            98:        error(Eperm);
        !            99: }
        !           100: 
        !           101: void
        !           102: rebootwstat(Chan *c, char *dp)
        !           103: {
        !           104:        USED(c, dp);
        !           105:        error(Eperm);
        !           106: }
        !           107: 
        !           108: void
        !           109: rebootclose(Chan *c)
        !           110: {
        !           111:        USED(c);
        !           112: }
        !           113: 
        !           114: long
        !           115: rebootread(Chan *c, void *a, long n, ulong offset)
        !           116: {
        !           117:        switch(c->qid.path & ~CHDIR){
        !           118:        case Dirqid:
        !           119:                return devdirread(c, a, n, Reboottab, NReboottab, devgen);
        !           120:        case Deltatqid:
        !           121:                return readnum(offset, a, n, deltat, NUMSIZE);
        !           122:        default:
        !           123:                n=0;
        !           124:                break;
        !           125:        }
        !           126:        return n;
        !           127: }
        !           128: 
        !           129: long
        !           130: rebootwrite(Chan *c, char *a, long n, ulong offset)
        !           131: {
        !           132:        char buf[NUMSIZE];
        !           133:        Block *bp;
        !           134: 
        !           135:        USED(offset);
        !           136:        switch(c->qid.path & ~CHDIR){
        !           137:        case Deltatqid:
        !           138:                if(n > NUMSIZE-1)
        !           139:                        n = NUMSIZE-1;
        !           140:                memmove(buf, a, n);
        !           141:                buf[n] = 0;
        !           142:                deltat = strtoul(buf, 0, 0);
        !           143:                break;
        !           144:        case Zotqid:
        !           145:                bp = allocb(0);
        !           146:                bp->type = M_HANGUP;
        !           147:                rebootiput(0, bp);
        !           148:                break;
        !           149:        default:
        !           150:                error(Ebadusefd);
        !           151:        }
        !           152:        return n;
        !           153: }
        !           154: 
        !           155: /*
        !           156:  *  stream routines
        !           157:  */
        !           158: 
        !           159: static void
        !           160: rebootstopen(Queue *q, Stream *s)
        !           161: {
        !           162:        USED(q, s);
        !           163:        if(strcmp(u->p->user, eve) != 0)
        !           164:                error(Eperm);
        !           165: }
        !           166: 
        !           167: void
        !           168: rebootoput(Queue *q, Block *bp)
        !           169: {
        !           170:        PUTNEXT(q, bp);
        !           171: }
        !           172: 
        !           173: static void
        !           174: rebootiput(Queue *q, Block *bp)
        !           175: {
        !           176:        if(bp->type == M_HANGUP){
        !           177:                tsleep(&timer, return0, 0, deltat);
        !           178:                exit(0);
        !           179:        }
        !           180:        PUTNEXT(q, bp);
        !           181: }

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