From 003c13aa185cebc8797b8b04e8bd0722643467aa Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sun, 15 Jun 2008 01:19:37 -0400 Subject: vac: make qids unique --- src/cmd/vac/file.c | 49 +- src/cmd/vac/fns.h | 1 + src/cmd/vac/mkfile | 4 +- src/cmd/vac/pack.c | 2 +- src/cmd/vac/vac.c | 1698 +++++++++++++++----------------------------------- src/cmd/vac/vac.h | 9 +- src/cmd/vac/vtdump.c | 372 ----------- 7 files changed, 564 insertions(+), 1571 deletions(-) delete mode 100644 src/cmd/vac/vtdump.c diff --git a/src/cmd/vac/file.c b/src/cmd/vac/file.c index 53cc95e3..fac419b1 100644 --- a/src/cmd/vac/file.c +++ b/src/cmd/vac/file.c @@ -45,6 +45,8 @@ struct VacFile VtFile *msource; /* metadata for children in a directory */ VacFile *down; /* children */ int mode; + + uvlong qidoffset; /* qid offset */ }; static VacFile* @@ -140,7 +142,7 @@ uvlong vacfilegetid(VacFile *f) { /* immutable */ - return f->dir.qid; + return f->qidoffset + f->dir.qid; } ulong @@ -400,6 +402,7 @@ dirlookup(VacFile *f, char *elem) filefree(ff); goto Err; } + ff->qidoffset = f->qidoffset + ff->dir.qidoffset; vtfileunlock(meta); vtblockput(b); ff->boff = bo; @@ -993,6 +996,7 @@ Found: me.p = p; me.size = n; vdpack(dir, &me, VacDirVersion); +vdunpack(dir, &me); mbinsert(&mb, i, &me); mbpack(&mb); vtblockput(b); @@ -1062,6 +1066,7 @@ filemetaflush(VacFile *f, char *oelem) /* Pack new data into new location. */ vdpack(&f->dir, &me, VacDirVersion); +vdunpack(&f->dir, &me); mbinsert(&mb, i, &me); mbpack(&mb); @@ -1269,6 +1274,7 @@ vacfilecreate(VacFile *fp, char *elem, ulong mode) if(vtfilelock2(fp->source, fp->msource, -1) < 0) goto Err1; ff = filealloc(fp->fs); + ff->qidoffset = fp->qidoffset; /* hopefully fp->qidoffset == 0 */ type = VtDataType; if(mode & ModeDir) type = VtDirType; @@ -1601,10 +1607,16 @@ vacfilesetqidspace(VacFile *f, u64int offset, u64int max) if(filelock(f) < 0) return -1; + if(f->source->mode != VtORDWR){ + fileunlock(f); + werrstr(EReadOnly); + return -1; + } filemetalock(f); f->dir.qidspace = 1; f->dir.qidoffset = offset; f->dir.qidmax = max; + f->dirty = 1; ret = filemetaflush(f, nil); filemetaunlock(f); fileunlock(f); @@ -1852,6 +1864,34 @@ _vacfsnextqid(VacFs *fs, uvlong *qid) return 0; } +void +vacfsjumpqid(VacFs *fs, uvlong step) +{ + fs->qid += step; +} + +/* + * Set *maxqid to the maximum qid expected in this file system. + * In newer vac archives, the maximum qid is stored in the + * qidspace VacDir annotation. In older vac archives, the root + * got created last, so it had the maximum qid. + */ +int +vacfsgetmaxqid(VacFs *fs, uvlong *maxqid) +{ + VacDir vd; + + if(vacfilegetdir(fs->root, &vd) < 0) + return -1; + if(vd.qidspace) + *maxqid = vd.qidmax; + else + *maxqid = vd.qid; + vdcleanup(&vd); + return 0; +} + + void vacfsclose(VacFs *fs) { @@ -1952,6 +1992,13 @@ vacfssync(VacFs *fs) /* Sync the entire vacfs to disk. */ if(vacfileflush(fs->root, 1) < 0) return -1; + if(vtfilelock(fs->root->up->msource, -1) < 0) + return -1; + if(vtfileflush(fs->root->up->msource) < 0){ + vtfileunlock(fs->root->up->msource); + return -1; + } + vtfileunlock(fs->root->up->msource); /* Prepare the dir stream for the root block. */ if(getentry(fs->root->source, &e) < 0) diff --git a/src/cmd/vac/fns.h b/src/cmd/vac/fns.h index 27cd479f..3cf87840 100644 --- a/src/cmd/vac/fns.h +++ b/src/cmd/vac/fns.h @@ -22,3 +22,4 @@ void vdpack(VacDir *dir, MetaEntry*, int); VacFile *_vacfileroot(VacFs *fs, VtFile *file); int _vacfsnextqid(VacFs *fs, uvlong *qid); +void vacfsjumpqid(VacFs*, uvlong step); diff --git a/src/cmd/vac/mkfile b/src/cmd/vac/mkfile index 224ab882..98e122b8 100644 --- a/src/cmd/vac/mkfile +++ b/src/cmd/vac/mkfile @@ -15,10 +15,8 @@ HFILES=\ dat.h\ fns.h\ -TARG=vac vacfs unvac # vtdump +TARG=vac vacfs unvac default:V: all -test:V: $O.srcload $O.wtest $O.rtest $O.vtdump $O.vtread - <$PLAN9/src/mkmany diff --git a/src/cmd/vac/pack.c b/src/cmd/vac/pack.c index cb92fad8..9777464f 100644 --- a/src/cmd/vac/pack.c +++ b/src/cmd/vac/pack.c @@ -463,7 +463,7 @@ vdpack(VacDir *dir, MetaEntry *me, int version) U32PUT(p+12, dir->atime); U32PUT(p+16, dir->mode); p += 5*4; - + if(dir->plan9 && version < 9) { U8PUT(p, DirPlan9Entry); U16PUT(p+1, 8+4); diff --git a/src/cmd/vac/vac.c b/src/cmd/vac/vac.c index 71244f43..c1508549 100644 --- a/src/cmd/vac/vac.c +++ b/src/cmd/vac/vac.c @@ -1,154 +1,103 @@ -#include -#include #include "stdinc.h" #include "vac.h" #include "dat.h" #include "fns.h" -/* - * We're between a rock and a hard place here. - * The pw library (getpwnam, etc.) reads the - * password and group files into an on-stack buffer, - * so if you have some huge groups, you overflow - * the stack. Because of this, the thread library turns - * it off by default, so that dirstat returns "14571" instead of "rsc". - * But for vac we want names. So cautiously turn the pwlibrary - * back on (see threadmain) and make the main thread stack huge. - */ -extern int _p9usepwlibrary; -int mainstacksize = 4*1024*1024; - -typedef struct Sink Sink; -typedef struct MetaSink MetaSink; -typedef struct DirSink DirSink; - -struct Sink { - VtConn *z; - VtEntry dir; - uchar *buf; - uchar *pbuf[VtPointerDepth+1]; -}; - -struct DirSink { - Sink *sink; - MetaSink *msink; - ulong nentry; - uchar *buf; - uchar *p; /* current pointer */ - uchar *ep; /* end pointer */ -}; - -struct MetaSink { - Sink *sink; - uchar *buf; - int maxindex; - int nindex; - uchar *rp; /* start of current record */ - uchar *p; /* current pointer */ - uchar *ep; /* end pointer */ -}; - -static void usage(void); -static int strpcmp(const void*, const void*); -static void warn(char *fmt, ...); -static void cleanup(void); -static u64int unittoull(char *s); -static void vac(VtConn *z, char *argv[]); -static void vacfile(DirSink *dsink, char *lname, char *sname, VacFile*); -static void vacstdin(DirSink *dsink, char *name, VacFile *vf); -static void vacdata(DirSink *dsink, int fd, char *lname, VacFile*, Dir*); -static void vacdir(DirSink *dsink, int fd, char *lname, char *sname, VacFile*); -static int vacmerge(DirSink *dsink, char *lname, char *sname); -static int vacspecial(DirSink *dsink, Dir *dir, char *lname, char *sname, VacFile *vf); -Sink *sinkalloc(VtConn *z, int psize, int dsize); -void sinkwrite(Sink *k, uchar *data, int n); -void sinkwritescore(Sink *k, uchar *score, int n); -void sinkclose(Sink *k); -void sinkfree(Sink *k); +// TODO: qids -DirSink *dirsinkalloc(VtConn *z, int psize, int dsize); -void dirsinkwrite(DirSink *k, VtEntry*); -void dirsinkwritesink(DirSink *k, Sink*); -int dirsinkwritefile(DirSink *k, VacFile *vf); -void dirsinkclose(DirSink *k); -void dirsinkfree(DirSink *k); - -MetaSink *metasinkalloc(VtConn *z, int psize, int dsize); -void metasinkputc(MetaSink *k, int c); -void metasinkputstring(MetaSink *k, char *s); -void metasinkputuint32(MetaSink *k, ulong x); -void metasinkputuint64(MetaSink *k, uvlong x); -void metasinkwrite(MetaSink *k, uchar *data, int n); -void metasinkwritedir(MetaSink *ms, VacDir *vd); -void metasinkeor(MetaSink *k); -void metasinkclose(MetaSink *k); -void metasinkfree(MetaSink *k); -void plan9tovacdir(VacDir*, Dir*, ulong entry, uvlong qid); +void +usage(void) +{ + fprint(2, "usage: vac [-b blocksize] [-h host] file...\n"); + threadexitsall("usage"); +} -enum { - Version = 8, +enum +{ BlockSize = 8*1024, MaxExclude = 1000 }; -struct { - ulong file; - ulong sfile; - ulong data; - ulong sdata; - ulong skip; - ulong meta; +struct +{ + int nfile; + int ndir; + vlong data; + vlong skipdata; + int skipfiles; } stats; -int bsize = BlockSize; -int maxbsize; -char *oname, *dfile; -int verbose; -uvlong fileid = 1; int qdiff; +int merge; +int verbose; +char *host; +VtConn *z; +VacFs *fs; char *exclude[MaxExclude]; int nexclude; -int nowrite; -int merge; -char *isi; +char *vacfile; -char **expandargv(char**); +int vacmerge(VacFile*, char*); +void vac(VacFile*, VacFile*, char*, Dir*); +void vacstdin(VacFile*, char*); -static void -usage(void) -{ - fprint(2, "usage: %s [-amqsv] [-h host] [-d vacfile] [-b blocksize] [-i name] [-e exclude] [-f vacfile] file ... \n", argv0); - threadexitsall("usage"); -} +static u64int unittoull(char*); +static void warn(char *fmt, ...); +static int strpcmp(const void*, const void*); +static void removevacfile(void); + +/* + * We're between a rock and a hard place here. + * The pw library (getpwnam, etc.) reads the + * password and group files into an on-stack buffer, + * so if you have some huge groups, you overflow + * the stack. Because of this, the thread library turns + * it off by default, so that dirstat returns "14571" instead of "rsc". + * But for vac we want names. So cautiously turn the pwlibrary + * back on (see threadmain) and make the main thread stack huge. + */ +extern int _p9usepwlibrary; +int mainstacksize = 4*1024*1024; void -threadmain(int argc, char *argv[]) +threadmain(int argc, char **argv) { - VtConn *z; - char *p; - char *host = nil; - int statsflag = 0; - + int i, j, fd, n, printstats; + Dir *d; + char *s; + uvlong u; + VacFile *f, *fdiff; + VacFs *fsdiff; + int blocksize; + int outfd; + char *stdinname; + char *diffvac; + uvlong qid; + +#ifdef PLAN9PORT /* see comment above */ _p9usepwlibrary = 1; +#endif - atexit(cleanup); + fmtinstall('H', encodefmt); + fmtinstall('V', vtscorefmt); + blocksize = BlockSize; + stdinname = nil; + printstats = 0; + fsdiff = nil; + diffvac = nil; ARGBEGIN{ - default: - usage(); case 'b': - p = ARGF(); - if(p == 0) - usage(); - bsize = unittoull(p); - if(bsize == ~0) - usage(); + u = unittoull(EARGF(usage())); + if(u < 512) + u = 512; + if(u > VtMaxLumpSize) + u = VtMaxLumpSize; + blocksize = u; break; case 'd': - dfile = ARGF(); - if(dfile == nil) - usage(); + diffvac = EARGF(usage()); break; case 'e': if(nexclude >= MaxExclude) @@ -159,22 +108,13 @@ threadmain(int argc, char *argv[]) nexclude++; break; case 'f': - oname = ARGF(); - if(oname == 0) - usage(); + vacfile = EARGF(usage()); break; case 'h': - host = ARGF(); - if(host == nil) - usage(); + host = EARGF(usage()); break; case 'i': - isi = ARGF(); - if(isi == nil) - usage(); - break; - case 'n': - nowrite++; + stdinname = EARGF(usage()); break; case 'm': merge++; @@ -183,249 +123,135 @@ threadmain(int argc, char *argv[]) qdiff++; break; case 's': - statsflag++; + printstats++; break; case 'v': verbose++; break; - }ARGEND; - - if(argc == 0) + default: + usage(); + }ARGEND + + if(argc == 0 && !stdinname) usage(); - if(bsize < 512) - bsize = 512; - if(bsize > VtMaxLumpSize) - bsize = VtMaxLumpSize; - maxbsize = bsize; + if(vacfile == nil) + outfd = 1; + else if((outfd = create(vacfile, OWRITE, 0666)) < 0) + sysfatal("create %s: %r", vacfile); + atexit(removevacfile); - fmtinstall('V', vtscorefmt); + qsort(exclude, nexclude, sizeof(char*), strpcmp); z = vtdial(host); if(z == nil) sysfatal("could not connect to server: %r"); - if(vtconnect(z) < 0) sysfatal("vtconnect: %r"); - - qsort(exclude, nexclude, sizeof(char*), strpcmp); - - argv = expandargv(argv); - - vac(z, argv); - - if(vtsync(z) < 0) - fprint(2, "warning: could not ask server to flush pending writes: %r\n"); - - if(statsflag){ - fprint(2, "files %ld:%ld data %ld:%ld:%ld meta %ld\n", stats.file, stats.sfile, - stats.data, stats.skip, stats.sdata, stats.meta); - dup(2, 1); - packetstats(); + + if(diffvac){ + if((fsdiff = vacfsopen(z, diffvac, VtOREAD, 128)) == nil) + warn("vacfsopen %s: %r", diffvac); } - vthangup(z); - - threadexitsall(0); -} -// Expand special directory names like / and . and .. into a list of their files. -char** -expandargv(char **argv) -{ - char **nargv; - int nargc; - int i, n; - Dir *d; - int fd; - char *s; + if((fs = vacfscreate(z, blocksize, 512)) == nil) + sysfatal("vacfscreate: %r"); - nargc = 0; - nargv = nil; - for(; *argv; argv++){ - cleanname(*argv); - if(strcmp(*argv, "/") == 0 || strcmp(*argv, ".") == 0 || strcmp(*argv, "..") == 0 - || (strlen(*argv) > 3 && strcmp(*argv+strlen(*argv)-3, "/..") == 0)){ - if((fd = open(*argv, OREAD)) < 0){ - warn("could not open %s: %r", *argv); - continue; - } - n = dirreadall(fd, &d); - close(fd); - if(n < 0){ - warn("could not read %s: %r", *argv); + f = vacfsgetroot(fs); + if(fsdiff) + fdiff = vacfsgetroot(fsdiff); + else + fdiff = nil; + if(stdinname) + vacstdin(f, stdinname); + for(i=0; i 3 && strcmp(argv[i]+strlen(argv[i])-3, "/..") == 0)){ + if((fd = open(argv[i], OREAD)) < 0){ + warn("open %s: %r", argv[i]); continue; } - nargv = vtrealloc(nargv, (nargc+n)*sizeof nargv[0]); - for(i=0; i 0){ + for(j=0; j= 0) + vacfilesetqidspace(f, 0, qid); + vacfiledecref(f); + + /* + * Copy fsdiff's root block score into fs's slot for that, + * so that vacfssync will copy it into root.prev for us. + * Just nice documentation, no effect. + */ + if(fsdiff) + memmove(fs->score, fsdiff->score, VtScoreSize); + if(vacfssync(fs) < 0) + fprint(2, "vacfssync: %r\n"); + + fprint(outfd, "vac:%V\n", fs->score); + vacfsclose(fs); + atexitdont(removevacfile); + vthangup(z); -int -vacwrite(VtConn *z, uchar score[VtScoreSize], int type, uchar *buf, int n) -{ - assert(n > 0); - if(nowrite){ - sha1(buf, n, score, nil); - return 0; + if(printstats){ + fprint(2, + "%d files, %d files skipped, %d directories\n" + "%lld data bytes written, %lld data bytes skipped\n", + stats.nfile, stats.skipfiles, stats.ndir, stats.data, stats.skipdata); + dup(2, 1); + packetstats(); } - return vtwrite(z, score, type, buf, n); + threadexitsall(0); } -static char* -lastelem(char *oname) +static void +removevacfile(void) { - char *p; - - if(oname == nil) - abort(); - if((p = strrchr(oname, '/')) == nil) - return oname; - return p+1; + if(vacfile) + remove(vacfile); } -static void -vac(VtConn *z, char *argv[]) +static int +strpcmp(const void *p0, const void *p1) { - DirSink *dsink, *ds; - MetaSink *ms; - VtRoot root; - uchar score[VtScoreSize], buf[VtRootSize]; - char cwd[2048]; - int cd; - char *cp2, *cp; - VacFs *fs; - VacFile *vff; - int fd; - Dir *dir; - VacDir vd; - - if(getwd(cwd, sizeof(cwd)) == 0) - sysfatal("can't find current directory: %r\n"); - - dsink = dirsinkalloc(z, bsize, bsize); - - fs = nil; - if(dfile != nil) { - fs = vacfsopen(z, dfile, VtOREAD, 1000); - if(fs == nil) - fprint(2, "could not open diff: %s: %r\n", dfile); - } - - - if(oname != nil) { - fd = create(oname, OWRITE, 0666); - if(fd < 0) - sysfatal("could not create file: %s: %r", oname); - } else - fd = 1; - - dir = dirfstat(fd); - if(dir == nil) - sysfatal("dirfstat failed: %r"); - if(oname) - dir->name = lastelem(oname); - else - dir->name = "stdin"; - - for(; *argv; argv++) { - cp2 = *argv; - cd = 0; - for (cp = *argv; *cp; cp++) - if (*cp == '/') - cp2 = cp; - if (cp2 != *argv) { - *cp2 = '\0'; - chdir(*argv); - *cp2 = '/'; - cp2++; - cd = 1; - } - vff = nil; - if(fs) - vff = vacfileopen(fs, cp2); - vacfile(dsink, argv[0], cp2, vff); - if(vff) - vacfiledecref(vff); - if(cd && chdir(cwd) < 0) - sysfatal("can't cd back to %s: %r\n", cwd); - } - - if(isi) { - vff = nil; - if(fs) - vff = vacfileopen(fs, isi); - vacstdin(dsink, isi, vff); - if(vff) - vacfiledecref(vff); - } - - dirsinkclose(dsink); - - /* build meta information for the root */ - ms = metasinkalloc(z, bsize, bsize); - /* fake into a directory */ - dir->mode = DMDIR|0555; - dir->qid.type |= QTDIR; - plan9tovacdir(&vd, dir, 0, fileid++); - if(strcmp(vd.elem, "/") == 0){ - vtfree(vd.elem); - vd.elem = vtstrdup("root"); - } - metasinkwritedir(ms, &vd); - vdcleanup(&vd); - metasinkclose(ms); - - ds = dirsinkalloc(z, bsize, bsize); - dirsinkwritesink(ds, dsink->sink); - dirsinkwritesink(ds, dsink->msink->sink); - dirsinkwritesink(ds, ms->sink); - dirsinkclose(ds); - - memset(&root, 0, sizeof(root)); - strncpy(root.name, dir->name, sizeof(root.name)); - root.name[sizeof(root.name)-1] = 0; - free(dir); - sprint(root.type, "vac"); - memmove(root.score, ds->sink->dir.score, VtScoreSize); - root.blocksize = maxbsize; - if(fs != nil) - vacfsgetscore(fs, root.prev); - - metasinkfree(ms); - dirsinkfree(ds); - dirsinkfree(dsink); - if(fs != nil) - vacfsclose(fs); - - vtrootpack(&root, buf); - if(vacwrite(z, score, VtRootType, buf, VtRootSize) < 0) - sysfatal("vacwrite: %r"); - - fprint(fd, "vac:%V\n", score); - - /* avoid remove at cleanup */ - oname = nil; + return strcmp(*(char**)p0, *(char**)p1); } static int @@ -448,897 +274,370 @@ isexcluded(char *name) return 0; } -static void -vacfile(DirSink *dsink, char *lname, char *sname, VacFile *vf) +void +plan9tovacdir(VacDir *vd, Dir *dir) { - int fd; - Dir *dir; - VacDir vd; - ulong entry; + memset(vd, 0, sizeof *vd); - if(isexcluded(lname)) { - warn("excluding: %s", lname); - return; - } + vd->elem = dir->name; + vd->uid = dir->uid; + vd->gid = dir->gid; + vd->mid = dir->muid; + if(vd->mid == nil) + vd->mid = ""; + vd->mtime = dir->mtime; + vd->mcount = 0; + vd->ctime = dir->mtime; /* ctime: not available on plan 9 */ + vd->atime = dir->atime; + vd->size = dir->length; - if(merge && vacmerge(dsink, lname, sname) >= 0) - return; + vd->mode = dir->mode & 0777; + if(dir->mode & DMDIR) + vd->mode |= ModeDir; + if(dir->mode & DMAPPEND) + vd->mode |= ModeAppend; + if(dir->mode & DMEXCL) + vd->mode |= ModeExclusive; +#ifdef PLAN9PORT + if(dir->mode & DMDEVICE) + vd->mode |= ModeDevice; + if(dir->mode & DMNAMEDPIPE) + vd->mode |= ModeNamedPipe; + if(dir->mode & DMSYMLINK) + vd->mode |= ModeLink; +#endif - if((dir = dirstat(sname)) == nil){ - warn("could not stat file %s: %r", lname); - return; - } - if(dir->mode&(DMSYMLINK|DMDEVICE|DMNAMEDPIPE)){ - vacspecial(dsink, dir, lname, sname, vf); - free(dir); - return; - }else if(dir->mode&DMSOCKET){ - free(dir); - return; - } - free(dir); + vd->plan9 = 1; + vd->p9path = dir->qid.path; + vd->p9version = dir->qid.vers; +} + +#ifdef PLAN9PORT +enum { + Special = + DMSOCKET | + DMSYMLINK | + DMNAMEDPIPE | + DMDEVICE +}; +#endif + +/* + * Does block b of f have the same SHA1 hash as the n bytes at buf? + */ +static int +sha1matches(VacFile *f, ulong b, uchar *buf, int n) +{ + uchar fscore[VtScoreSize]; + uchar bufscore[VtScoreSize]; - fd = open(sname, OREAD); - if(fd < 0) { - warn("could not open file: %s: %r", lname); + if(vacfileblockscore(f, b, fscore) < 0) + return 0; + n = vtzerotruncate(VtDataType, buf, n); + sha1(buf, n, bufscore, nil); + if(memcmp(bufscore, fscore, VtScoreSize) == 0) + return 1; + return 0; +} + +/* + * Archive the file named name, which has stat info d, + * into the vac directory fp (p = parent). + * + * If we're doing a vac -d against another archive, the + * equivalent directory to fp in that archive is diffp. + */ +void +vac(VacFile *fp, VacFile *diffp, char *name, Dir *d) +{ + char *elem, *s; + static char buf[65536]; + int fd, i, n, bsize; + vlong off; + Dir *dk; // kids + VacDir vd, vddiff; + VacFile *f, *fdiff; + VtEntry e; + + if(isexcluded(name)){ + warn("excluding %s%s", name, (d->mode&DMDIR) ? "/" : ""); return; } + if(d->mode&DMDIR) + stats.ndir++; + else + stats.nfile++; + + if(merge && vacmerge(fp, name) >= 0) + return; + if(verbose) - fprint(2, "%s\n", lname); + fprint(2, "%s%s\n", name, (d->mode&DMDIR) ? "/" : ""); - dir = dirfstat(fd); - if(dir == nil) { - warn("can't stat %s: %r", lname); - close(fd); +#ifdef PLAN9PORT + if(d->mode&Special) + fd = -1; + else +#endif + if((fd = open(name, OREAD)) < 0){ + warn("open %s: %r", name); return; } - dir->name = lastelem(sname); - entry = dsink->nentry; - - if(dir->mode & DMDIR) - vacdir(dsink, fd, lname, sname, vf); + elem = strrchr(name, '/'); + if(elem) + elem++; else - vacdata(dsink, fd, lname, vf, dir); + elem = name; - plan9tovacdir(&vd, dir, entry, fileid++); - metasinkwritedir(dsink->msink, &vd); - vdcleanup(&vd); + plan9tovacdir(&vd, d); + if((f = vacfilecreate(fp, elem, vd.mode)) == nil){ + warn("vacfilecreate %s: %r", name); + return; + } + if(diffp) + fdiff = vacfilewalk(diffp, elem); + else + fdiff = nil; - free(dir); + if(vacfilesetdir(f, &vd) < 0) + warn("vacfilesetdir %s: %r", name); + +#ifdef PLAN9PORT + if(d->mode&(DMSOCKET|DMNAMEDPIPE)){ + /* don't write anything */ + } + else if(d->mode&DMSYMLINK){ + n = readlink(name, buf, sizeof buf); + if(n > 0 && vacfilewrite(f, buf, n, 0) < 0){ + warn("venti write %s: %r", name); + goto Out; + } + stats.data += n; + }else if(d->mode&DMDEVICE){ + snprint(buf, sizeof buf, "%c %d %d", + (char)((d->qid.path >> 16) & 0xFF), + (int)(d->qid.path & 0xFF), + (int)((d->qid.path >> 8) & 0xFF)); + if(vacfilewrite(f, buf, strlen(buf), 0) < 0){ + warn("venti write %s: %r", name); + goto Out; + } + stats.data += strlen(buf); + }else +#endif + if(d->mode&DMDIR){ + while((n = dirread(fd, &dk)) > 0){ + for(i=0; ibsize; + if(fdiff){ + /* + * Copy fdiff's contents into f by moving the score. + * We'll diff and update below. + */ + if(vacfilegetentries(fdiff, &e, nil) >= 0) + if(vacfilesetentries(f, &e, nil) >= 0){ + bsize = e.dsize; + + /* + * Or if -q is set, and the metadata looks the same, + * don't even bother reading the file. + */ + if(qdiff && vacfilegetdir(fdiff, &vddiff) >= 0){ + if(vddiff.mtime == vd.mtime) + if(vddiff.size == vd.size) + if(!vddiff.plan9 || (/* vddiff.p9path == vd.p9path && */ vddiff.p9version == vd.p9version)){ + stats.skipfiles++; + stats.nfile--; + vdcleanup(&vddiff); + goto Out; + } + + /* + * Skip over presumably-unchanged prefix + * of an append-only file. + */ + if(vd.mode&ModeAppend) + if(vddiff.size < vd.size) + if(vddiff.plan9 && vd.plan9) + if(vddiff.p9path == vd.p9path){ + off = vd.size/bsize*bsize; + if(seek(fd, off, 0) >= 0) + stats.skipdata += off; + else{ + seek(fd, 0, 0); // paranoia + off = 0; + } + } + + vdcleanup(&vddiff); + // XXX different verbose chatty prints for kaminsky? + } + } + } + if(qdiff && verbose) + fprint(2, "+%s\n", name); + while((n = readn(fd, buf, bsize)) > 0){ + if(fdiff && sha1matches(f, off/bsize, (uchar*)buf, n)){ + off += n; + stats.skipdata += n; + continue; + } + if(vacfilewrite(f, buf, n, off) < 0){ + warn("venti write %s: %r", name); + goto Out; + } + stats.data += n; + off += n; + } + /* + * Since we started with fdiff's contents, + * set the size in case fdiff was bigger. + */ + if(fdiff && vacfilesetsize(f, off) < 0) + warn("vtfilesetsize %s: %r", name); + } + +Out: + vacfileflush(f, 1); + vacfiledecref(f); + if(fdiff) + vacfiledecref(fdiff); close(fd); } -static void -vacstdin(DirSink *dsink, char *name, VacFile *vf) +void +vacstdin(VacFile *fp, char *name) { - Dir *dir; - VacDir vd; - ulong entry; - - if(verbose) - fprint(2, "%s\n", ""); + vlong off; + VacFile *f; + static char buf[8192]; + int n; - dir = dirfstat(0); - if(dir == nil) { - warn("can't stat : %r"); + if((f = vacfilecreate(fp, name, 0666)) == nil){ + warn("vacfilecreate %s: %r", name); return; } - dir->name = "stdin"; - - entry = dsink->nentry; - - vacdata(dsink, 0, "", vf, dir); - - plan9tovacdir(&vd, dir, entry, fileid++); - vd.elem = vtstrdup(name); - metasinkwritedir(dsink->msink, &vd); - vdcleanup(&vd); - - free(dir); -} - -static int -sha1check(u8int *score, uchar *buf, int n) -{ - uchar score2[VtScoreSize]; - - sha1(buf, n, score2, nil); - if(memcmp(score, score2, VtScoreSize) == 0) - return 0; - return -1; + + off = 0; + while((n = read(0, buf, sizeof buf)) > 0){ + if(vacfilewrite(f, buf, n, off) < 0){ + warn("venti write %s: %r", name); + vacfiledecref(f); + return; + } + off += n; + } + vacfileflush(f, 1); + vacfiledecref(f); } -static ulong -vacdataskip(Sink *sink, VacFile *vf, int fd, ulong blocks, uchar *buf, char *lname) +/* + * fp is the directory we're writing. + * mp is the directory whose contents we're merging in. + * d is the directory entry of the file from mp that we want to add to fp. + * vacfile is the name of the .vac file, for error messages. + * offset is the qid that qid==0 in mp should correspond to. + * max is the maximum qid we expect to see (not really needed). + */ +int +vacmergefile(VacFile *fp, VacFile *mp, VacDir *d, char *vacfile, + vlong offset, vlong max) { - int n; - ulong i; - uchar score[VtScoreSize]; - - /* skip blocks for append only files */ - if(seek(fd, (blocks-1)*bsize, 0) != (blocks-1)*bsize) { - warn("error seeking: %s", lname); - goto Err; + VtEntry ed, em; + VacFile *mf; + VacFile *f; + + mf = vacfilewalk(mp, d->elem); + if(mf == nil){ + warn("could not walk %s in %s", d->elem, vacfile); + return -1; } - n = readn(fd, buf, bsize); - if(n < bsize) { - warn("error checking append only file: %s", lname); - goto Err; + if(vacfilegetentries(mf, &ed, &em) < 0){ + warn("could not get entries for %s in %s", d->elem, vacfile); + vacfiledecref(mf); + return -1; } - if(vacfileblockscore(vf, blocks-1, score)<0 || sha1check(score, buf, n)<0) { - warn("last block of append file did not match: %s", lname); - goto Err; + + if((f = vacfilecreate(fp, d->elem, d->mode)) == nil){ + warn("vacfilecreate %s: %r", d->elem); + vacfiledecref(mf); + return -1; } - - for(i=0; iqidspace){ + d->qidoffset += offset; + d->qidmax += offset; + }else{ + d->qidspace = 1; + d->qidoffset = offset; + d->qidmax = max; + } + if(vacfilesetdir(f, d) < 0 || vacfilesetentries(f, &ed, &em) < 0){ + warn("vacmergefile %s: %r", d->elem); + vacfiledecref(mf); + vacfiledecref(f); + return -1; } - - return i; -Err: - seek(fd, 0, 0); + + vacfiledecref(mf); + vacfiledecref(f); return 0; } -static void -vacdata(DirSink *dsink, int fd, char *lname, VacFile *vf, Dir *dir) +int +vacmerge(VacFile *fp, char *name) { - uchar *buf; - Sink *sink; - int n; - uchar score[VtScoreSize]; - ulong block, same; + VacFs *mfs; VacDir vd; - ulong vfblocks; + VacDirEnum *de; + VacFile *mp; + uvlong maxqid, offset; - vfblocks = 0; - if(vf != nil && qdiff) { - vacfilegetdir(vf, &vd); - if(vd.mtime == dir->mtime) - if(vd.size == dir->length) - if(!vd.plan9 || /* vd.p9path == dir->qid.path && */ vd.p9version == dir->qid.vers) - if(dirsinkwritefile(dsink, vf) >= 0) { - stats.sfile++; - vdcleanup(&vd); - return; - } - - if(verbose) - fprint(2, "+ %s\n", lname); - - /* look for an append only file */ - if((dir->mode&DMAPPEND) != 0) - if(vd.size < dir->length) - if(vd.plan9) - if(vd.p9path == dir->qid.path) - vfblocks = vd.size/bsize; - - vdcleanup(&vd); - } - stats.file++; - - buf = vtmalloc(bsize); - sink = sinkalloc(dsink->sink->z, bsize, bsize); - block = 0; - same = stats.sdata+stats.skip; - - if(vfblocks > 1) - block += vacdataskip(sink, vf, fd, vfblocks, buf, lname); - - for(;;) { - n = readn(fd, buf, bsize); - if(0 && n < 0) - warn("file truncated due to read error: %s: %r", lname); - if(n <= 0) - break; - if(vf != nil && vacfileblockscore(vf, block, score)>=0 && sha1check(score, buf, n)>=0) { - stats.sdata++; - sinkwritescore(sink, score, n); - } else - sinkwrite(sink, buf, n); - block++; - } - same = stats.sdata+stats.skip - same; - - if(same && (dir->mode&DMAPPEND) != 0) - if(0)fprint(2, "%s: total %lud same %lud:%lud diff %lud\n", - lname, block, same, vfblocks, block-same); - - sinkclose(sink); - dirsinkwritesink(dsink, sink); - sinkfree(sink); - free(buf); -} - - -static void -vacdir(DirSink *dsink, int fd, char *lname, char *sname, VacFile *vf) -{ - Dir *dirs; - char *ln, *sn; - int i, nd; - DirSink *ds; - VacFile *vvf; - char *name; - - ds = dirsinkalloc(dsink->sink->z, bsize, bsize); - while((nd = dirread(fd, &dirs)) > 0){ - for(i = 0; i < nd; i++){ - name = dirs[i].name; - /* check for bad file names */ - if(name[0] == 0 || strcmp(name, ".") == 0 || strcmp(name, "..") == 0) - continue; - ln = vtmalloc(strlen(lname) + strlen(name) + 2); - sn = vtmalloc(strlen(sname) + strlen(name) + 2); - strcpy(ln, lname); - strcat(ln, "/"); - strcat(ln, name); - strcpy(sn, sname); - strcat(sn, "/"); - strcat(sn, name); - if(vf != nil) - vvf = vacfilewalk(vf, name); - else - vvf = nil; - vacfile(ds, ln, sn, vvf); - if(vvf != nil) - vacfiledecref(vvf); - vtfree(ln); - vtfree(sn); - } - free(dirs); - } - dirsinkclose(ds); - dirsinkwritesink(dsink, ds->sink); - dirsinkwritesink(dsink, ds->msink->sink); - dirsinkfree(ds); -} - -static int -vacmergefile(DirSink *dsink, VacFile *vf, VacDir *dir, uvlong offset, uvlong *max) -{ - uchar buf[VtEntrySize]; - VtEntry dd, md; - int e; - - if(vacfileread(vf, buf, VtEntrySize, (uvlong)dir->entry*VtEntrySize) != VtEntrySize) { - warn("could not read venti dir entry: %s\n", dir->elem); - return -1; - } - vtentryunpack(&dd, buf, 0); - - if(dir->mode & ModeDir) { - e = dir->mentry; - if(e == 0) - e = dir->entry + 1; - - if(vacfileread(vf, buf, VtEntrySize, e*VtEntrySize) != VtEntrySize) { - warn("could not read venti dir entry: %s\n", dir->elem); - return 0; - } - vtentryunpack(&md, buf, 0); - } - - /* max might incorrect in some old dumps */ - if(dir->qid >= *max) { - warn("qid out of range: %s", dir->elem); - *max = dir->qid; - } - - dir->qid += offset; - dir->entry = dsink->nentry; - - if(dir->qidspace) { - dir->qidoffset += offset; - } else { - dir->qidspace = 1; - dir->qidoffset = offset; - dir->qidmax = *max; - } - - dirsinkwrite(dsink, &dd); - if(dir->mode & ModeDir) - dirsinkwrite(dsink, &md); - metasinkwritedir(dsink->msink, dir); - - return 0; -} - -static int -vacmerge(DirSink *dsink, char *lname, char *sname) -{ - char *p; - VacFs *fs; - VacFile *vf; - VacDirEnum *d; - VacDir dir; - uvlong max; - - if((p=strrchr(sname, '.')) == nil || strcmp(p, ".vac") != 0) + if(strlen(name) < 4 || strcmp(name+strlen(name)-4, ".vac") != 0) return -1; - - d = nil; - fs = vacfsopen(dsink->sink->z, sname, VtOREAD, 100); - if(fs == nil) + if((mfs = vacfsopen(z, name, VtOREAD, 100)) == nil) return -1; - - vf = vacfileopen(fs, "/"); - if(vf == nil) - goto Done; - max = vacfilegetid(vf); - d = vdeopen(vf); - if(d == nil) - goto Done; - if(verbose) - fprint(2, "merging: %s\n", lname); - - if(maxbsize < fs->bsize) - maxbsize = fs->bsize; - - for(;;) { - if(vderead(d, &dir) < 1) - break; - vacmergefile(dsink, vf, &dir, fileid, &max); - vdcleanup(&dir); - } - fileid += max; - -Done: - if(d != nil) - vdeclose(d); - if(vf != nil) - vacfiledecref(vf); - vacfsclose(fs); - return 0; -} - -static int -vacspecial(DirSink *dsink, Dir* dir, char *lname, char *sname, VacFile *vf) -{ - char *btmp, *buf; - int buflen, dtype, major, minor, n; - ulong entry; - Sink *sink; - VacDir vd; - - n = 0; - buflen = 128; - buf = malloc(buflen); - if(buf == nil) - return -1; - - if(verbose) - fprint(2, "%s\n", lname); - - dir->name = lastelem(sname); - - if(dir->mode & DMSYMLINK){ - while((n = readlink(sname, buf, buflen)) == buflen){ - buflen *= 2; - btmp = vtrealloc(buf, buflen); - if(btmp == nil){ - free(buf); - return -1; + fprint(2, "merging %s\n", name); + + de = vdeopen(fs->root); + if(de){ + mp = vacfsgetroot(mfs); + offset = 0; + if(vacfsgetmaxqid(mfs, &maxqid) >= 0){ + _vacfsnextqid(fs, &offset); + vacfsjumpqid(fs, maxqid+1); + } + while(vderead(de, &vd) > 0){ + if(vd.qid > maxqid){ + warn("vacmerge %s: maxqid=%lld but %s has %lld", + name, maxqid, vd.elem, vd.qid); + vacfsjumpqid(fs, vd.qid - maxqid); + maxqid = vd.qid; } - buf = btmp; + vacmergefile(fp, mp, &vd, name, + offset, maxqid); + vdcleanup(&vd); } - dir->mode &= ~DMDIR; - dir->mode |= DMSYMLINK; - }else if(dir->mode & DMDEVICE){ - dtype = (dir->qid.path >> 16) & 0xFF; - minor = dir->qid.path & 0xff; - major = (dir->qid.path >> 8) & 0xFF; - n = snprint(buf, buflen, "%c %d %d", dtype, major, minor); + vdeclose(de); + vacfiledecref(mp); } - - entry = dsink->nentry; - - sink = sinkalloc(dsink->sink->z, bsize, bsize); - sinkwrite(sink, (uchar*)buf, n); - sinkclose(sink); - dirsinkwritesink(dsink, sink); - sinkfree(sink); - free(buf); - - dir->name = lastelem(sname); - dir->length = n; - plan9tovacdir(&vd, dir, entry, fileid++); - metasinkwritedir(dsink->msink, &vd); - vdcleanup(&vd); - + vacfsclose(mfs); return 0; } - -Sink * -sinkalloc(VtConn *z, int psize, int dsize) -{ - Sink *k; - int i; - - if(psize < 512 || psize > VtMaxLumpSize) - sysfatal("sinkalloc: bad psize"); - if(dsize < 512 || dsize > VtMaxLumpSize) - sysfatal("sinkalloc: bad psize"); - - psize = VtScoreSize*(psize/VtScoreSize); - - k = vtmallocz(sizeof(Sink)); - k->z = z; - k->dir.flags = VtEntryActive; - k->dir.psize = psize; - k->dir.dsize = dsize; - k->buf = vtmallocz(VtPointerDepth*k->dir.psize + VtScoreSize); - for(i=0; i<=VtPointerDepth; i++) - k->pbuf[i] = k->buf + i*k->dir.psize; - return k; -} - -void -sinkwritescore(Sink *k, uchar score[VtScoreSize], int n) -{ - int i; - uchar *p; - VtEntry *d; - - memmove(k->pbuf[0], score, VtScoreSize); - - d = &k->dir; - - for(i=0; ipbuf[i] += VtScoreSize; - if(k->pbuf[i] < k->buf + d->psize*(i+1)) - break; - if(i == VtPointerDepth-1) - sysfatal("file too big"); - p = k->buf+i*d->psize; - stats.meta++; - if(vacwrite(k->z, k->pbuf[i+1], VtDataType+1+i, p, d->psize) < 0) - sysfatal("vacwrite failed: %r"); - k->pbuf[i] = p; - } - - /* round size up to multiple of dsize */ - d->size = d->dsize * ((d->size + d->dsize-1)/d->dsize); - - d->size += n; -} - -void -sinkwrite(Sink *k, uchar *p, int n) -{ - int type; - uchar score[VtScoreSize]; - - if(n == 0) - return; - - if(n > k->dir.dsize) - sysfatal("sinkwrite: size too big"); - - if((k->dir.type&~VtTypeDepthMask) == VtDirType){ - type = VtDirType; - stats.meta++; - } else { - type = VtDataType; - stats.data++; - } - if(vacwrite(k->z, score, type, p, n) < 0) - sysfatal("vacwrite: %r"); - - sinkwritescore(k, score, n); -} - -static int -sizetodepth(uvlong s, int psize, int dsize) -{ - int np; - int d; - - /* determine pointer depth */ - np = psize/VtScoreSize; - s = (s + dsize - 1)/dsize; - for(d = 0; s > 1; d++) - s = (s + np - 1)/np; - return d; -} - -void -sinkclose(Sink *k) -{ - int i, n, base; - uchar *p; - VtEntry *kd; - - kd = &k->dir; - - /* empty */ - if(kd->size == 0) { - memmove(kd->score, vtzeroscore, VtScoreSize); - return; - } - - for(n=VtPointerDepth-1; n>0; n--) - if(k->pbuf[n] > k->buf + kd->psize*n) - break; - - base = kd->type&~VtTypeDepthMask; - kd->type = base + sizetodepth(kd->size, kd->psize, kd->dsize); - - /* skip full part of tree */ - for(i=0; ipbuf[i] == k->buf + kd->psize*i; i++) - ; - - /* is the tree completely full */ - if(i == n && k->pbuf[n] == k->buf + kd->psize*n + VtScoreSize) { - memmove(kd->score, k->pbuf[n] - VtScoreSize, VtScoreSize); - return; - } - n++; - - /* clean up the edge */ - for(; ibuf+i*kd->psize; - stats.meta++; - if(vacwrite(k->z, k->pbuf[i+1], base+1+i, p, k->pbuf[i]-p) < 0) - sysfatal("vacwrite: %r"); - k->pbuf[i+1] += VtScoreSize; - } - memmove(kd->score, k->pbuf[i] - VtScoreSize, VtScoreSize); -} - -void -sinkfree(Sink *k) -{ - vtfree(k->buf); - vtfree(k); -} - -DirSink * -dirsinkalloc(VtConn *z, int psize, int dsize) -{ - DirSink *k; - int ds; - - ds = VtEntrySize*(dsize/VtEntrySize); - - k = vtmallocz(sizeof(DirSink)); - k->sink = sinkalloc(z, psize, ds); - k->sink->dir.type = VtDirType; - k->msink = metasinkalloc(z, psize, dsize); - k->buf = vtmalloc(ds); - k->p = k->buf; - k->ep = k->buf + ds; - return k; -} - -void -dirsinkwrite(DirSink *k, VtEntry *dir) -{ - if(k->p + VtEntrySize > k->ep) { - sinkwrite(k->sink, k->buf, k->p - k->buf); - k->p = k->buf; - } - vtentrypack(dir, k->p, 0); - k->nentry++; - k->p += VtEntrySize; -} - -void -dirsinkwritesink(DirSink *k, Sink *sink) -{ - dirsinkwrite(k, &sink->dir); -} - -int -dirsinkwritefile(DirSink *k, VacFile *vf) -{ - VtEntry dir; - - if(vacfilegetentries(vf, &dir, nil) < 0) - return -1; - dirsinkwrite(k, &dir); - return 0; -} - -void -dirsinkclose(DirSink *k) -{ - metasinkclose(k->msink); - if(k->p != k->buf) - sinkwrite(k->sink, k->buf, k->p - k->buf); - sinkclose(k->sink); -} - -void -dirsinkfree(DirSink *k) -{ - sinkfree(k->sink); - metasinkfree(k->msink); - vtfree(k->buf); - vtfree(k); -} - -MetaSink* -metasinkalloc(VtConn *z, int psize, int dsize) -{ - MetaSink *k; - - k = vtmallocz(sizeof(MetaSink)); - k->sink = sinkalloc(z, psize, dsize); - k->buf = vtmalloc(dsize); - k->maxindex = dsize/100; /* 100 byte entries seems reasonable */ - if(k->maxindex < 1) - k->maxindex = 1; - k->rp = k->p = k->buf + MetaHeaderSize + k->maxindex*MetaIndexSize; - k->ep = k->buf + dsize; - return k; -} - -/* hack to get base to compare routine - not reentrant */ -uchar *blockbase; - -int -dircmp(const void *p0, const void *p1) -{ - uchar *q0, *q1; - int n0, n1, r; - - /* name is first element of entry */ - q0 = (uchar*)p0; - q0 = blockbase + (q0[0]<<8) + q0[1]; - n0 = (q0[6]<<8) + q0[7]; - q0 += 8; - - q1 = (uchar*)p1; - q1 = blockbase + (q1[0]<<8) + q1[1]; - n1 = (q1[6]<<8) + q1[7]; - q1 += 8; - - if(n0 == n1) - return memcmp(q0, q1, n0); - else if (n0 < n1) { - r = memcmp(q0, q1, n0); - return (r==0)?1:r; - } else { - r = memcmp(q0, q1, n1); - return (r==0)?-1:r; - } -} - -void -metasinkflush(MetaSink *k) -{ - uchar *p; - int n; - MetaBlock mb; - - if(k->nindex == 0) - return; - assert(k->nindex <= k->maxindex); - - p = k->buf; - n = k->rp - p; - - mb.size = n; - mb.free = 0; - mb.nindex = k->nindex; - mb.maxindex = k->maxindex; - mb.buf = p; - mbpack(&mb); - - p += MetaHeaderSize; - - /* XXX this is not reentrant! */ - blockbase = k->buf; - qsort(p, k->nindex, MetaIndexSize, dircmp); - p += k->nindex*MetaIndexSize; - - memset(p, 0, (k->maxindex-k->nindex)*MetaIndexSize); - p += (k->maxindex-k->nindex)*MetaIndexSize; - - sinkwrite(k->sink, k->buf, n); - - /* move down partial entry */ - n = k->p - k->rp; - memmove(p, k->rp, n); - k->rp = p; - k->p = p + n; - k->nindex = 0; -} - -void -metasinkputc(MetaSink *k, int c) -{ - if(k->p+1 > k->ep) - metasinkflush(k); - if(k->p+1 > k->ep) - sysfatal("directory entry too large"); - k->p[0] = c; - k->p++; -} - -void -metasinkputstring(MetaSink *k, char *s) -{ - int n = strlen(s); - metasinkputc(k, n>>8); - metasinkputc(k, n); - metasinkwrite(k, (uchar*)s, n); -} - -void -metasinkputuint32(MetaSink *k, ulong x) -{ - metasinkputc(k, x>>24); - metasinkputc(k, x>>16); - metasinkputc(k, x>>8); - metasinkputc(k, x); -} - -void -metasinkputuint64(MetaSink *k, uvlong x) -{ - metasinkputuint32(k, x>>32); - metasinkputuint32(k, x); -} - -void -metasinkwrite(MetaSink *k, uchar *data, int n) -{ - if(k->p + n > k->ep) - metasinkflush(k); - if(k->p + n > k->ep) - sysfatal("directory entry too large"); - - memmove(k->p, data, n); - k->p += n; -} - -void -metasinkwritedir(MetaSink *ms, VacDir *dir) -{ - - metasinkputuint32(ms, DirMagic); - metasinkputc(ms, Version>>8); - metasinkputc(ms, Version); - metasinkputstring(ms, dir->elem); - metasinkputuint32(ms, dir->entry); - metasinkputuint64(ms, dir->qid); - metasinkputstring(ms, dir->uid); - metasinkputstring(ms, dir->gid); - metasinkputstring(ms, dir->mid); - metasinkputuint32(ms, dir->mtime); - metasinkputuint32(ms, dir->mcount); - metasinkputuint32(ms, dir->ctime); - metasinkputuint32(ms, dir->atime); - metasinkputuint32(ms, dir->mode); - - if(dir->plan9) { - metasinkputc(ms, DirPlan9Entry); /* plan9 extra info */ - metasinkputc(ms, 0); /* plan9 extra size */ - metasinkputc(ms, 12); /* plan9 extra size */ - metasinkputuint64(ms, dir->p9path); - metasinkputuint32(ms, dir->p9version); - } - - if(dir->qidspace != 0) { - metasinkputc(ms, DirQidSpaceEntry); - metasinkputc(ms, 0); - metasinkputc(ms, 16); - metasinkputuint64(ms, dir->qidoffset); - metasinkputuint64(ms, dir->qidmax); - } - - if(dir->gen != 0) { - metasinkputc(ms, DirGenEntry); - metasinkputc(ms, 0); - metasinkputc(ms, 4); - metasinkputuint32(ms, dir->gen); - } - - metasinkeor(ms); -} - - -void -plan9tovacdir(VacDir *vd, Dir *dir, ulong entry, uvlong qid) -{ - memset(vd, 0, sizeof(VacDir)); - - vd->elem = vtstrdup(dir->name); - vd->entry = entry; - vd->qid = qid; - vd->uid = vtstrdup(dir->uid); - vd->gid = vtstrdup(dir->gid); - vd->mid = vtstrdup(dir->muid); - vd->mtime = dir->mtime; - vd->mcount = 0; - vd->ctime = dir->mtime; /* ctime: not available on plan 9 */ - vd->atime = dir->atime; - - vd->mode = dir->mode & 0777; - if(dir->mode & DMDIR) - vd->mode |= ModeDir; - if(dir->mode & DMAPPEND) - vd->mode |= ModeAppend; - if(dir->mode & DMEXCL) - vd->mode |= ModeExclusive; - if(dir->mode & DMDEVICE) - vd->mode |= ModeDevice; - if(dir->mode & DMNAMEDPIPE) - vd->mode |= ModeNamedPipe; - if(dir->mode & DMSYMLINK) - vd->mode |= ModeLink; - - vd->plan9 = 1; - vd->p9path = dir->qid.path; - vd->p9version = dir->qid.vers; -} - -void -metasinkeor(MetaSink *k) -{ - uchar *p; - int o, n; - - p = k->buf + MetaHeaderSize; - p += k->nindex * MetaIndexSize; - o = k->rp-k->buf; /* offset from start of block */ - n = k->p-k->rp; /* size of entry */ - p[0] = o >> 8; - p[1] = o; - p[2] = n >> 8; - p[3] = n; - k->rp = k->p; - k->nindex++; - if(k->nindex == k->maxindex) - metasinkflush(k); -} - -void -metasinkclose(MetaSink *k) -{ - metasinkflush(k); - sinkclose(k->sink); -} - -void -metasinkfree(MetaSink *k) -{ - sinkfree(k->sink); - vtfree(k->buf); - vtfree(k); -} - -static void -warn(char *fmt, ...) -{ - va_list arg; - - va_start(arg, fmt); - fprint(2, "%s: ", argv0); - vfprint(2, fmt, arg); - fprint(2, "\n"); - va_end(arg); -} - -static void -cleanup(void) -{ - if(oname != nil) - remove(oname); -} - #define TWID64 ((u64int)~(u64int)0) static u64int @@ -1364,3 +663,16 @@ unittoull(char *s) return TWID64; return n; } + +static void +warn(char *fmt, ...) +{ + va_list arg; + + va_start(arg, fmt); + fprint(2, "vac: "); + vfprint(2, fmt, arg); + fprint(2, "\n"); + va_end(arg); +} + diff --git a/src/cmd/vac/vac.h b/src/cmd/vac/vac.h index 5ce69734..610028f4 100644 --- a/src/cmd/vac/vac.h +++ b/src/cmd/vac/vac.h @@ -3,6 +3,11 @@ typedef struct VacDir VacDir; typedef struct VacFile VacFile; typedef struct VacDirEnum VacDirEnum; +#ifndef PLAN9PORT +#pragma incomplete VacFile +#pragma incomplete VacDirEnum +#endif + /* * Mode bits */ @@ -99,6 +104,8 @@ void vacfsclose(VacFs *fs); int vacfssync(VacFs *fs); int vacfssnapshot(VacFs *fs, char *src, char *dst); int vacfsgetscore(VacFs *fs, u8int *score); +int vacfsgetmaxqid(VacFs*, uvlong*); +void vacfsjumpqid(VacFs*, uvlong); VacFile *vacfsgetroot(VacFs *fs); VacFile *vacfileopen(VacFs *fs, char *path); @@ -127,7 +134,7 @@ int vacfilesetentries(VacFile *f, VtEntry *e, VtEntry *me); void vdcleanup(VacDir *dir); void vdcopy(VacDir *dst, VacDir *src); - +int vacfilesetqidspace(VacFile*, u64int, u64int); VacDirEnum *vdeopen(VacFile*); int vderead(VacDirEnum*, VacDir *); diff --git a/src/cmd/vac/vtdump.c b/src/cmd/vac/vtdump.c deleted file mode 100644 index 2daaf1bb..00000000 --- a/src/cmd/vac/vtdump.c +++ /dev/null @@ -1,372 +0,0 @@ -#include "stdinc.h" -#include - -typedef struct Source Source; - -struct Source -{ - ulong gen; - int psize; - int dsize; - int dir; - int active; - int depth; - uvlong size; - uchar score[VtScoreSize]; - int reserved; -}; - -int bsize; -Biobuf *bout; -VtRoot root; -int ver; -int cmp; -int all; -int find; -uchar fscore[VtScoreSize]; -VtConn *z; - -int vtgetuint16(uchar *p); -ulong vtgetuint32(uchar *p); -uvlong vtgetuint48(uchar *p); -void usage(void); -void readroot(VtRoot*, uchar *score, char *file); -int dumpdir(Source*, int indent); -int timevtread(VtConn*, uchar*, int, void*, int); - -int mainstacksize = 512*1024; - -void -threadmain(int argc, char *argv[]) -{ - char *host = nil, *pref; - uchar score[VtScoreSize]; - Source source; - char *p; - int n; - uchar buf[VtMaxLumpSize]; - - ARGBEGIN{ - case 'h': - host = ARGF(); - break; - case 'c': - cmp++; - break; - case 'f': - find++; - p = ARGF(); - if(p == nil || vtparsescore(p, &pref, fscore) < 0 || !pref || strcmp(pref, "vac") != 0) - usage(); - break; - case 'a': - all = 1; - break; - }ARGEND - - bout = vtmallocz(sizeof(Biobuf)); - Binit(bout, 1, OWRITE); - - if(argc > 1) - usage(); - - fmtinstall('V', vtscorefmt); - fmtinstall('H', encodefmt); - - z = vtdial(host); - if(z == nil) - sysfatal("could not connect to server: %r"); - - if(vtconnect(z) < 0) - sysfatal("vtconnect: %r"); - - readroot(&root, score, argv[0]); - bsize = root.blocksize; - if(!find) { - Bprint(bout, "score: %V\n", score); - Bprint(bout, "name: %s\n", root.name); - Bprint(bout, "type: %s\n", root.type); - Bprint(bout, "bsize: %d\n", bsize); - Bprint(bout, "prev: %V\n", root.prev); - } - -fprint(2, "read...\n"); - n = timevtread(z, root.score, VtDirType, buf, bsize); - if(n < 0) - sysfatal("could not read root dir"); - -fprint(2, "...\n"); - /* fake up top level source */ - memset(&source, 0, sizeof(source)); - memmove(source.score, root.score, VtScoreSize); - source.psize = bsize; - source.dsize = bsize; - source.dir = 1; - source.active = 1; - source.depth = 0; - source.size = n; - - dumpdir(&source, 0); - - Bterm(bout); - - vthangup(z); - threadexitsall(0); -} - -void -sourceprint(Source *s, int indent, int entry) -{ - int i; - uvlong size; - int ne; - - for(i=0; iactive) { - /* dir size in directory entries */ - if(s->dir) { - ne = s->dsize/VtEntrySize; - size = ne*(s->size/s->dsize) + (s->size%s->dsize)/VtEntrySize; - } else - size = s->size; - if(cmp) { - Bprint(bout, ": gen: %lud size: %llud", - s->gen, size); - if(!s->dir) - Bprint(bout, ": %V", s->score); - } else { - Bprint(bout, ": gen: %lud psize: %d dsize: %d", - s->gen, s->psize, s->dsize); - Bprint(bout, " depth: %d size: %llud: %V", - s->depth, size, s->score); - } - - if(s->reserved) - Bprint(bout, ": reserved not emtpy"); - } - Bprint(bout, "\n"); -} - -int -parse(Source *s, uchar *p) -{ - VtEntry dir; - - memset(s, 0, sizeof(*s)); - if(vtentryunpack(&dir, p, 0) < 0) - return -1; - - if(!(dir.flags & VtEntryActive)) - return 0; - - s->active = 1; - s->gen = dir.gen; - s->psize = dir.psize; - s->dsize = dir.dsize; - s->size = dir.size; - memmove(s->score, dir.score, VtScoreSize); - if((dir.type&~VtTypeDepthMask) == VtDirType) - s->dir = 1; - s->depth = dir.type&VtTypeDepthMask; - return 0; -} - -int -sourceread(Source *s, ulong block, uchar *p, int n) -{ - uchar *buf; - uchar score[VtScoreSize]; - int i, nn, np, type; - int elem[VtPointerDepth]; - - buf = vtmalloc(VtMaxLumpSize); - - memmove(score, s->score, VtScoreSize); - - np = s->psize/VtScoreSize; - for(i=0; idepth; i++) { - elem[i] = block % np; - block /= np; - } - assert(block == 0); - - for(i=s->depth-1; i>=0; i--) { - nn = timevtread(z, score, (s->dir ? VtDirType : VtDataType)+1+i, buf, s->psize); - if(nn < 0){ -fprint(2, "vtread %V %d: %r\n", score, (s->dir ? VtDirType : VtDataType)+1+i); - free(buf); - return -1; - } - - if((elem[i]+1)*VtScoreSize > nn){ - free(buf); - return 0; - } - memmove(score, buf + elem[i]*VtScoreSize, VtScoreSize); - } - - if(s->dir) - type = VtDirType; - else - type = VtDataType; - - nn = timevtread(z, score, type, p, n); - if(nn < 0){ -fprint(2, "vtread %V %d: %r\n", score, type); -abort(); - free(buf); - return -1; - } - - free(buf); - return nn; -} - -void -dumpfilecontents(Source *s) -{ - int nb, lb, i, n; - uchar buf[VtMaxLumpSize]; - - nb = (s->size + s->dsize - 1)/s->dsize; - lb = s->size%s->dsize; - for(i=0; idsize); - n = sourceread(s, i, buf, s->dsize); - if(n < 0) { - fprint(2, "could not read block: %d: %r\n", i); - continue; - } - if(i < nb-1) - Bwrite(bout, buf, s->dsize); - else - Bwrite(bout, buf, lb); - } -} - -void -dumpfile(Source *s, int indent) -{ - int nb, i, j, n; - uchar *buf; - uchar score[VtScoreSize]; - - buf = vtmalloc(VtMaxLumpSize); - nb = (s->size + s->dsize - 1)/s->dsize; - for(i=0; idsize); - n = sourceread(s, i, buf, s->dsize); - if(n < 0) { - fprint(2, "could not read block: %d: %r\n", i); - continue; - } - for(j=0; jdsize/VtEntrySize; - ne = pb*(s->size/s->dsize) + (s->size%s->dsize)/VtEntrySize; - nb = (s->size + s->dsize - 1)/s->dsize; - for(i=0; idsize); - n = sourceread(s, i, buf, s->dsize); - if(n < 0) { - fprint(2, "could not read block: %d: %r\n", i); - continue; - } - for(j=0; j= ne) - break; - parse(&ss, buf + j * VtEntrySize); - - if(!find) - sourceprint(&ss, indent, entry); - else if(memcmp(ss.score, fscore, VtScoreSize) == 0) { - dumpfilecontents(&ss); - free(buf); - return -1; - } - - if(ss.dir) { - if(dumpdir(&ss, indent+1) < 0){ - free(buf); - return -1; - } - } else if(all) - dumpfile(&ss, indent+1); - } - } - free(buf); - return 0; -} - -void -usage(void) -{ - fprint(2, "%s: [file]\n", argv0); - threadexits("usage"); -} - -void -readroot(VtRoot *root, uchar *score, char *file) -{ - int fd; - char *pref; - char buf[VtRootSize]; - int n, nn; - - if(file == 0) - fd = 0; - else { - fd = open(file, OREAD); - if(fd < 0) - sysfatal("could not open file: %s: %r\n", file); - } - n = readn(fd, buf, sizeof(buf)-1); - if(n < 0) - sysfatal("read failed: %r\n"); - if(n==0 || buf[n-1] != '\n') - sysfatal("not a root file"); - buf[n-1] = 0; - close(fd); - - if(vtparsescore(buf, &pref, score) < 0){ - sysfatal("not a root file"); - } - nn = timevtread(z, score, VtRootType, buf, VtRootSize); - if(nn < 0) - sysfatal("cannot read root %V", score); - if(vtrootunpack(root, buf) < 0) - sysfatal("cannot parse root: %r"); -} - -int -timevtread(VtConn *z, uchar *score, int type, void *buf, int nbuf) -{ -/* - ulong t0, t1; - int n; - - t0 = nsec(); - n = vtread(z, score, type, buf, nbuf); - t1 = nsec(); - fprint(2, "read %V: %.6f seconds\n", score, (t1-t0)/1.e9); - return n; -*/ - return vtread(z, score, type, buf, nbuf); -} -- cgit v1.2.3