tventi updates - plan9port - [fork] Plan 9 from user space
(HTM) git clone git://src.adamsgaard.dk/plan9port
(DIR) Log
(DIR) Files
(DIR) Refs
(DIR) README
(DIR) LICENSE
---
(DIR) commit 23fb2edb22703ad10aae02295e654b3de68617c5
(DIR) parent 7ba8aa0c7083415ad69c2f8e591425f3c6ebf952
(HTM) Author: rsc <devnull@localhost>
Date: Sun, 24 Jul 2005 20:15:44 +0000
venti updates
Diffstat:
M include/venti.h | 1 +
M src/cmd/vac/file.c | 29 ++++++++++++++++++++++++++---
M src/cmd/vac/fs.c | 8 ++++++--
M src/cmd/vac/mkfile | 2 +-
M src/cmd/vac/vac.c | 3 +--
M src/cmd/vac/vacfs.c | 11 +++++++----
M src/cmd/venti/read.c | 7 +++----
A src/cmd/venti/root.c | 72 +++++++++++++++++++++++++++++++
M src/cmd/venti/srv/buildindex.c | 1 +
M src/cmd/venti/srv/wrarena.c | 6 +++---
M src/libventi/cache.c | 10 ++++++----
M src/libventi/entry.c | 12 +++++++++++-
M src/libventi/file.c | 50 +++++++++++++++++--------------
13 files changed, 165 insertions(+), 47 deletions(-)
---
(DIR) diff --git a/include/venti.h b/include/venti.h
t@@ -463,6 +463,7 @@ VtFile *vtfileopenroot(VtCache*, VtEntry*);
VtFile *vtfilecreateroot(VtCache*, int psize, int dsize, int type);
VtFile *vtfileopen(VtFile*, u32int, int);
VtFile *vtfilecreate(VtFile*, int psize, int dsize, int dir);
+VtFile *_vtfilecreate(VtFile*, int offset, int psize, int dsize, int dir);
VtBlock *vtfileblock(VtFile*, u32int, int mode);
long vtfileread(VtFile*, void*, long, vlong);
long vtfilewrite(VtFile*, void*, long, vlong);
(DIR) diff --git a/src/cmd/vac/file.c b/src/cmd/vac/file.c
t@@ -4,6 +4,8 @@
#include "fns.h"
#include "error.h"
+#define debug 0
+
/*
* locking order is upwards. A thread can hold the lock for a VacFile
* and then acquire the lock of its parent
t@@ -122,12 +124,16 @@ Err:
VacFile*
_vacfileroot(VacFs *fs, VtFile *r)
{
+ int redirected;
+ char err[ERRMAX];
VtBlock *b;
VtFile *r0, *r1, *r2;
MetaBlock mb;
MetaEntry me;
VacFile *root, *mr;
+ redirected = 0;
+Top:
b = nil;
root = nil;
mr = nil;
t@@ -137,14 +143,31 @@ _vacfileroot(VacFs *fs, VtFile *r)
if(vtfilelock(r, -1) < 0)
return nil;
r0 = vtfileopen(r, 0, fs->mode);
+ if(debug)
+ fprint(2, "r0 %p\n", r0);
if(r0 == nil)
goto Err;
+ r2 = vtfileopen(r, 2, fs->mode);
+ if(debug)
+ fprint(2, "r2 %p\n", r2);
+ if(r2 == nil){
+ /*
+ * some vac files (e.g., from fossil)
+ * have an extra layer of indirection.
+ */
+ rerrstr(err, sizeof err);
+ if(!redirected && strstr(err, "not active")){
+ vtfileunlock(r);
+ r = r0;
+ goto Top;
+ }
+ goto Err;
+ }
r1 = vtfileopen(r, 1, fs->mode);
+ if(debug)
+ fprint(2, "r1 %p\n", r1);
if(r1 == nil)
goto Err;
- r2 = vtfileopen(r, 2, fs->mode);
- if(r2 == nil)
- goto Err;
mr = filealloc(fs);
mr->msource = r2;
(DIR) diff --git a/src/cmd/vac/fs.c b/src/cmd/vac/fs.c
t@@ -3,6 +3,8 @@
#include "dat.h"
#include "fns.h"
+#define debug 0
+
static char EBadVacFormat[] = "bad format for vac file";
static VacFs *
t@@ -103,13 +105,15 @@ vacfsopenscore(VtConn *z, u8int *score, int mode, int ncache)
root = nil;
if((r = vtfileopenroot(fs->cache, &e)) == nil)
goto Err;
-
+ if(debug)
+ fprint(2, "r %p\n", r);
root = _vacfileroot(fs, r);
+ if(debug)
+ fprint(2, "root %p\n", root);
vtfileclose(r);
if(root == nil)
goto Err;
fs->root = root;
-
return fs;
Err:
if(root)
(DIR) diff --git a/src/cmd/vac/mkfile b/src/cmd/vac/mkfile
t@@ -6,7 +6,7 @@ LIBFILES=\
fs\
pack\
-LIB=${LIBFILES:%=%.$O}
+LIB=${LIBFILES:%=%.$O} $PLAN9/lib/libventi.a
HFILES=\
$PLAN9/include/venti.h\
(DIR) diff --git a/src/cmd/vac/vac.c b/src/cmd/vac/vac.c
t@@ -318,9 +318,8 @@ vac(VtConn *z, char *argv[])
/* build meta information for the root */
ms = metasinkalloc(z, bsize, bsize);
/* fake into a directory */
- dir->mode |= (dir->mode&0444)>>2;
+ dir->mode = DMDIR|0555;
dir->qid.type |= QTDIR;
- dir->mode |= DMDIR;
plan9tovacdir(&vd, dir, 0, fileid++);
if(strcmp(vd.elem, "/") == 0){
vtfree(vd.elem);
(DIR) diff --git a/src/cmd/vac/vacfs.c b/src/cmd/vac/vacfs.c
t@@ -141,6 +141,10 @@ threadmain(int argc, char *argv[])
long ncache = 1000;
int readOnly = 1;
+ fmtinstall('H', encodefmt);
+ fmtinstall('V', vtscorefmt);
+ fmtinstall('F', vtfcallfmt);
+
defsrv = nil;
ARGBEGIN{
case 'd':
t@@ -164,6 +168,9 @@ threadmain(int argc, char *argv[])
case 'p':
noperm = 1;
break;
+ case 'V':
+ chattyventi = 1;
+ break;
default:
usage();
}ARGEND
t@@ -198,7 +205,6 @@ threadmain(int argc, char *argv[])
if(post9pservice(p[1], defsrv) != 0)
sysfatal("post9pservice");
-
threadexits(0);
}
t@@ -840,9 +846,6 @@ init(char *file, char *host, long ncache, int readOnly)
notify(notifyf);
user = getuser();
- fmtinstall('V', vtscorefmt);
-// fmtinstall('R', vtErrFmt);
-
conn = vtdial(host);
if(conn == nil)
sysfatal("could not connect to server: %r");
(DIR) diff --git a/src/cmd/venti/read.c b/src/cmd/venti/read.c
t@@ -30,7 +30,7 @@ threadmain(int argc, char *argv[])
host = EARGF(usage());
break;
case 't':
- type = atoi(argv[1]);
+ type = atoi(EARGF(usage()));
break;
default:
usage();
t@@ -62,10 +62,9 @@ threadmain(int argc, char *argv[])
break;
}
}
- }else{
- type = atoi(argv[1]);
+ }else
n = vtread(z, score, type, buf, VtMaxLumpSize);
- }
+
vthangup(z);
if(n < 0)
sysfatal("could not read block: %r");
(DIR) diff --git a/src/cmd/venti/root.c b/src/cmd/venti/root.c
t@@ -0,0 +1,72 @@
+#include <u.h>
+#include <libc.h>
+#include <venti.h>
+#include <libsec.h>
+#include <thread.h>
+
+void
+usage(void)
+{
+ fprint(2, "usage: root [-h host] score\n");
+ threadexitsall("usage");
+}
+
+void
+threadmain(int argc, char *argv[])
+{
+ int i, n;
+ uchar score[VtScoreSize];
+ uchar *buf;
+ VtConn *z;
+ char *host;
+ VtRoot root;
+
+ fmtinstall('F', vtfcallfmt);
+ fmtinstall('V', vtscorefmt);
+ quotefmtinstall();
+
+ host = nil;
+ ARGBEGIN{
+ case 'h':
+ host = EARGF(usage());
+ break;
+ default:
+ usage();
+ break;
+ }ARGEND
+
+ if(argc == 0)
+ usage();
+
+ buf = vtmallocz(VtMaxLumpSize);
+
+ z = vtdial(host);
+ if(z == nil)
+ sysfatal("could not connect to server: %r");
+
+ if(vtconnect(z) < 0)
+ sysfatal("vtconnect: %r");
+
+ for(i=0; i<argc; i++){
+ if(vtparsescore(argv[i], nil, score) < 0){
+ fprint(2, "cannot parse score '%s': %r\n", argv[i]);
+ continue;
+ }
+ n = vtread(z, score, VtRootType, buf, VtMaxLumpSize);
+ if(n < 0){
+ fprint(2, "could not read block %V: %r\n", score);
+ continue;
+ }
+ if(n != VtRootSize){
+ fprint(2, "block %V is wrong size %d != 300\n", score, n);
+ continue;
+ }
+ if(vtrootunpack(&root, buf) < 0){
+ fprint(2, "unpacking block %V: %r\n", score);
+ continue;
+ }
+ print("%V: %q %q %V %d %V\n", score, root.name, root.type, root.score, root.blocksize, root.prev);
+ }
+ vthangup(z);
+ threadexitsall(0);
+}
(DIR) diff --git a/src/cmd/venti/srv/buildindex.c b/src/cmd/venti/srv/buildindex.c
t@@ -119,6 +119,7 @@ threadmain(int argc, char *argv[])
zero = 1;
bcmem = 0;
+ ventifmtinstall();
ARGBEGIN{
case 'B':
bcmem = unittoull(ARGF());
(DIR) diff --git a/src/cmd/venti/srv/wrarena.c b/src/cmd/venti/srv/wrarena.c
t@@ -190,14 +190,14 @@ threadmain(int argc, char *argv[])
if(arena == nil)
sysfatal("initarena: %r");
- if(host && strcmp(host, "/dev/null") != 0){
+ z = nil;
+ if(host==nil || strcmp(host, "/dev/null") != 0){
z = vtdial(host);
if(z == nil)
sysfatal("could not connect to server: %r");
if(vtconnect(z) < 0)
sysfatal("vtconnect: %r");
- }else
- z = nil;
+ }
c = chancreate(sizeof(ZClump), 0);
for(i=0; i<12; i++)
(DIR) diff --git a/src/libventi/cache.c b/src/libventi/cache.c
t@@ -311,11 +311,13 @@ vtcachelocal(VtCache *c, u32int addr, int type)
{
VtBlock *b;
- if(addr >= c->nblock)
- sysfatal("vtcachelocal: asked for block #%ud; only %d blocks\n",
+ if(addr == 0)
+ sysfatal("vtcachelocal: asked for nonexistent block 0");
+ if(addr > c->nblock)
+ sysfatal("vtcachelocal: asked for block #%ud; only %d blocks",
addr, c->nblock);
- b = &c->block[addr];
+ b = &c->block[addr-1];
if(b->addr == NilBlock || b->iostate != BioLocal)
sysfatal("vtcachelocal: block is not local");
t@@ -340,7 +342,7 @@ vtcacheallocblock(VtCache *c, int type)
b = vtcachebumpblock(c);
b->iostate = BioLocal;
b->type = type;
- b->addr = b - c->block;
+ b->addr = (b - c->block)+1;
vtzeroextend(type, b->data, 0, c->blocksize);
vtlocaltoglobal(b->addr, b->score);
qunlock(&c->lk);
(DIR) diff --git a/src/libventi/entry.c b/src/libventi/entry.c
t@@ -7,7 +7,7 @@ static int
checksize(int n)
{
if(n < 256 || n > VtMaxLumpSize) {
- werrstr("bad block size");
+ werrstr("bad block size %#ux", n);
return -1;
}
return 0;
t@@ -77,6 +77,16 @@ vtentryunpack(VtEntry *e, uchar *p, int index)
if(!(e->flags & VtEntryActive))
return 0;
+ /*
+ * Some old vac files use psize==0 and dsize==0 when the
+ * file itself has size 0 or is zeros. Just to make programs not
+ * have to figure out what block sizes of 0 means, rewrite them.
+ */
+ if(e->psize == 0 && e->dsize == 0
+ && memcmp(e->score, vtzeroscore, VtScoreSize) == 0){
+ e->psize = 4096;
+ e->dsize = 4096;
+ }
if(checksize(e->psize) < 0 || checksize(e->dsize) < 0)
return -1;
(DIR) diff --git a/src/libventi/file.c b/src/libventi/file.c
t@@ -18,7 +18,6 @@
#define MaxBlock (1UL<<31)
-static char EBadEntry[] = "bad VtEntry";
static char ENotDir[] = "walk in non-directory";
static char ETooBig[] = "file too big";
/* static char EBadAddr[] = "bad address"; */
t@@ -49,8 +48,10 @@ vtfilealloc(VtCache *c, VtBlock *b, VtFile *p, u32int offset, int mode)
}else
epb = p->dsize / VtEntrySize;
- if(b->type != VtDirType)
- goto Bad;
+ if(b->type != VtDirType){
+ werrstr("bad block type %#uo", b->type);
+ return nil;
+ }
/*
* a non-active entry is the only thing that
t@@ -58,28 +59,26 @@ vtfilealloc(VtCache *c, VtBlock *b, VtFile *p, u32int offset, int mode)
* get prints.
*/
if(vtentryunpack(&e, b->data, offset % epb) < 0){
- fprint(2, "vtentryunpack failed\n");
- goto Bad;
+ fprint(2, "vtentryunpack failed: %r (%.*H)\n", VtEntrySize, b->data+VtEntrySize*(offset%epb));
+ return nil;
}
if(!(e.flags & VtEntryActive)){
- if(0)fprint(2, "not active\n");
- goto Bad;
- }
- if(e.psize < 256 || e.dsize < 256){
- fprint(2, "psize %ud dsize %ud\n", e.psize, e.dsize);
- goto Bad;
+ werrstr("entry not active");
+ return nil;
}
if(DEPTH(e.type) < sizetodepth(e.size, e.psize, e.dsize)){
fprint(2, "depth %ud size %llud psize %ud dsize %ud\n",
DEPTH(e.type), e.size, e.psize, e.dsize);
- goto Bad;
+ werrstr("bad depth");
+ return nil;
}
size = vtcacheblocksize(c);
if(e.dsize > size || e.psize > size){
- fprint(2, "psize %ud dsize %ud blocksize %ud\n", e.psize, e.dsize, size);
- goto Bad;
+ werrstr("block sizes %ud, %ud bigger than cache block size %ud",
+ e.psize, e.dsize, size);
+ return nil;
}
r = vtmallocz(sizeof(VtFile));
t@@ -105,10 +104,6 @@ vtfilealloc(VtCache *c, VtBlock *b, VtFile *p, u32int offset, int mode)
r->epb = epb;
return r;
-Bad:
- werrstr(EBadEntry);
- return nil;
-
}
VtFile *
t@@ -178,17 +173,23 @@ vtfileopen(VtFile *r, u32int offset, int mode)
return r;
}
-VtFile *
+VtFile*
vtfilecreate(VtFile *r, int psize, int dsize, int type)
{
+ return _vtfilecreate(r, -1, psize, dsize, type);
+}
+
+VtFile*
+_vtfilecreate(VtFile *r, int o, int psize, int dsize, int type)
+{
int i;
VtBlock *b;
u32int bn, size;
VtEntry e;
int epb;
VtFile *rr;
- u32int offset;
-
+ u32int offset;
+
assert(ISLOCKED(r));
assert(psize <= VtMaxLumpSize);
assert(dsize <= VtMaxLumpSize);
t@@ -205,8 +206,11 @@ vtfilecreate(VtFile *r, int psize, int dsize, int type)
/*
* look at a random block to see if we can find an empty entry
*/
- offset = lnrand(size+1);
- offset -= offset % epb;
+ if(o == -1){
+ offset = lnrand(size+1);
+ offset -= offset % epb;
+ }else
+ offset = o;
/* try the given block and then try the last block */
for(;;){