sys/src/cmd/tapefs/v10fs.c

   1 /*
   2  * 10th edition 4K file system
   3  */
   4 #include <u.h>
   5 #include <libc.h>
   6 #include <auth.h>
   7 #include <fcall.h>
   8 #include "tapefs.h"
   9
  10 /*
  11  * v10 disk inode
  12  */
  13 #define VNADDR  13
  14 #define VFMT    0160000
  15 #define VIFREG  0100000
  16 #define VIFDIR  0040000
  17 #define VIFCHR  0120000
  18 #define VIFBLK  0160000
  19 #define VMODE   0777
  20 #define VSUPERB 1
  21 #define VROOT           2       /* root inode */
  22 #define VNAMELEN        14
  23 #define BLSIZE  4096
  24 #define LINOPB  (BLSIZE/sizeof(struct v10dinode))
  25 #define LNINDIR (BLSIZE/sizeof(unsigned long))
  26
  27 struct v10dinode {
  28         unsigned char flags[2];
  29         unsigned char nlinks[2];
  30         unsigned char uid[2];
  31         unsigned char gid[2];
  32         unsigned char size[4];
  33         unsigned char addr[40];
  34         unsigned char atime[4];
  35         unsigned char mtime[4];
  36         unsigned char ctime[4];
  37 };
  38
  39 struct  v10dir {
  40         uchar   ino[2];
  41         char    name[VNAMELEN];
  42 };
  43
  44 int     tapefile;
  45 vlong   tapelen;
  46 Fileinf iget(int ino);
  47 long    bmap(Ram *r, long bno);
  48 void    getblk(Ram *r, long bno, char *buf);
  49
  50 void
  51 populate(char *name)
  52 {
  53         Fileinf f;
  54         Dir *d;
  55
  56         replete = 0;
  57         tapefile = open(name, OREAD);
  58         if (tapefile<0)
  59                 error("Can't open argument file");
  60         if ((d=dirfstat(tapefile)) == nil)
  61                 error("dirfstat");
  62         tapelen = d->length;
  63         free(d);
  64         f = iget(VROOT);
  65         ram->perm = f.mode;
  66         ram->mtime = f.mdate;
  67         ram->addr = f.addr;
  68         ram->data = f.data;
  69         ram->ndata = f.size;
  70 }
  71
  72 void
  73 popdir(Ram *r)
  74 {
  75         int i, ino;
  76         char *cp;
  77         struct v10dir *dp;
  78         Fileinf f;
  79         char name[VNAMELEN+1];
  80
  81         cp = 0;
  82         for (i=0; i<r->ndata; i+=sizeof(struct v10dir)) {
  83                 if (i%BLSIZE==0)
  84                         cp = doread(r, i, BLSIZE);
  85                 dp = (struct v10dir *)(cp+i%BLSIZE);
  86                 ino = g2byte(dp->ino);
  87                 if (strcmp(dp->name, ".")==0 || strcmp(dp->name, "..")==0)
  88                         continue;
  89                 if (ino==0)
  90                         continue;
  91                 f = iget(ino);
  92                 strncpy(name, dp->name, VNAMELEN);
  93                 name[VNAMELEN] = '\0';
  94                 f.name = name;
  95                 popfile(r, f);
  96         }
  97         r->replete = 1;
  98 }
  99
 100 void
 101 dotrunc(Ram *r)
 102 {
 103         USED(r);
 104 }
 105
 106 void
 107 docreate(Ram *r)
 108 {
 109         USED(r);
 110 }
 111
 112 char *
 113 doread(Ram *r, vlong off, long cnt)
 114 {
 115         static char buf[Maxbuf+BLSIZE];
 116         int bno, i;
 117
 118         bno = off/BLSIZE;
 119         off -= bno*BLSIZE;
 120         if (cnt>Maxbuf)
 121                 error("count too large");
 122         if (off)
 123                 cnt += off;
 124         i = 0;
 125         while (cnt>0) {
 126                 getblk(r, bno, &buf[i*BLSIZE]);
 127                 cnt -= BLSIZE;
 128                 bno++;
 129                 i++;
 130         }
 131         return buf+off;
 132 }
 133
 134 void
 135 dowrite(Ram *r, char *buf, long off, long cnt)
 136 {
 137         USED(r); USED(buf); USED(off); USED(cnt);
 138 }
 139
 140 int
 141 dopermw(Ram *r)
 142 {
 143         USED(r);
 144         return 0;
 145 }
 146
 147 /*
 148  * fetch an i-node
 149  * -- no sanity check for now
 150  * -- magic inode-to-disk-block stuff here
 151  */
 152
 153 Fileinf
 154 iget(int ino)
 155 {
 156         char buf[BLSIZE];
 157         struct v10dinode *dp;
 158         long flags, i;
 159         Fileinf f;
 160
 161         seek(tapefile, BLSIZE*((ino-1)/LINOPB + VSUPERB + 1), 0);
 162         if (read(tapefile, buf, BLSIZE) != BLSIZE)
 163                 error("Can't read inode");
 164         dp = ((struct v10dinode *)buf) + ((ino-1)%LINOPB);
 165         flags = g2byte(dp->flags);
 166         f.size = g4byte(dp->size);
 167         if ((flags&VFMT)==VIFCHR || (flags&VFMT)==VIFBLK)
 168                 f.size = 0;
 169         f.data = emalloc(VNADDR*sizeof(long));
 170         for (i = 0; i < VNADDR; i++)
 171                 ((long*)f.data)[i] = g3byte(dp->addr+3*i);
 172         f.mode = flags & VMODE;
 173         if ((flags&VFMT)==VIFDIR)
 174                 f.mode |= DMDIR;
 175         f.uid = g2byte(dp->uid);
 176         f.gid = g2byte(dp->gid);
 177         f.mdate = g4byte(dp->mtime);
 178         return f;
 179 }
 180
 181 void
 182 getblk(Ram *r, long bno, char *buf)
 183 {
 184         long dbno;
 185
 186         if ((dbno = bmap(r, bno)) == 0) {
 187                 memset(buf, 0, BLSIZE);
 188                 return;
 189         }
 190         if ((vlong)(dbno+1)*BLSIZE > tapelen) {
 191                 fprint(2, "read past end of tape: %lld\n", (vlong)dbno*BLSIZE);
 192                 memset(buf, 0, BLSIZE);
 193                 return;
 194         }
 195         seek(tapefile, dbno*BLSIZE, 0);
 196         if (readn(tapefile, buf, BLSIZE) != BLSIZE){
 197                 fprint(2, "readn at %lld: %r\n", (vlong)dbno*BLSIZE);
 198                 error("bad read");
 199         }
 200 }
 201
 202 /*
 203  * logical to physical block
 204  * only singly-indirect files for now
 205  */
 206
 207 long
 208 bmap(Ram *r, long bno)
 209 {
 210         unsigned char indbuf[LNINDIR][sizeof(long)];
 211
 212         if (bno < VNADDR-3)
 213                 return ((long*)r->data)[bno];
 214         if (bno < VNADDR*LNINDIR) {
 215                 seek(tapefile, ((long *)r->data)[(bno-(VNADDR-3))/LNINDIR+(VNADDR-3)]*BLSIZE, 0);
 216                 if (read(tapefile, (char *)indbuf, BLSIZE) != BLSIZE)
 217                         return 0;
 218                 return ((indbuf[(bno-(VNADDR-3))%LNINDIR][2]<<16) + (indbuf[(bno-(VNADDR-3))%LNINDIR][1]<<8)
 219                         + indbuf[(bno-(VNADDR-3))%LNINDIR][0]);
 220         }
 221         return 0;
 222 }