8 typedef struct Args Args;
15 typedef struct Dfile Dfile;
16 typedef struct Fid Fid;
17 typedef struct File File;
19 typedef struct Request Request;
20 typedef struct Symbol Symbol;
21 typedef struct Tardir Tardir;
23 extern int threadrforkflag = RFNAMEG;
26 Nstat = 1024, /* plenty for this application */
27 MAXSIZE = 8192+IOHDRSZ,
30 int messagesize = MAXSIZE;
38 write(2, "depend: ", 8);
40 vseprint(buf, buf+1024, fmt, arg);
42 write(2, buf, strlen(buf));
55 Symbol *next; /* hash list chaining */
57 int fno; /* file symbol is defined in */
67 uchar *refvec; /* files resolving the references */
68 uint len; /* length of file */
69 uint tarlen; /* length of tar file */
81 int use; /* use count */
82 int old; /* true if this is an superceded dfile */
84 File *file; /* files */
85 int nfile; /* number of files */
86 int flen; /* length of file table */
88 Symbol **dhash; /* hash table of symbols */
89 int hlen; /* length of hash table */
91 Dfile *next; /* hash chain */
92 char *path; /* path name of dependency file */
93 Qid qid; /* qid of the dependency file */
124 Tblocksize= 512, /* tar block size */
125 Tnamesize= 100, /* tar name size */
130 char name[Tnamesize];
138 char linkname[Tnamesize];
145 int fd; /* to kernel mount point */
160 extern void fsrun(void*);
161 extern Fid* fsgetfid(Fs*, int);
162 extern void fsputfid(Fs*, Fid*);
163 extern void fsreply(Fs*, Request*, char*);
164 extern void fsversion(Fs*, Request*, Fid*);
165 extern void fsauth(Fs*, Request*, Fid*);
166 extern void fsflush(Fs*, Request*, Fid*);
167 extern void fsattach(Fs*, Request*, Fid*);
168 extern void fswalk(Fs*, Request*, Fid*);
169 extern void fsopen(Fs*, Request*, Fid*);
170 extern void fscreate(Fs*, Request*, Fid*);
171 extern void fsread(Fs*, Request*, Fid*);
172 extern void fswrite(Fs*, Request*, Fid*);
173 extern void fsclunk(Fs*, Request*, Fid*);
174 extern void fsremove(Fs*, Request*, Fid*);
175 extern void fsstat(Fs*, Request*, Fid*);
176 extern void fswstat(Fs*, Request*, Fid*);
178 void (*fcall[])(Fs*, Request*, Fid*) =
181 [Tversion] fsversion,
195 char Eperm[] = "permission denied";
196 char Eexist[] = "file does not exist";
197 char Enotdir[] = "not a directory";
198 char Eisopen[] = "file already open";
199 char Enofid[] = "no such fid";
200 char mallocerr[] = "malloc: %r";
201 char Etoolong[] = "name too long";
203 char *dependlog = "depend";
206 Dfile *dfhash[Ndfhash]; /* dependency file hash */
207 QLock dfhlock[Ndfhash];
210 Request* allocreq(int);
212 void releasedf(Dfile*);
213 Symbol* dfsearch(Dfile*, char*);
214 void dfresolve(Dfile*, int);
215 char* mkpath(char*, char*);
216 int mktar(Dfile*, Symbol*, uchar*, uint, int);
217 void closetar(Dfile*, Symbol*);
232 erealloc(void *ReallocP, int ReallocN)
237 ReallocP = emalloc(ReallocN);
238 else if(!(ReallocP = realloc(ReallocP, ReallocN)))
239 fatal("unable to allocate %d bytes",ReallocN);
250 d = d0 = emalloc(strlen(s)+1);
257 * mount the user interface and start one request processor
276 fmtinstall('F', fcallfmt);
284 fprint(2, "usage: %s [-d] svc-name directory\n", argv0);
287 snprint(service, sizeof service, "#s/%s", argv[0]);
288 if(argv[1][0] != '/')
289 fatal("directory must be rooted");
292 fatal("opening pipe: %r");
294 /* Typically mounted before /srv exists */
295 srv = create(service, OWRITE, 0666);
298 fprint(srv, "%d", pfd[1]);
302 time(nil); /* open fd for time before losing / */
303 if(bind(argv[1], "/", MREPL) == 0)
304 fatal("can't bind %s to /", argv[1]);
306 fs = emalloc(sizeof(Fs));
309 fsarg.root = argv[1];
310 proccreate(fsrun, &fsarg, 16*1024);
311 proccreate(fsrun, &fsarg, 16*1024);
317 threadmain(int argc, char *argv[])
324 proccreate(realmain, &args, 16*1024);
328 mkpath(char *dir, char *file)
333 len = strlen(dir) + 1;
335 len += strlen(file) + 1;
338 sprint(path, "%s/%s", dir, file);
340 sprint(path, "%s", dir);
361 fatal("root %s inaccessible: %r", root);
362 fs->rootqid = d->qid;
366 r = allocreq(messagesize);
368 while((n = read9pmsg(fs->fd, r->buf, messagesize)) == 0)
372 fatal("read9pmsg error: %r");
374 if(convM2S(r->buf, n, &r->f) == 0){
375 fprint(2, "can't convert %ux %ux %ux\n", r->buf[0],
376 r->buf[1], r->buf[2]);
381 f = fsgetfid(fs, r->f.fid);
384 fprint(2, "%F path %llux\n", &r->f, f->qid.path);
388 (*fcall[t])(fs, r, f);
395 * any request that can get queued for a delayed reply
398 allocreq(int bufsize)
402 r = emalloc(sizeof(Request)+bufsize);
408 fsgetfid(Fs *fs, int fid)
413 for(f = fs->hash[fid%Nfidhash]; f; f = f->next){
421 nf = emalloc(sizeof(Fid));
422 nf->next = fs->hash[fid%Nfidhash];
423 fs->hash[fid%Nfidhash] = nf;
432 fsputfid(Fs *fs, Fid *f)
441 for(l = &fs->hash[f->fid%Nfidhash]; nf = *l; l = &nf->next)
451 fsreply(Fs *fs, Request *r, char *err)
461 fprint(2, "%F path %llux\n", &r->f, r->fid->qid.path);
462 n = convS2M(&r->f, buf, messagesize);
464 fatal("bad convS2M");
465 if(write(fs->fd, buf, n) != n)
471 fsversion(Fs *fs, Request *r, Fid*)
473 if(r->f.msize < 256){
474 fsreply(fs, r, "version: bad message size");
477 if(messagesize > r->f.msize)
478 messagesize = r->f.msize;
479 r->f.msize = messagesize;
480 r->f.version = "9P2000";
485 fsauth(Fs *fs, Request *r, Fid*)
487 fsreply(fs, r, "depend: authentication not required");
491 fsflush(Fs*, Request*, Fid*)
496 fsattach(Fs *fs, Request *r, Fid *f)
498 f->qid = fs->rootqid;
499 f->path = strdup("/");
500 f->df = getdf(mkpath(f->path, ".depend"));
502 /* hold down the fid till the clunk */
513 fswalk(Fs *fs, Request *r, Fid *f)
518 char errbuf[ERRMAX], *err;
525 if(f->attached == 0){
526 fsreply(fs, r, Eexist);
530 if(f->fd >= 0 || f->open)
531 fatal("walk of an open file");
534 if(r->f.newfid != r->f.fid){
535 nf = fsgetfid(fs, r->f.newfid);
538 nf->path = strdup(f->path);
548 if(r->f.nwname == 0){
557 path = strdup(f->path);
561 nwname = r->f.nwname;
565 for(; nqid<nwname; nqid++){
566 name = r->f.wname[nqid];
568 if(strcmp(name, ".") == 0){
573 qid[nqid] = qid[nqid-1];
577 if(strcmp(name, "..") == 0){
578 name = strrchr(path, '/');
580 if(name == path) /* at root */
587 errstr(errbuf, sizeof errbuf);
595 lastdf = getdf(mkpath(path, ".depend"));
599 npath = mkpath(path, name);
604 if(d !=nil && (d->qid.type & QTDIR))
608 qid[nqid].type = QTFILE;
612 dp = dfsearch(lastdf, name);
618 if(i > 4 && strcmp(&tmp[i-4], ".tar") == 0){
620 dp = dfsearch(lastdf, tmp);
629 qid[nqid].path = (uvlong)dp;
632 if(nqid == 0 && err == nil)
633 err = "file does not exist";
636 /* for error or partial success, put the cloned fid back*/
637 if(nf!=nil && (err != nil || nqid < nwname)){
644 /* return (possibly short) list of qids */
645 for(i=0; i<nqid; i++)
646 r->f.wqid[i] = qid[i];
649 /* for full success, advance f */
650 if(nqid > 0 && nqid == nwname){
655 f->qid = qid[nqid-1];
656 f->dp = (Symbol*)f->qid.path;
675 fsclone(Fs *fs, Request *r, Fid *f)
679 if(f->attached == 0){
680 fsreply(fs, r, Eexist);
683 nf = fsgetfid(fs, r->f.newfid);
687 nf->path = strdup(f->path);
701 fswalk(Fs *fs, Request *r, Fid *f)
710 if(f->attached == 0){
711 fsreply(fs, r, Enofid);
715 if(f->fd >= 0 || f->open)
716 fatal("walk of an open file");
719 if(strcmp(name, ".") == 0){
723 if(strcmp(name, "..") == 0){
724 name = strrchr(f->path, '/');
732 if(dirstat(f->path, &d) < 0){
735 fsreply(fs, r, errbuf);
738 r->f.qid = f->qid = d.qid;
741 f->df = getdf(mkpath(f->path, ".depend"));
747 path = mkpath(f->path, name);
748 if(dirstat(path, &d) < 0 || (d.qid.path & CHDIR) == 0){
749 dp = dfsearch(f->df, name);
752 if(i > 4 && strcmp(&name[i-4], ".tar") == 0){
754 dp = dfsearch(f->df, name);
758 fsreply(fs, r, Eexist);
763 d.qid.path = (uint)dp;
770 if(d.qid.path & CHDIR){
772 f->df = getdf(mkpath(f->path, ".depend"));
775 r->f.qid = f->qid = d.qid;
780 fsopen(Fs *fs, Request *r, Fid *f)
785 if(f->attached == 0){
786 fsreply(fs, r, Enofid);
790 fsreply(fs, r, Eisopen);
794 mode = r->f.mode & 3;
796 fsreply(fs, r, Eperm);
800 if(f->qid.type & QTDIR){
801 f->fd = open(f->path, OREAD);
803 errstr(errbuf, sizeof errbuf);
804 fsreply(fs, r, errbuf);
815 fscreate(Fs *fs, Request *r, Fid*)
817 fsreply(fs, r, Eperm);
821 fsread(Fs *fs, Request *r, Fid *f)
828 if(f->attached == 0){
829 fsreply(fs, r, Enofid);
832 if((int)r->f.count < 0){
833 fsreply(fs, r, "bad read count");
837 if(f->qid.type & QTDIR){
840 f->ndir = dirreadall(f->fd, &f->dir);
845 if(r->f.offset == 0) /* seeking to zero is permitted */
847 for(; f->dirindex < f->ndir; f->dirindex++){
848 if((f->dir[f->dirindex].qid.type & QTDIR) == 0)
850 len = convD2M(&f->dir[f->dirindex], r->buf+n, r->f.count-n);
856 skip = f->dirindex - f->ndir; /* # depend records already read */
859 for(i = 0; i < f->df->hlen; i++)
860 for(dp = f->df->dhash[i]; dp; dp = dp->next){
863 snprint(buf, sizeof buf, "%s.tar", dp->sym);
869 d.qid.path = (uvlong)dp;
871 d.length = f->df->file[dp->fno].tarlen;
875 len = convD2M(&d, r->buf + n, r->f.count - n);
883 n = mktar(f->df, f->dp, r->buf, r->f.offset, r->f.count);
886 r->f.data = (char*)r->buf;
892 fswrite(Fs *fs, Request *r, Fid*)
894 fsreply(fs, r, Eperm);
898 fsclunk(Fs *fs, Request *r, Fid *f)
900 if(f->attached == 0){
901 fsreply(fs, r, Enofid);
909 if((f->qid.type & QTDIR) == 0)
910 closetar(f->df, f->dp);
922 fsremove(Fs *fs, Request *r, Fid*)
924 fsreply(fs, r, Eperm);
928 fsstat(Fs *fs, Request *r, Fid *f)
934 uchar statbuf[Nstat];
936 if(f->qid.type & QTDIR)
937 n = stat(f->path, statbuf, sizeof statbuf);
945 d.qid.path = (uvlong)dp;
947 d.length = f->df->file[dp->fno].tarlen;
951 n = convD2M(&d, statbuf, sizeof statbuf);
954 errstr(err, sizeof err);
964 fswstat(Fs *fs, Request *r, Fid*)
966 fsreply(fs, r, Eperm);
973 shash(char *str, int len)
979 for(val = str; *val; val++)
980 hash = (hash*13) + *val-'a';
985 * free info about a dependency file
1000 unlock(df); /* we're no longer referenced */
1001 for(i = 0; i < df->nfile; i++)
1002 free(df->file[i].name);
1003 free(df->file[i].refvec);
1007 for(i = 0; i < df->hlen; i++)
1008 for(dp = df->dhash[i]; dp != nil; dp = next){
1020 * crack a dependency file
1023 newsym(char *name, int fno, Symbol **l)
1027 dp = emalloc(sizeof(Symbol));
1028 dp->sym = strdup(name);
1036 awk(Biobuf *b, char **field, int n)
1041 while(line = Brdline(b, '\n')){
1042 line[Blinelen(b)-1] = 0;
1043 while(*line == ' ' || *line == '\t')
1045 for(i = 0; i < n; i++){
1046 if(*line == 0 || *line == '#')
1049 while(*line && *line != ' ' && *line != '\t')
1051 while(*line == ' ' || *line == '\t')
1062 crackdf(Dfile *df, Biobuf *b, uint len, char *dpath)
1067 int n, inc, ok, npath;
1068 Symbol **l, *dp, *next;
1074 df->file = emalloc(df->flen*sizeof(File));
1077 df->hlen = 1 + len/8;
1078 df->dhash = emalloc(df->hlen*sizeof(Symbol*));
1081 while((n = awk(b, field, 3)) > 0){
1088 if(df->flen == df->nfile){
1090 df->file = realloc(df->file, df->flen*sizeof(File));
1093 memset(&df->file[df->nfile], 0, inc*sizeof(File));
1095 f = &df->file[df->nfile++];
1096 f->name = strdup(name);
1098 /* fall through and define as a symbol */
1102 newsym(name, df->nfile-1, &(df->dhash[shash(name, df->hlen)]));
1112 ef = &df->file[df->nfile];
1114 /* stat the files to get sizes */
1115 npath = strlen(dpath);
1116 if(npath+1+1 >= sizeof path)
1118 memmove(path, dpath, npath+1); /* include NUL */
1119 name = strrchr(path, '/') + 1;
1120 for(f = df->file; f < ef; f++){
1121 n = strlen(f->name);
1122 if(npath+1+n+3+1 > sizeof path)
1124 memmove(name, f->name, n+1); /* include NUL */
1125 ok = access(path, AEXIST);
1127 strcpy(name+n, ".Z");
1128 ok = access(path, AEXIST);
1130 strcpy(name+n, ".gz");
1131 ok = access(path, AEXIST);
1136 f->name = strdup(name);
1144 f->mtime = d->mtime;
1154 /* resolve all file references */
1155 for(f = df->file; f < ef; f++)
1156 dfresolve(df, f-df->file);
1158 /* free the referenced symbols, don't need them anymore */
1159 for(f = df->file; f < ef; f++){
1160 f->tarlen += 2*Tblocksize; /* tars trailing 0 blocks */
1161 for(dp = f->ref; dp != nil; dp = next){
1170 * get a cracked dependency file
1181 i = shash(path, Ndfhash);
1185 for(df = *l; df; df = *l){
1186 if(strcmp(path, df->path) == 0)
1193 if(d!=nil && d->qid.type == df->qid.type && d->qid.vers == df->qid.vers && d->qid.vers == df->qid.vers){
1204 fd = open(path, OREAD);
1205 if(d == nil || fd < 0){
1210 df = emalloc(sizeof(*df));
1211 b = emalloc(sizeof(Biobuf));
1213 Binit(b, fd, OREAD);
1216 crackdf(df, b, d->length, path);
1231 * stop using a dependency file. Free it if it is no longer linked in.
1234 releasedf(Dfile *df)
1243 /* remove from hash chain */
1244 i = shash(df->path, Ndfhash);
1250 if(df->old == 0 || df->use > 0){
1255 for(d = *l; d; d = *l){
1265 /* now we know it is unreferenced, remove it */
1270 * search a dependency file for a symbol
1273 dfsearch(Dfile *df, char *name)
1279 for(dp = df->dhash[shash(name, df->hlen)]; dp; dp = dp->next)
1280 if(strcmp(dp->sym, name) == 0)
1286 * resolve a single file into a vector of referenced files and the sum of their
1289 /* set a bit in the referenced file vector */
1291 set(uchar *vec, int fno)
1293 if(vec[fno/8] & (1<<(fno&7)))
1295 vec[fno/8] |= 1<<(fno&7);
1298 /* merge two referenced file vectors */
1300 merge(uchar *vec, uchar *ovec, int nfile)
1302 nfile = (nfile+7)/8;
1307 res(Dfile *df, uchar *vec, int fno)
1315 return 0; /* already set */
1316 if(f->refvec != nil){
1317 merge(vec, f->refvec, df->nfile); /* we've descended here before */
1322 for(rp = f->ref; rp; rp = rp->next){
1323 dp = dfsearch(df, rp->sym);
1326 len += res(df, vec, dp->fno);
1328 return len + Tblocksize + ((f->len + Tblocksize - 1)/Tblocksize)*Tblocksize;
1331 dfresolve(Dfile *df, int fno)
1337 vec = emalloc((df->nfile+7)/8);
1338 f->tarlen = res(df, vec, fno);
1343 * make the tar directory block for a file
1353 p = emalloc(Tblocksize);
1356 strcpy(tp->name, f->name);
1357 sprint(tp->mode, "%6o ", f->mode & 0777);
1358 sprint(tp->uid, "%6o ", 0);
1359 sprint(tp->gid, "%6o ", 0);
1360 sprint(tp->size, "%11o ", f->len);
1361 sprint(tp->mtime, "%11o ", f->mtime);
1363 /* calculate checksum */
1364 memset(tp->chksum, ' ', sizeof(tp->chksum));
1366 ep = p + Tblocksize;
1367 for (cp = p; cp < ep; cp++)
1369 sprint(tp->chksum, "%6o", sum);
1378 getfile(Dfile *df, File *f)
1381 char path[512], *name;
1386 name = strrchr(df->path, '/') + 1;
1387 n = snprint(path, sizeof path, "%.*s/%s", (int)(name-df->path), df->path, f->name);
1388 if(n >= sizeof path - UTFmax){
1389 syslog(0, dependlog, "path name too long: %.20s.../%.20s...", df->path, f->name);
1392 f->fd = open(path, OREAD);
1394 syslog(0, dependlog, "can't open %s: %r", path);
1400 releasefile(File *f)
1417 * return a block of a tar file
1420 mktar(Dfile *df, Symbol *dp, uchar *area, uint offset, int len)
1422 int fd, i, j, n, off;
1427 f = &df->file[dp->fno];
1432 for(i = 0; i < df->nfile && len > 0; i++){
1433 if((vec[i/8] & (1<<(i&7))) == 0)
1437 n = Tblocksize + ((f->len + Tblocksize - 1)/Tblocksize)*Tblocksize;
1443 if(offset < Tblocksize){
1445 if(offset + len > Tblocksize)
1446 j = Tblocksize - offset;
1449 //if(debug)fprint(2, "reading %d bytes dir of %s\n", j, f->name);
1450 memmove(p, buf+offset, j);
1458 off = offset - Tblocksize;
1459 if(off >= 0 && off < f->len){
1460 if(off + len > f->len)
1464 fd = getfile(df, f);
1466 //if(debug)fprint(2, "reading %d bytes from offset %d of %s\n", j, off, f->name);
1467 if(pread(fd, p, j, off) != j)
1468 syslog(0, dependlog, "%r reading %d bytes from offset %d of %s", j, off, f->name);
1478 if(offset + len > n)
1482 //if(debug)fprint(2, "filling %d bytes after %s\n", j, f->name);
1490 /* null blocks at end of tar file */
1491 if(offset < 2*Tblocksize && len > 0){
1492 if(offset + len > 2*Tblocksize)
1493 j = 2*Tblocksize - offset;
1496 //if(debug)fprint(2, "filling %d bytes at end\n", j);
1505 * close the files making up a tar file
1508 closetar(Dfile *df, Symbol *dp)
1514 f = &df->file[dp->fno];
1518 for(i = 0; i < df->nfile; i++){
1519 if((vec[i/8] & (1<<(i&7))) == 0)
1521 closefile(&df->file[i]);