9 static void parsedirent(Dirent*, uchar*);
10 static void parseinode(Inode*, uchar*);
11 static void parsegroup(Group*, uchar*);
12 static void parsesuper(Super*, uchar*);
16 static int ext2sync(Fsys*);
17 static void ext2close(Fsys*);
18 static Block* ext2blockread(Fsys*, u64int);
20 static Nfs3Status ext2root(Fsys*, Nfs3Handle*);
21 static Nfs3Status ext2getattr(Fsys*, SunAuthUnix *au, Nfs3Handle*, Nfs3Attr*);
22 static Nfs3Status ext2lookup(Fsys*, SunAuthUnix *au, Nfs3Handle*, char*, Nfs3Handle*);
23 static Nfs3Status ext2readfile(Fsys*, SunAuthUnix *au, Nfs3Handle*, u32int, u64int, uchar**, u32int*, u1int*);
24 static Nfs3Status ext2readlink(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, char **link);
25 static Nfs3Status ext2readdir(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, u32int, u64int, uchar**, u32int*, u1int*);
26 static Nfs3Status ext2access(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, u32int want, u32int *got, Nfs3Attr *attr);
29 fsysopenext2(Disk *disk)
34 fsys = emalloc(sizeof(Fsys));
35 fs = emalloc(sizeof(Ext2));
40 fsys->_readblock = ext2blockread;
41 fsys->_sync = ext2sync;
42 fsys->_root = ext2root;
43 fsys->_getattr = ext2getattr;
44 fsys->_access = ext2access;
45 fsys->_lookup = ext2lookup;
46 fsys->_readfile = ext2readfile;
47 fsys->_readlink = ext2readlink;
48 fsys->_readdir = ext2readdir;
49 fsys->_close = ext2close;
51 if(ext2sync(fsys) < 0)
72 ext2group(Ext2 *fs, u32int i, Group *g)
80 addr = fs->groupaddr + i/fs->descperblock;
81 b = diskread(fs->disk, fs->blocksize, addr*fs->blocksize);
84 parsegroup(g, b->data+i%fs->descperblock*GroupSize);
90 ext2blockread(Fsys *fsys, u64int vbno)
95 u32int bno, boff, bitblock;
100 if(vbno >= fs->nblock)
107 if(bno < fs->firstblock)
108 return diskread(fs->disk, fs->blocksize, (u64int)bno*fs->blocksize);
110 if(bno < fs->firstblock)
113 bno -= fs->firstblock;
114 if(ext2group(fs, bno/fs->blockspergroup, &g) < 0){
116 fprint(2, "loading group: %r...");
121 fprint(2, "ext2 group %d: bitblock=%ud inodebitblock=%ud inodeaddr=%ud freeblocks=%ud freeinodes=%ud useddirs=%ud\n",
122 (int)(bno/fs->blockspergroup),
130 fprint(2, "group %d bitblock=%d...", bno/fs->blockspergroup, g.bitblock);
132 bitblock = g.bitblock;
133 bitpos = (u64int)bitblock*fs->blocksize;
135 if((bitb = diskread(fs->disk, fs->blocksize, bitpos)) == nil){
137 fprint(2, "loading bitblock: %r...");
141 boff = bno%fs->blockspergroup;
142 if((bits[boff>>3] & (1<<(boff&7))) == 0){
144 fprint(2, "block %d not allocated in group %d: bitblock %d/%lld bits[%d] = %#x\n",
145 boff, bno/fs->blockspergroup,
155 bno += fs->firstblock;
156 return diskread(fs->disk, fs->blocksize, (u64int)bno*fs->blocksize);
160 ext2datablock(Ext2 *fs, u32int bno, int size)
163 return ext2blockread(fs->fsys, bno);
167 ext2fileblock(Ext2 *fs, Inode *ino, u32int bno, int size)
175 if(bno < NDIRBLOCKS){
177 fprint(2, "fileblock %d -> %d...",
178 bno, ino->block[bno]);
179 return ext2datablock(fs, ino->block[bno], size);
182 ppb = fs->blocksize/4;
186 b = ext2datablock(fs, ino->block[INDBLOCK], fs->blocksize);
189 a = (u32int*)b->data;
192 return ext2datablock(fs, bno, size);
196 /* one double indirect */
198 b = ext2datablock(fs, ino->block[DINDBLOCK], fs->blocksize);
201 a = (u32int*)b->data;
205 b = ext2datablock(fs, pbno, fs->blocksize);
208 a = (u32int*)b->data;
211 return ext2datablock(fs, bno, size);
215 /* one triple indirect */
216 if(bno < ppb*ppb*ppb){
217 b = ext2datablock(fs, ino->block[TINDBLOCK], fs->blocksize);
220 a = (u32int*)b->data;
221 pbno = a[bno/(ppb*ppb)];
224 b = ext2datablock(fs, pbno, fs->blocksize);
227 a = (u32int*)b->data;
231 b = ext2datablock(fs, pbno, fs->blocksize);
234 a = (u32int*)b->data;
237 return ext2datablock(fs, bno, size);
240 fprint(2, "ext2fileblock %ud: too big\n", obno);
245 checksuper(Super *super)
247 if(super->magic != SUPERMAGIC){
248 werrstr("bad magic 0x%ux wanted 0x%ux", super->magic, SUPERMAGIC);
266 if((b = diskread(disk, SBSIZE, SBOFF)) == nil)
268 parsesuper(&super, b->data);
270 if(checksuper(&super) < 0)
272 fs->blocksize = MINBLOCKSIZE<<super.logblocksize;
273 fs->nblock = super.nblock;
274 fs->ngroup = (super.nblock+super.blockspergroup-1)
275 / super.blockspergroup;
276 fs->inospergroup = super.inospergroup;
277 fs->blockspergroup = super.blockspergroup;
278 if(super.revlevel >= 1)
279 fs->inosize = super.inosize;
282 fs->inosperblock = fs->blocksize / fs->inosize;
283 if(fs->blocksize == SBOFF)
287 fs->descperblock = fs->blocksize / GroupSize;
288 fs->firstblock = super.firstdatablock;
290 fsys->blocksize = fs->blocksize;
291 fsys->nblock = fs->nblock;
292 if(debug) fprint(2, "ext2 %d %d-byte blocks, first data block %d, %d groups of %d\n",
293 fs->nblock, fs->blocksize, fs->firstblock, fs->ngroup, fs->blockspergroup);
296 for(i=0; i<fs->ngroup; i++)
297 if(ext2group(fs, i, &g) >= 0)
298 fprint(2, "grp %d: bitblock=%d\n", i, g.bitblock);
304 mkhandle(Nfs3Handle *h, u64int ino)
316 return (p[0]<<24) | (p[1]<<16) | (p[2]<<8) | p[3];
320 handle2ino(Ext2 *fs, Nfs3Handle *h, u32int *pinum, Inode *ino)
330 return Nfs3ErrBadHandle;
331 inum = byte2u32(h->h);
334 i = (inum-1) / fs->inospergroup;
336 return Nfs3ErrBadHandle;
337 ioff = (inum-1) % fs->inospergroup;
338 if(ext2group(fs, i, &g) < 0)
340 addr = g.inodeaddr + ioff/fs->inosperblock;
341 if((b = diskread(fs->disk, fs->blocksize, (u64int)addr*fs->blocksize)) == nil)
343 parseinode(ino, b->data+fs->inosize*(ioff%fs->inosperblock));
349 ext2root(Fsys *fsys, Nfs3Handle *h)
352 mkhandle(h, ROOTINODE);
362 if((ino->mode&IFMT)==IFREG)
363 size |= (u64int)ino->diracl << 32;
368 ino2attr(Ext2 *fs, Inode *ino, u32int inum, Nfs3Attr *attr)
373 switch(ino->mode&IFMT){
375 attr->type = Nfs3FileFifo;
378 attr->type = Nfs3FileChar;
381 attr->type = Nfs3FileDir;
384 attr->type = Nfs3FileBlock;
387 attr->type = Nfs3FileReg;
390 attr->type = Nfs3FileSymlink;
393 attr->type = Nfs3FileSocket;
397 return Nfs3ErrBadHandle;
400 attr->mode = ino->mode&07777;
401 attr->nlink = ino->nlink;
402 attr->uid = ino->uid;
403 attr->gid = ino->gid;
404 attr->size = inosize(ino);
405 attr->used = (u64int)ino->nblock*fs->blocksize;
406 if(attr->type==Nfs3FileBlock || attr->type==Nfs3FileChar){
407 rdev = ino->block[0];
408 attr->major = (rdev>>8)&0xFF;
409 attr->minor = rdev & 0xFFFF00FF;
416 attr->atime.sec = ino->atime;
417 attr->atime.nsec = 0;
418 attr->mtime.sec = ino->mtime;
419 attr->mtime.nsec = 0;
420 attr->ctime.sec = ino->ctime;
421 attr->ctime.nsec = 0;
426 ingroup(SunAuthUnix *au, uint gid)
430 for(i=0; i<au->ng; i++)
437 inoperm(Inode *ino, SunAuthUnix *au, int need)
444 have = ino->mode&0777;
445 if(ino->uid == au->uid)
447 else if(ino->gid == au->gid || ingroup(au, ino->gid))
450 if((have&need) != need)
451 return Nfs3ErrNotOwner; /* really EPERM */
456 ext2getattr(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, Nfs3Attr *attr)
464 if((ok = handle2ino(fs, h, &inum, &ino)) != Nfs3Ok)
467 USED(au); /* anyone can getattr */
468 return ino2attr(fs, &ino, inum, attr);
472 ext2access(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, u32int want, u32int *got, Nfs3Attr *attr)
481 if((ok = handle2ino(fs, h, &inum, &ino)) != Nfs3Ok)
484 have = ino.mode&0777;
485 if(ino.uid == au->uid)
487 else if(ino.gid == au->gid || ingroup(au, ino.gid))
491 if((want&Nfs3AccessRead) && (have&AREAD))
492 *got |= Nfs3AccessRead;
493 if((want&Nfs3AccessLookup) && (ino.mode&IFMT)==IFDIR && (have&AEXEC))
494 *got |= Nfs3AccessLookup;
495 if((want&Nfs3AccessExecute) && (ino.mode&IFMT)!=IFDIR && (have&AEXEC))
496 *got |= Nfs3AccessExecute;
498 return ino2attr(fs, &ino, inum, attr);
502 ext2lookup(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, char *name, Nfs3Handle *nh)
515 if((ok = handle2ino(fs, h, nil, &ino)) != Nfs3Ok)
518 if((ino.mode&IFMT) != IFDIR)
519 return Nfs3ErrNotDir;
521 if((ok = inoperm(&ino, au, AEXEC)) != Nfs3Ok)
525 nblock = (ino.size+fs->blocksize-1) / fs->blocksize;
526 if(debug) fprint(2, "%d blocks in dir...", nblock);
527 for(i=0; i<nblock; i++){
529 want = ino.size % fs->blocksize;
531 want = fs->blocksize;
532 b = ext2fileblock(fs, &ino, i, want);
534 if(debug) fprint(2, "empty block...");
543 fprint(2, "reclen 0 at offset %d of %d\n", (int)(p-b->data), b->len);
549 fprint(2, "bad len %d at offset %d of %d\n", de.reclen, (int)(p-b->data), b->len);
554 if(4+2+2+de.namlen > de.reclen){
556 fprint(2, "bad namelen %d at offset %d of %d\n", de.namlen, (int)(p-b->data), b->len);
559 if(de.namlen == len && memcmp(de.name, name, len) == 0){
560 mkhandle(nh, de.ino);
571 ext2readdir(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, u32int count, u64int cookie, uchar **pdata, u32int *pcount, u1int *peof)
576 uchar *data, *dp, *dep, *p, *ep, *ndp;
586 if((ok = handle2ino(fs, h, nil, &ino)) != Nfs3Ok)
589 if((ino.mode&IFMT) != IFDIR)
590 return Nfs3ErrNotDir;
592 if((ok = inoperm(&ino, au, AREAD)) != Nfs3Ok)
595 if(debug) print("readdir cookie %#llux ino.size %#llux\n",
596 (u64int)cookie, (u64int)ino.size);
598 if(cookie >= ino.size){
611 nblock = (ino.size+fs->blocksize-1) / fs->blocksize;
612 i = cookie/fs->blocksize;
613 off = cookie%fs->blocksize;
615 for(; i<nblock && !outofspace; i++, off=0){
617 want = ino.size % fs->blocksize;
619 want = fs->blocksize;
620 b = ext2fileblock(fs, &ino, i, want);
625 memset(&e, 0, sizeof e);
629 if(debug) fprint(2, "reclen 0 at offset %d of %d\n", (int)(p-b->data), b->len);
634 if(debug) fprint(2, "reclen %d at offset %d of %d\n", de.reclen, (int)(p-b->data), b->len);
638 if(debug) fprint(2, "zero inode\n");
641 if(4+2+2+de.namlen > de.reclen){
642 if(debug) fprint(2, "bad namlen %d reclen %d at offset %d of %d\n", de.namlen, de.reclen, (int)(p-b->data), b->len);
645 if(debug) print("%.*s/%d ", de.namlen, de.name, (int)de.ino);
646 if(p-de.reclen - b->data < off)
650 e.namelen = de.namlen;
651 e.cookie = (u64int)i*fs->blocksize + (p - b->data);
652 if(debug) print("%.*s %#llux\n", utfnlen(e.name, e.namelen), e.name, (u64int)e.cookie);
653 if(nfs3entrypack(dp, dep, &ndp, &e) < 0){
661 if(i==nblock && !outofspace)
670 ext2readfile(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, u32int count,
671 u64int offset, uchar **pdata, u32int *pcount, u1int *peof)
676 int skip1, tot, want, fragcount;
682 if((ok = handle2ino(fs, h, nil, &ino)) != Nfs3Ok)
685 if((ok = inoperm(&ino, au, AREAD)) != Nfs3Ok)
688 size = inosize(&ino);
695 if(offset+count > size)
698 data = malloc(count);
701 memset(data, 0, count);
703 skip1 = offset%fs->blocksize;
708 * have to read multiple blocks if we get asked for a big read.
709 * Linux NFS client assumes that if you ask for 8k and only get 4k
710 * back, the remaining 4k is zeros.
712 for(tot=0; tot<want; tot+=fragcount){
713 b = ext2fileblock(fs, &ino, (offset+tot)/fs->blocksize, fs->blocksize);
714 fragcount = fs->blocksize;
717 if(tot+fragcount > want)
718 fragcount = want - tot;
720 memmove(data, b->data+skip1, fragcount-skip1);
722 memmove(data+tot-skip1, b->data, fragcount);
727 *peof = (offset+count == size);
734 ext2readlink(Fsys *fsys, SunAuthUnix *au, Nfs3Handle *h, char **link)
743 if((ok = handle2ino(fs, h, nil, &ino)) != Nfs3Ok)
745 if((ok = inoperm(&ino, au, AREAD)) != Nfs3Ok)
753 /* BUG: assumes symlink fits in one block */
754 b = ext2fileblock(fs, &ino, 0, len);
757 if(memchr(b->data, 0, len) != nil){
761 *link = malloc(len+1);
766 memmove(*link, b->data, len);
772 if(len > sizeof ino.block)
775 *link = malloc(len+1);
778 memmove(*link, ino.block, ino.size);
784 * Ext2 is always little-endian, even on big-endian machines.
790 return p[0] | (p[1]<<8) | (p[2]<<16) | (p[3]<<24);
796 return p[0] | (p[1]<<8);
806 parsedirent(Dirent *de, uchar *p)
809 de->reclen = l16(p+4);
810 de->namlen = l8(p+6);
812 de->name = (char*)p+8;
816 parseinode(Inode *ino, uchar *p)
822 ino->size = l32(p+4);
823 ino->atime = l32(p+8);
824 ino->ctime = l32(p+12);
825 ino->mtime = l32(p+16);
826 ino->dtime = l32(p+20);
827 ino->gid = l16(p+24);
828 ino->nlink = l16(p+26);
829 ino->nblock = l32(p+28);
830 ino->flags = l32(p+32);
832 for(i=0; i<NBLOCKS; i++)
833 ino->block[i] = l32(p+40+i*4);
834 ino->version = l32(p+100);
835 ino->fileacl = l32(p+104);
836 ino->diracl = l32(p+108);
837 ino->faddr = l32(p+112);
842 parsegroup(Group *g, uchar *p)
844 g->bitblock = l32(p);
845 g->inodebitblock = l32(p+4);
846 g->inodeaddr = l32(p+8);
847 g->freeblockscount = l16(p+12);
848 g->freeinodescount = l16(p+14);
849 g->useddirscount = l16(p+16);
851 /* 12 byte reserved */
855 parsesuper(Super *s, uchar *p)
858 s->nblock = l32(p+4);
859 s->rblockcount = l32(p+8);
860 s->freeblockcount = l32(p+12);
861 s->freeinodecount = l32(p+16);
862 s->firstdatablock = l32(p+20);
863 s->logblocksize = l32(p+24);
864 s->logfragsize = l32(p+28);
865 s->blockspergroup = l32(p+32);
866 s->fragpergroup = l32(p+36);
867 s->inospergroup = l32(p+40);
868 s->mtime = l32(p+44);
869 s->wtime = l32(p+48);
870 s->mntcount = l16(p+52);
871 s->maxmntcount = l16(p+54);
872 s->magic = l16(p+56);
873 s->state = l16(p+58);
874 s->errors = l16(p+60);
876 s->lastcheck = l32(p+64);
877 s->checkinterval = l32(p+68);
878 s->creatoros = l32(p+72);
879 s->revlevel = l32(p+76);
880 s->defresuid = l16(p+80);
881 s->defresgid = l16(p+82);
882 s->firstino = l32(p+84);
883 s->inosize = l32(p+88);
884 s->blockgroupnr = l16(p+60);
885 /* 932 byte reserved */