Return to devroot.c CVS log

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

Annotation of lucent/sys/src/9/port/devroot.c, revision 1.1.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: #include       "devtab.h"
                      8: 
                      9: enum{
                     10:        Qdir=   0,
                     11:        Qbin,
                     12:        Qdev,
                     13:        Qenv,
                     14:        Qproc,
                     15:        Qnet,
                     16:        Qboot,          /* readable files */
                     17: 
                     18:        Nfiles=13,      /* max root files */    
                     19: };
                     20: 
                     21: extern ulong   bootlen;
                     22: extern uchar   bootcode[];
                     23: 
                     24: Dirtab rootdir[Nfiles]={
                     25:                "bin",          {Qbin|CHDIR},   0,      0777,
                     26:                "dev",          {Qdev|CHDIR},   0,      0777,
                     27:                "env",          {Qenv|CHDIR},   0,      0777,
                     28:                "proc",         {Qproc|CHDIR},  0,      0777,
                     29:                "net",          {Qnet|CHDIR},   0,      0777,
                     30: };
                     31: 
                     32: static uchar   *rootdata[Nfiles];
                     33: static int     nroot = Qboot - 1;
                     34: 
                     35: /*
                     36:  *  add a root file
                     37:  */
                     38: void
                     39: addrootfile(char *name, uchar *contents, ulong len)
                     40: {
                     41:        Dirtab *d;
                     42:        
                     43: 
                     44:        if(nroot >= Nfiles)
                     45:                panic("too many root files");
                     46:        rootdata[nroot] = contents;
                     47:        d = &rootdir[nroot];
                     48:        strcpy(d->name, name);
                     49:        d->length = len;
                     50:        d->perm = 0555;
                     51:        d->qid.path = nroot+1;
                     52:        nroot++;
                     53: }
                     54: 
                     55: void
                     56: rootreset(void)
                     57: {
                     58:        addrootfile("boot", bootcode, bootlen); /* always have a boot file */
                     59: }
                     60: 
                     61: void
                     62: rootinit(void)
                     63: {
                     64: }
                     65: 
                     66: Chan*
                     67: rootattach(char *spec)
                     68: {
                     69:        return devattach('/', spec);
                     70: }
                     71: 
                     72: Chan*
                     73: rootclone(Chan *c, Chan *nc)
                     74: {
                     75:        return devclone(c, nc);
                     76: }
                     77: 
                     78: int     
                     79: rootwalk(Chan *c, char *name)
                     80: {
                     81:        if(strcmp(name, "..") == 0) {
                     82:                c->qid.path = Qdir|CHDIR;
                     83:                return 1;
                     84:        }
                     85:        if((c->qid.path & ~CHDIR) != Qdir)
                     86:                return 0;
                     87:        return devwalk(c, name, rootdir, nroot, devgen);
                     88: }
                     89: 
                     90: void    
                     91: rootstat(Chan *c, char *dp)
                     92: {
                     93:        devstat(c, dp, rootdir, nroot, devgen);
                     94: }
                     95: 
                     96: Chan*
                     97: rootopen(Chan *c, int omode)
                     98: {
                     99:        return devopen(c, omode, rootdir, nroot, devgen);
                    100: }
                    101: 
                    102: void    
                    103: rootcreate(Chan *c, char *name, int omode, ulong perm)
                    104: {
                    105:        USED(c, name, omode, perm);
                    106:        error(Eperm);
                    107: }
                    108: 
                    109: /*
                    110:  * sysremove() knows this is a nop
                    111:  */
                    112: void    
                    113: rootclose(Chan *c)
                    114: {
                    115:        USED(c);
                    116: }
                    117: 
                    118: long    
                    119: rootread(Chan *c, void *buf, long n, ulong offset)
                    120: {
                    121:        ulong t;
                    122:        Dirtab *d;
                    123:        uchar *data;
                    124: 
                    125:        t = c->qid.path & ~CHDIR;
                    126:        if(t == Qdir)
                    127:                return devdirread(c, buf, n, rootdir, nroot, devgen);
                    128:        if(t < Qboot)
                    129:                return 0;
                    130: 
                    131:        d = &rootdir[t-1];
                    132:        data = rootdata[t-1];
                    133:        if(offset >= d->length)
                    134:                return 0;
                    135:        if(offset+n > d->length)
                    136:                n = d->length - offset;
                    137:        memmove(buf, data+offset, n);
                    138:        return n;
                    139: }
                    140: 
                    141: long    
                    142: rootwrite(Chan *c, void *buf, long n, ulong offset)
                    143: {
                    144:        USED(c, buf, n, offset);
                    145:        error(Egreg);
                    146:        return 0;       /* not reached */
                    147: }
                    148: 
                    149: void    
                    150: rootremove(Chan *c)
                    151: {
                    152:        USED(c);
                    153:        error(Eperm);
                    154: }
                    155: 
                    156: void    
                    157: rootwstat(Chan *c, char *dp)
                    158: {
                    159:        USED(c, dp);
                    160:        error(Eperm);
                    161: }

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