3 * - gc of file systems (not going to do just yet?)
5 * - configure on amsterdam
20 #define trace if(!tracecalls){}else print
22 typedef struct Ipokay Ipokay;
23 typedef struct Config Config;
24 typedef struct Ctree Ctree;
25 typedef struct Cnode Cnode;
31 uchar mask[IPaddrlen];
47 int encryptedhandles = 1;
58 void timerthread(void*);
59 void timerproc(void*);
61 extern void handleunparse(Fsys*, Nfs3Handle*, Nfs3Handle*, int);
62 extern Nfs3Status handleparse(Nfs3Handle*, Fsys**, Nfs3Handle*, int);
64 Nfs3Status logread(Cnode*, u32int, u64int, uchar**, u32int*, u1int*);
65 Nfs3Status refreshdiskread(Cnode*, u32int, u64int, uchar**, u32int*, u1int*);
66 Nfs3Status refreshconfigread(Cnode*, u32int, u64int, uchar**, u32int*, u1int*);
68 int readconfigfile(Config *cp);
69 void setrootfid(void);
70 int ipokay(uchar *ip, ushort port);
72 u64int unittoull(char*);
77 fprint(2, "usage: vnfs [-LLRVr] [-a addr] [-b blocksize] [-c cachesize] configfile\n");
78 threadexitsall("usage");
82 threadmain(int argc, char **argv)
84 fmtinstall('B', sunrpcfmt);
85 fmtinstall('C', suncallfmt);
86 fmtinstall('F', vtfcallfmt);
87 fmtinstall('H', encodefmt);
88 fmtinstall('I', eipfmt);
89 fmtinstall('V', vtscorefmt);
90 sunfmtinstall(&nfs3prog);
91 sunfmtinstall(&nfsmount3prog);
104 encryptedhandles = 0;
107 if(srv->localonly == 0)
110 srv->localparanoia = 1;
123 addr = EARGF(usage());
126 blocksize = unittoull(EARGF(usage()));
129 cachesize = unittoull(EARGF(usage()));
139 if((z = vtdial(nil)) == nil)
140 sysfatal("vtdial: %r");
142 sysfatal("vtconnect: %r");
143 if((vcache = vtcachealloc(z, blocksize, cachesize)) == nil)
144 sysfatal("vtcache: %r");
146 configfile = argv[0];
147 if(readconfigfile(&config) < 0)
148 sysfatal("readConfig: %r");
151 nfschan = chancreate(sizeof(SunMsg*), 0);
152 mountchan = chancreate(sizeof(SunMsg*), 0);
153 timerchan = chancreate(sizeof(void*), 0);
155 if(sunsrvudp(srv, addr) < 0)
156 sysfatal("starting server: %r");
158 sunsrvthreadcreate(srv, nfs3proc, nfschan);
159 sunsrvthreadcreate(srv, mount3proc, mountchan);
160 sunsrvthreadcreate(srv, timerthread, nil);
161 proccreate(timerproc, nil, 32768);
163 sunsrvprog(srv, &nfs3prog, nfschan);
164 sunsrvprog(srv, &nfsmount3prog, mountchan);
169 #define TWID64 ((u64int)~(u64int)0)
179 n = strtoul(s, &es, 0);
180 if(*es == 'k' || *es == 'K'){
183 }else if(*es == 'm' || *es == 'M'){
186 }else if(*es == 'g' || *es == 'G'){
189 }else if(*es == 't' || *es == 'T'){
201 * We store all the state about which file a client is accessing in
202 * the handle, so that we don't have to maintain any per-client state
203 * ourselves. In order to avoid leaking handles or letting clients
204 * create arbitrary handles, we sign and encrypt each handle with
205 * AES using a key selected randomly when the server starts.
206 * Thus, handles cannot be used across sessions.
208 * The decrypted handles begin with the following header:
210 * sessid[8] random session id chosen at start time
211 * len[4] length of handle that follows
213 * If we're pressed for space in the rest of the handle, we could
214 * probably reduce the amount of sessid bytes. Note that the sessid
215 * bytes must be consistent during a run of vnfs, or else some
216 * clients (e.g., Linux 2.4) eventually notice that successive TLookups
217 * return different handles, and they return "Stale NFS file handle"
218 * errors to system calls in response (even though we never sent
221 * Security woes aside, the fact that we have to shove everything
222 * into the handles is quite annoying. We have to encode, in 40 bytes:
224 * - position in the synthesized config tree
225 * - enough of the path to do glob matching
226 * - position in an archived file system image
228 * and the handles need to be stable across changes in the config file
229 * (though not across server restarts since encryption screws
232 * We encode each of the first two as a 10-byte hash that is
233 * the first half of a SHA1 hash.
239 HeaderSize = SessidSize+4,
240 MaxHandleSize = Nfs3MaxHandleSize - HeaderSize
244 uchar sessid[SessidSize];
247 hencrypt(Nfs3Handle *h)
253 * root handle has special encryption - a single 0 byte - so that it
256 if(h->len == root.len && memcmp(h->h, root.h, root.len) == 0){
262 if(!encryptedhandles)
265 if(h->len > MaxHandleSize){
267 fprint(2, "handle too long: %.*lH\n", h->len, h->h);
268 memset(h->h, 'X', Nfs3MaxHandleSize);
269 h->len = Nfs3MaxHandleSize;
274 memmove(p+HeaderSize, p, h->len);
275 memmove(p, sessid, SessidSize);
276 *(u32int*)(p+SessidSize) = h->len;
277 h->len += HeaderSize;
279 if(encryptedhandles){
280 while(h->len < MaxHandleSize)
283 aesCBCencrypt(h->h, MaxHandleSize, &aes);
288 hdecrypt(Nfs3Handle *h)
292 if(h->len == 1 && h->h[0] == 0){ /* single 0 byte is root */
297 if(!encryptedhandles)
300 if(h->len <= HeaderSize)
301 return Nfs3ErrBadHandle;
302 if(encryptedhandles){
303 if(h->len != MaxHandleSize)
304 return Nfs3ErrBadHandle;
306 aesCBCdecrypt(h->h, h->len, &aes);
308 if(memcmp(h->h, sessid, SessidSize) != 0)
309 return Nfs3ErrStale; /* give benefit of doubt */
310 h->len = *(u32int*)(h->h+SessidSize);
311 if(h->len >= MaxHandleSize-HeaderSize)
312 return Nfs3ErrBadHandle;
313 memmove(h->h, h->h+HeaderSize, h->len);
320 uchar key[32], ivec[AESbsize];
323 *(u32int*)sessid = truerand();
324 for(i=0; i<nelem(key); i+=4)
325 *(u32int*)&key[i] = truerand();
326 for(i=0; i<nelem(ivec); i++)
327 ivec[i] = fastrand();
328 setupAESstate(&aesstate, key, sizeof key, ivec);
334 * The main purpose of the configuration file is to define a tree
335 * in which the archived file system images are mounted.
336 * The tree is stored as Entry structures, defined below.
338 * The configuration file also allows one to define shell-like
339 * glob expressions matching paths that are not to be displayed.
340 * The matched files or directories are shown in directory listings
341 * (could suppress these if we cared) but they cannot be opened,
342 * read, or written, and getattr returns zeroed data.
346 /* sizes used in handles; see nfs server below */
348 FsysHandleOffset = CnodeHandleSize
362 char *name; /* path element */
363 Cnode *parent; /* in tree */
364 Cnode *nextsib; /* in tree */
365 Cnode *kidlist; /* in tree */
366 Cnode *nexthash; /* in hash list */
368 Nfs3Status (*read)(Cnode*, u32int, u64int, uchar**, u32int*, u1int*); /* synthesized read fn */
370 uchar handle[VtScoreSize]; /* sha1(path to here) */
371 ulong mtime; /* mtime for this directory entry */
373 /* fsys overlay on this node */
374 Fsys *fsys; /* cache of memory structure */
375 Nfs3Handle fsyshandle;
376 int isblackhole; /* walking down keeps you here */
380 * if a mount point is inside another file system,
381 * the fsys and fsyshandle above have the old fs info,
382 * the mfsys and mfsyshandle below have the new one.
383 * getattrs must use the old info for consistency.
385 int ismtpt; /* whether there is an fsys mounted here */
386 uchar fsysscore[VtScoreSize]; /* score of fsys image on venti */
387 char *fsysimage; /* raw disk image */
388 Fsys *mfsys; /* mounted file system (nil until walked) */
389 Nfs3Handle mfsyshandle; /* handle to root of mounted fsys */
397 return (s[0]<<2)|(s[1]>>6); /* first 10 bits */
401 mkcnode(Ctree *t, Cnode *parent, char *elem, uint elen, char *path, uint plen)
406 n = emalloc(sizeof *n + elen+1);
407 n->name = (char*)(n+1);
408 memmove(n->name, elem, elen);
412 n->nextsib = parent->kidlist;
416 sha1((uchar*)path, plen, n->handle, nil);
417 h = dumbhash(n->handle);
418 n->nexthash = t->hash[h];
430 for(i=0; i<nelem(t->hash); i++)
431 for(n=t->hash[i]; n; n=n->nexthash)
432 if(n->name[0] != '+')
444 for(i=0; i<nelem(t->hash); i++)
445 for(n=t->hash[i]; n; n=n->nexthash){
447 disksync(n->mfsys->disk);
449 disksync(n->fsys->disk);
460 /* just zero all the garbage and leave it linked into the tree */
461 for(i=0; i<nelem(t->hash); i++){
462 for(n=t->hash[i]; n; n=n->nexthash){
468 memset(n->fsysscore, 0, sizeof n->fsysscore);
471 memset(&n->fsyshandle, 0, sizeof n->fsyshandle);
472 memset(&n->mfsyshandle, 0, sizeof n->mfsyshandle);
478 cnodewalk(Cnode *n, char *name, uint len, int markokay)
482 for(nn=n->kidlist; nn; nn=nn->nextsib)
483 if(strncmp(nn->name, name, len) == 0 && nn->name[len] == 0)
484 if(!nn->mark || markokay)
490 ctreewalkpath(Ctree *t, char *name, ulong createmtime)
501 nextp = strchr(p, '/');
504 if((nn = cnodewalk(n, p, nextp-p, 1)) == nil){
507 nn = mkcnode(t, n, p, nextp-p, name, nextp-name);
508 nn->mtime = createmtime;
523 t = emalloc(sizeof *t);
524 t->root = mkcnode(t, nil, "", 0, "", 0);
526 ctreewalkpath(t, "/+log", time(0))->read = logread;
527 ctreewalkpath(t, "/+refreshdisk", time(0))->read = refreshdiskread;
528 ctreewalkpath(t, "/+refreshconfig", time(0))->read = refreshconfigread;
534 ctreemountfsys(Ctree *t, char *path, ulong time, uchar *score, char *file)
540 n = ctreewalkpath(t, path, time);
542 if(n->ismtpt && (n->fsysimage || memcmp(n->fsysscore, score, VtScoreSize) != 0)){
545 n->fsys = nil; /* leak (might be other refs) */
547 memmove(n->fsysscore, score, VtScoreSize);
549 if(n->ismtpt && (n->fsysimage==nil || strcmp(n->fsysimage, file) != 0)){
552 n->fsys = nil; /* leak (might be other refs) */
554 n->fsysimage = emalloc(strlen(file)+1);
555 strcpy(n->fsysimage, file);
562 cnodebyhandle(Ctree *t, uchar *p)
568 for(n=t->hash[h]; n; n=n->nexthash)
569 if(memcmp(n->handle, p, CnodeHandleSize) == 0)
575 parseipandmask(char *s, uchar *ip, uchar *mask)
582 if(parseip(ip, s) == ~0UL)
585 memset(mask, 0xFF, IPaddrlen);
587 if(isdigit((uchar)*p) && strtol(p, &q, 10)>=0 && *q==0)
589 if(parseipmask(mask, p) == ~0UL)
594 /*fprint(2, "parseipandmask %s => %I %I\n", s, ip, mask); */
599 parsetime(char *s, ulong *time)
606 /* decimal integer is seconds since 1970 */
607 x = strtoul(s, &p, 10);
608 if(x > 0 && *p == 0){
613 /* otherwise expect yyyy/mmdd/hhmm */
614 if(strlen(s) != 14 || s[4] != '/' || s[9] != '/')
617 if(!isdigit((uchar)s[i]) || !isdigit((uchar)s[i+5]) || !isdigit((uchar)s[i+10]))
619 memset(&tm, 0, sizeof tm);
620 tm.year = atoi(s)-1900;
621 if(tm.year < 0 || tm.year > 200)
623 tm.mon = (s[5]-'0')*10+s[6]-'0' - 1;
624 if(tm.mon < 0 || tm.mon > 11)
626 tm.mday = (s[7]-'0')*10+s[8]-'0';
627 if(tm.mday < 0 || tm.mday > 31)
629 tm.hour = (s[10]-'0')*10+s[11]-'0';
630 if(tm.hour < 0 || tm.hour > 23)
632 tm.min = (s[12]-'0')*10+s[13]-'0';
633 if(tm.min < 0 || tm.min > 59)
635 strcpy(tm.zone, "XXX"); /* anything but GMT */
637 print("tm2sec %d/%d/%d/%d/%d\n",
638 tm.year, tm.mon, tm.mday, tm.hour, tm.min);
641 if(0) print("time %lud\n", *time);
647 readconfigfile(Config *cp)
649 char *f[10], *image, *p, *pref, *q, *name;
651 uchar scorebuf[VtScoreSize], *score;
659 if((dir = dirstat(name)) == nil)
661 if(c.mtime == dir->mtime){
665 c.mtime = dir->mtime;
667 if((b = Bopen(name, OREAD)) == nil){
673 * Reuse old tree, garbage collecting entries that
674 * are not mentioned in the new config file.
684 for(; (p=Brdstr(b, '\n', 1)) != nil; free(p)){
686 if((q = strchr(p, '#')) != nil)
688 nf = tokenize(p, f, nelem(f));
691 if(strcmp(f[0], "mount") == 0){
693 werrstr("syntax error: mount /path /dev|score mtime");
697 werrstr("unrooted path %s", f[1]);
703 if(access(f[2], AEXIST) < 0){
704 werrstr("image %s does not exist", f[2]);
709 if(vtparsescore(f[2], &pref, scorebuf) < 0){
710 werrstr("bad score %s", f[2]);
715 if(parsetime(f[3], &time) < 0){
716 fprint(2, "%s:%d: bad time %s\n", name, line, f[3]);
719 ctreemountfsys(c.ctree, f[1], time, score, image);
722 if(strcmp(f[0], "allow") == 0 || strcmp(f[0], "deny") == 0){
724 werrstr("syntax error: allow|deny ip[/mask]");
727 c.ok = erealloc(c.ok, (c.nok+1)*sizeof(c.ok[0]));
728 if(parseipandmask(f[1], c.ok[c.nok].ip, c.ok[c.nok].mask) < 0){
729 werrstr("bad ip[/mask]: %s", f[1]);
732 c.ok[c.nok].okay = (strcmp(f[0], "allow") == 0);
736 werrstr("unknown verb '%s'", f[0]);
738 fprint(2, "%s:%d: %r\n", name, line);
749 ipokay(uchar *ip, ushort port)
752 uchar ipx[IPaddrlen];
755 for(i=0; i<config.nok; i++){
757 maskip(ip, ok->mask, ipx);
758 if(0) fprint(2, "%I & %I = %I (== %I?)\n",
759 ip, ok->mask, ipx, ok->ip);
760 if(memcmp(ipx, ok->ip, IPaddrlen) == 0)
763 if(config.nok == 0) /* all is permitted */
765 /* otherwise default is none allowed */
770 cnodelookup(Ctree *t, Cnode **np, char *name)
777 if((nn = cnodewalk(n, name, strlen(name), 0)) == nil){
778 if(n->ismtpt || n->fsys){
779 if((nn = cnodewalk(n, "", 0, 1)) == nil){
780 nn = mkcnode(t, n, "", 0, (char*)n->handle, SHA1dlen);
793 cnodegetattr(Cnode *n, Nfs3Attr *attr)
795 memset(attr, 0, sizeof *attr);
797 attr->type = Nfs3FileReg;
802 attr->type = Nfs3FileDir;
807 attr->fileid = *(u64int*)n->handle;
808 attr->atime.sec = n->mtime;
809 attr->mtime.sec = n->mtime;
810 attr->ctime.sec = n->mtime;
815 cnodereaddir(Cnode *n, u32int count, u64int cookie, uchar **pdata, u32int *pcount, u1int *peof)
817 uchar *data, *p, *ep, *np;
832 data = emalloc(count);
836 if(n->mark || n->name[0] == '+'){
842 ne.namelen = strlen(n->name);
843 ne.cookie = ++cookie;
844 ne.fileid = *(u64int*)n->handle;
845 if(nfs3entrypack(p, ep, &np, &ne) < 0)
870 /* refreshconfig(); */
875 * Actually serve the NFS requests. Called from nfs3srv.c.
876 * Each request runs in its own thread (coroutine).
878 * Decrypted handles have the form:
880 * config[20] - SHA1 hash identifying a config tree node
881 * glob[10] - SHA1 hash prefix identifying a glob state
882 * fsyshandle[<=10] - disk file system handle (usually 4 bytes)
886 * A fid represents a point in the file tree.
887 * There are three components, all derived from the handle:
889 * - config tree position (also used to find fsys)
890 * - glob state for exclusions
891 * - file system position
901 typedef struct Fid Fid;
906 Nfs3Handle fsyshandle;
910 handlecmp(Nfs3Handle *h, Nfs3Handle *h1)
912 if(h->len != h1->len)
913 return h->len - h1->len;
914 return memcmp(h->h, h1->h, h->len);
918 handletofid(Nfs3Handle *eh, Fid *fid, int mode)
925 Nfs3Handle h2, *h, *fh;
927 memset(fid, 0, sizeof *fid);
933 * Not necessary, but speeds up ls -l /dump/2005
934 * HAttr and HAccess must be handled the same way
935 * because both can be used to fetch attributes.
936 * Acting differently yields inconsistencies at mount points,
937 * and causes FreeBSD ls -l to fail.
939 if(mode == HAttr || mode == HAccess)
947 if((ok = hdecrypt(h)) != Nfs3Ok)
949 trace("handletofid: decrypted %.*lH\n", h->len, h->h);
950 if(h->len < FsysHandleOffset)
951 return Nfs3ErrBadHandle;
954 * Find place in config tree.
956 if((n = cnodebyhandle(config.ctree, h->h)) == nil)
960 if(n->ismtpt && domount){
962 * Open fsys for mount point if needed.
965 trace("handletofid: mounting %V/%s\n", n->fsysscore, n->fsysimage);
967 if(strcmp(n->fsysimage, "/dev/null") == 0)
969 if((disk = diskopenfile(n->fsysimage)) == nil){
970 fprint(2, "cannot open disk %s: %r\n", n->fsysimage);
973 if((cdisk = diskcache(disk, blocksize, 64)) == nil){
974 fprint(2, "cannot cache disk %s: %r\n", n->fsysimage);
979 if((disk = diskopenventi(vcache, n->fsysscore)) == nil){
980 fprint(2, "cannot open venti disk %V: %r\n", n->fsysscore);
984 if((fsys = fsysopen(disk)) == nil){
985 fprint(2, "cannot open fsys on %V: %r\n", n->fsysscore);
990 fsysroot(fsys, &n->mfsyshandle);
996 fid->fsys = n->mfsys;
997 fid->fsyshandle = n->mfsyshandle;
1000 * Use fsys handle from tree or from handle.
1001 * This assumes that fsyshandle was set by fidtohandle
1002 * earlier, so it's not okay to reuse handles (except the root)
1003 * across sessions. The encryption above makes and
1004 * enforces the same restriction, so this is okay.
1006 fid->fsys = n->fsys;
1007 fh = &fid->fsyshandle;
1009 fh->len = h->len-FsysHandleOffset;
1010 memmove(fh->h, h->h+FsysHandleOffset, fh->len);
1012 *fh = n->fsyshandle;
1013 trace("handletofid: fsyshandle %.*lH\n", fh->len, fh->h);
1017 * TO DO (maybe): some sort of path restriction here.
1019 trace("handletofid: cnode %s fsys %p fsyshandle %.*lH\n",
1020 n->name, fid->fsys, fid->fsyshandle.len, fid->fsyshandle.h);
1025 _fidtohandle(Fid *fid, Nfs3Handle *h)
1031 * Record fsys handle in n, don't bother sending it to client
1034 n->fsys = fid->fsys;
1035 if(!n->isblackhole){
1036 n->fsyshandle = fid->fsyshandle;
1037 fid->fsyshandle.len = 0;
1039 memmove(h->h, n->handle, CnodeHandleSize);
1040 memmove(h->h+FsysHandleOffset, fid->fsyshandle.h, fid->fsyshandle.len);
1041 h->len = FsysHandleOffset+fid->fsyshandle.len;
1045 fidtohandle(Fid *fid, Nfs3Handle *h)
1047 _fidtohandle(fid, h);
1056 memset(&fid, 0, sizeof fid);
1057 fid.cnode = config.ctree->root;
1058 _fidtohandle(&fid, &root);
1059 fprint(2, "handle %.*lH\n", root.len, root.h);
1063 fsgetroot(Nfs3Handle *h)
1070 fsgetattr(SunAuthUnix *au, Nfs3Handle *h, Nfs3Attr *attr)
1075 trace("getattr %.*lH\n", h->len, h->h);
1076 if((ok = handletofid(h, &fid, HAttr)) != Nfs3Ok)
1079 return fsysgetattr(fid.fsys, au, &fid.fsyshandle, attr);
1081 return cnodegetattr(fid.cnode, attr);
1085 * Lookup is always the hard part.
1088 fslookup(SunAuthUnix *au, Nfs3Handle *h, char *name, Nfs3Handle *nh)
1096 trace("lookup %.*lH %s\n", h->len, h->h, name);
1099 if(strcmp(name, "..") == 0 || strcmp(name, ".") == 0)
1101 if((ok = handletofid(h, &fid, mode)) != Nfs3Ok){
1103 trace("lookup: handletofid %r\n");
1107 if(strcmp(name, ".") == 0){
1108 fidtohandle(&fid, nh);
1113 * Walk down file system and cnode simultaneously.
1114 * If dotdot and file system doesn't move, need to walk
1115 * up cnode. Save the corresponding fsys handles in
1116 * the cnode as we walk down so that we'll have them
1117 * for dotdotting back up.
1122 * Walk down config tree and file system simultaneously.
1124 if((ok = cnodelookup(config.ctree, &n, name)) != Nfs3Ok){
1126 trace("lookup: cnodelookup: %r\n");
1131 if((ok = fsyslookup(fid.fsys, au, &fid.fsyshandle, name, &xh)) != Nfs3Ok){
1133 trace("lookup: fsyslookup: %r\n");
1136 fid.fsyshandle = xh;
1140 * Walking dotdot. Ick.
1142 trace("lookup dotdot fsys=%p\n", fid.fsys);
1145 * Walk up file system, then try up config tree.
1147 if((ok = fsyslookup(fid.fsys, au, &fid.fsyshandle, "..", &xh)) != Nfs3Ok){
1149 trace("lookup fsyslookup: %r\n");
1152 fid.fsyshandle = xh;
1155 * Usually just go to n->parent.
1157 * If we're in a subtree of the mounted file system that
1158 * isn't represented explicitly by the config tree (instead
1159 * the black hole node represents the entire file tree),
1160 * then we only go to n->parent when we've dotdotted back
1161 * to the right handle.
1163 if(n->parent == nil)
1164 trace("lookup dotdot: no parent\n");
1166 trace("lookup dotdot: parent %.*lH, have %.*lH\n",
1167 n->parent->fsyshandle.len, n->parent->fsyshandle.h,
1172 if(handlecmp(&n->parent->mfsyshandle, &xh) == 0)
1180 * No file system, just walk up.
1186 fid.fsyshandle = n->fsyshandle;
1189 fidtohandle(&fid, nh);
1194 fsaccess(SunAuthUnix *au, Nfs3Handle *h, u32int want, u32int *got, Nfs3Attr *attr)
1199 trace("access %.*lH 0x%ux\n", h->len, h->h, want);
1200 if((ok = handletofid(h, &fid, HAccess)) != Nfs3Ok)
1203 return fsysaccess(fid.fsys, au, &fid.fsyshandle, want, got, attr);
1204 *got = want & (Nfs3AccessRead|Nfs3AccessLookup|Nfs3AccessExecute);
1205 return cnodegetattr(fid.cnode, attr);
1209 fsreadlink(SunAuthUnix *au, Nfs3Handle *h, char **link)
1214 trace("readlink %.*lH\n", h->len, h->h);
1215 if((ok = handletofid(h, &fid, HRead)) != Nfs3Ok)
1218 return fsysreadlink(fid.fsys, au, &fid.fsyshandle, link);
1220 return Nfs3ErrNotSupp;
1224 fsreadfile(SunAuthUnix *au, Nfs3Handle *h, u32int count, u64int offset, uchar **data, u32int *pcount, u1int *peof)
1229 trace("readfile %.*lH\n", h->len, h->h);
1230 if((ok = handletofid(h, &fid, HRead)) != Nfs3Ok)
1233 return fid.cnode->read(fid.cnode, count, offset, data, pcount, peof);
1235 return fsysreadfile(fid.fsys, au, &fid.fsyshandle, count, offset, data, pcount, peof);
1236 return Nfs3ErrNotSupp;
1240 fsreaddir(SunAuthUnix *au, Nfs3Handle *h, u32int len, u64int cookie, uchar **pdata, u32int *pcount, u1int *peof)
1245 trace("readdir %.*lH\n", h->len, h->h);
1246 if((ok = handletofid(h, &fid, HRead)) != Nfs3Ok)
1249 return fsysreaddir(fid.fsys, au, &fid.fsyshandle, len, cookie, pdata, pcount, peof);
1250 return cnodereaddir(fid.cnode, len, cookie, pdata, pcount, peof);
1254 logread(Cnode *n, u32int count, u64int offset, uchar **data, u32int *pcount, u1int *peof)
1262 refreshdiskread(Cnode *n, u32int count, u64int offset, uchar **data, u32int *pcount, u1int *peof)
1271 if(refreshdisk() < 0)
1272 snprint(buf, sizeof buf, "refreshdisk: %r\n");
1274 strcpy(buf, "ok\n");
1275 *data = emalloc(strlen(buf));
1276 strcpy((char*)*data, buf);
1277 *pcount = strlen(buf);
1283 refreshconfigread(Cnode *n, u32int count, u64int offset, uchar **data, u32int *pcount, u1int *peof)
1292 if(readconfigfile(&config) < 0)
1293 snprint(buf, sizeof buf, "readconfig: %r\n");
1295 strcpy(buf, "ok\n");
1296 *data = emalloc(strlen(buf));
1297 strcpy((char*)*data, buf);
1298 *pcount = strlen(buf);