Return to devdup.c CVS log

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

Annotation of lucent/sys/src/9/port/devdup.c, revision 1.1

1.1     ! root        1: #include       "u.h"
        !             2: #include       "../port/lib.h"
        !             3: #include       "mem.h"
        !             4: #include       "dat.h"
        !             5: #include       "fns.h"
        !             6: #include       "../port/error.h"
        !             7: 
        !             8: #include       "devtab.h"
        !             9: 
        !            10: 
        !            11: int
        !            12: dupgen(Chan *c, Dirtab *tab, int ntab, int s, Dir *dp)
        !            13: {
        !            14:        char buf[8];
        !            15:        Fgrp *fgrp = u->p->fgrp;
        !            16:        Chan *f;
        !            17:        static int perm[] = { 0400, 0200, 0600, 0 };
        !            18: 
        !            19:        USED(tab);
        !            20:        USED(ntab);
        !            21:        if(s >= NFD)
        !            22:                return -1;
        !            23:        if((f=fgrp->fd[s]) == 0)
        !            24:                return 0;
        !            25:        sprint(buf, "%ld", s);
        !            26:        devdir(c, (Qid){s, 0}, buf, 0, eve, perm[f->mode&3], dp);
        !            27:        return 1;
        !            28: }
        !            29: 
        !            30: void
        !            31: dupinit(void)
        !            32: {
        !            33: }
        !            34: 
        !            35: void
        !            36: dupreset(void)
        !            37: {
        !            38: }
        !            39: 
        !            40: Chan *
        !            41: dupattach(char *spec)
        !            42: {
        !            43:        return devattach('d', spec);
        !            44: }
        !            45: 
        !            46: Chan *
        !            47: dupclone(Chan *c, Chan *nc)
        !            48: {
        !            49:        return devclone(c, nc);
        !            50: }
        !            51: 
        !            52: int
        !            53: dupwalk(Chan *c, char *name)
        !            54: {
        !            55:        return devwalk(c, name, (Dirtab *)0, 0, dupgen);
        !            56: }
        !            57: 
        !            58: void
        !            59: dupstat(Chan *c, char *db)
        !            60: {
        !            61:        devstat(c, db, (Dirtab *)0, 0L, dupgen);
        !            62: }
        !            63: 
        !            64: Chan *
        !            65: dupopen(Chan *c, int omode)
        !            66: {
        !            67:        Chan *f;
        !            68: 
        !            69:        if(c->qid.path == CHDIR){
        !            70:                if(omode != 0)
        !            71:                        error(Eisdir);
        !            72:                c->mode = 0;
        !            73:                c->flag |= COPEN;
        !            74:                c->offset = 0;
        !            75:                return c;
        !            76:        }
        !            77:        fdtochan(c->qid.path, openmode(omode), 0, 0);   /* error check only */
        !            78:        f = u->p->fgrp->fd[c->qid.path];
        !            79:        close(c);
        !            80:        incref(f);
        !            81:        if(omode & OCEXEC)
        !            82:                f->flag |= CCEXEC;
        !            83:        return f;
        !            84: }
        !            85: 
        !            86: void
        !            87: dupcreate(Chan *c, char *name, int omode, ulong perm)
        !            88: {
        !            89:        USED(c, name, omode, perm);
        !            90:        error(Eperm);
        !            91: }
        !            92: 
        !            93: void
        !            94: dupremove(Chan *c)
        !            95: {
        !            96:        USED(c);
        !            97:        error(Eperm);
        !            98: }
        !            99: 
        !           100: void
        !           101: dupwstat(Chan *c, char *dp)
        !           102: {
        !           103:        USED(c);
        !           104:        USED(dp);
        !           105:        error(Egreg);
        !           106: }
        !           107: 
        !           108: void
        !           109: dupclose(Chan *c)
        !           110: {
        !           111:        USED(c);
        !           112: }
        !           113: 
        !           114: long
        !           115: dupread(Chan *c, void *va, long n, ulong offset)
        !           116: {
        !           117:        char *a = va;
        !           118: 
        !           119:        USED(offset);
        !           120:        if(c->qid.path != CHDIR)
        !           121:                panic("dupread");
        !           122:        return devdirread(c, a, n, (Dirtab *)0, 0L, dupgen);
        !           123: }
        !           124: 
        !           125: long
        !           126: dupwrite(Chan *c, void *va, long n, ulong offset)
        !           127: {
        !           128:        USED(c, va, n, offset);
        !           129:        panic("dupwrite");
        !           130:        return 0;               /* not reached */
        !           131: }

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