sys/src/cmd/tapefs/32vfs.c

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