tmain.c - plan9port - [fork] Plan 9 from user space
HTML git clone git://src.adamsgaard.dk/plan9port
DIR Log
DIR Files
DIR Refs
DIR README
DIR LICENSE
---
tmain.c (26392B)
---
1 /*
2 * 9P to FUSE translator. Acts as FUSE server, 9P client.
3 * Mounts 9P servers via FUSE kernel module.
4 *
5 * There are four procs in this threaded program
6 * (ignoring the one that runs main and then exits).
7 * The first proc reads FUSE requests from /dev/fuse.
8 * It sends the requests over a channel to a second proc,
9 * which serves the requests. Each request runs in a
10 * thread in that second proc. Those threads do write
11 * FUSE replies, which in theory might block, but in practice don't.
12 * The 9P interactions are handled by lib9pclient, which
13 * allocates two more procs, one for reading and one for
14 * writing the 9P connection. Thus the many threads in the
15 * request proc can do 9P interactions without blocking.
16 */
17
18 #define _GNU_SOURCE 1 /* for O_DIRECTORY on Linux */
19 #include "a.h"
20
21 /* GNUisms */
22 #ifndef O_DIRECTORY
23 #define O_DIRECTORY 0
24 #endif
25
26 #ifndef O_LARGEFILE
27 # define O_LARGEFILE 0
28 #endif
29
30 /*
31 * Work around glibc's broken <bits/fcntl.h> which defines
32 * O_LARGEFILE to 0 on 64 bit architectures. But, on those same
33 * architectures, linux _forces_ O_LARGEFILE (which is always
34 * 0100000 in the kernel) at each file open. FUSE is all too
35 * happy to pass the flag onto us, where we'd have no idea what
36 * to do with it if we trusted glibc.
37 *
38 * On ARM however, the O_LARGEFILE is set correctly.
39 */
40
41 #if defined(__linux__) && !defined(__arm__)
42 # undef O_LARGEFILE
43 # define O_LARGEFILE 0100000
44 #endif
45
46 #ifndef O_CLOEXEC
47 # if defined(__linux__)
48 # define O_CLOEXEC 02000000 /* Sigh */
49 # else
50 # define O_CLOEXEC 0
51 # endif
52 #endif
53
54 #ifndef FMODE_EXEC
55 # if defined(__linux__)
56 # define FMODE_EXEC 040
57 # else
58 # define FMODE_EXEC 0
59 # endif
60 #endif
61
62 int debug;
63 char *argv0;
64 char *aname = "";
65 void fusedispatch(void*);
66 Channel *fusechan;
67
68 enum
69 {
70 STACK = 8192
71 };
72
73 /*
74 * The number of seconds that the kernel can cache
75 * returned file attributes. FUSE's default is 1.0.
76 * I haven't experimented with using 0.
77 */
78 double attrtimeout = 1.0;
79
80 /*
81 * The number of seconds that the kernel can cache
82 * the returned entry nodeids returned by lookup.
83 * I haven't experimented with other values.
84 */
85 double entrytimeout = 1.0;
86
87 CFsys *fsys;
88 CFid *fsysroot;
89 void init9p(char*, char*);
90
91 void
92 usage(void)
93 {
94 fprint(2, "usage: 9pfuse [-D] [-A attrtimeout] [-a aname] address mtpt\n");
95 exit(1);
96 }
97
98 void fusereader(void*);
99 void watchfd(void*);
100
101 int
102 threadmaybackground(void)
103 {
104 return 1;
105 }
106
107 void
108 threadmain(int argc, char **argv)
109 {
110 ARGBEGIN{
111 case 'D':
112 chatty9pclient++;
113 debug++;
114 break;
115 case 'A':
116 attrtimeout = atof(EARGF(usage()));
117 break;
118 case 'a':
119 aname = EARGF(usage());
120 break;
121 default:
122 usage();
123 }ARGEND
124
125 if(argc != 2)
126 usage();
127
128 quotefmtinstall();
129 fmtinstall('F', fcallfmt);
130 fmtinstall('M', dirmodefmt);
131 fmtinstall('G', fusefmt);
132
133 setsid(); /* won't be able to use console, but can't be interrupted */
134
135 init9p(argv[0], aname);
136 initfuse(argv[1]);
137
138 fusechan = chancreate(sizeof(void*), 0);
139 proccreate(fusedispatch, nil, STACK);
140 sendp(fusechan, nil); /* sync */
141
142 proccreate(fusereader, nil, STACK);
143 /*
144 * Now that we're serving FUSE, we can wait
145 * for the mount to finish and exit back to the user.
146 */
147 waitfuse();
148 threadexits(0);
149 }
150
151 void
152 fusereader(void *v)
153 {
154 FuseMsg *m;
155
156 while((m = readfusemsg()) != nil)
157 sendp(fusechan, m);
158
159 fusemtpt = nil; /* no need to unmount */
160 threadexitsall(0);
161 }
162
163 void
164 init9p(char *addr, char *spec)
165 {
166 int fd;
167
168 if(strcmp(addr, "-") == 0)
169 fd = 0;
170 else
171 if((fd = dial(netmkaddr(addr, "tcp", "564"), nil, nil, nil)) < 0)
172 sysfatal("dial %s: %r", addr);
173 proccreate(watchfd, (void*)(uintptr)fd, STACK);
174 if((fsys = fsmount(fd, spec)) == nil)
175 sysfatal("fsmount: %r");
176 fsysroot = fsroot(fsys);
177 }
178
179 /*
180 * FUSE uses nodeids to refer to active "struct inodes"
181 * (9P's unopened fids). FUSE uses fhs to refer to active
182 * "struct fuse_files" (9P's opened fids). The choice of
183 * numbers is up to us except that nodeid 1 is the root directory.
184 * We use the same number space for both and call the
185 * bookkeeping structure a FuseFid.
186 *
187 * FUSE requires nodeids to have associated generation
188 * numbers. If we reuse a nodeid, we have to bump the
189 * generation number to guarantee that the nodeid,gen
190 * combination is never reused.
191 *
192 * There are also inode numbers returned in directory reads
193 * and file attributes, but these do NOT need to match the nodeids.
194 * We use a combination of qid.path and qid.type as the inode
195 * number.
196 */
197 /*
198 * TO DO: reference count the fids.
199 */
200 typedef struct Fusefid Fusefid;
201 struct Fusefid
202 {
203 Fusefid *next;
204 CFid *fid;
205 int ref;
206 int id;
207 int gen;
208 int isnodeid;
209
210 /* directory read state */
211 Dir *d0;
212 Dir *d;
213 int nd;
214 int off;
215 };
216
217 Fusefid **fusefid;
218 int nfusefid;
219 Fusefid *freefusefidlist;
220
221 Fusefid*
222 allocfusefid(void)
223 {
224 Fusefid *f;
225
226 if((f = freefusefidlist) == nil){
227 f = emalloc(sizeof *f);
228 fusefid = erealloc(fusefid, (nfusefid+1)*sizeof *fusefid);
229 f->id = nfusefid;
230 fusefid[f->id] = f;
231 nfusefid++;
232 }else
233 freefusefidlist = f->next;
234 f->next = nil;
235 f->ref = 1;
236 f->isnodeid = -1;
237 return f;
238 }
239
240 void
241 freefusefid(Fusefid *f)
242 {
243 if(--f->ref > 0)
244 return;
245 assert(f->ref == 0);
246 if(f->fid)
247 fsclose(f->fid);
248 if(f->d0)
249 free(f->d0);
250 f->off = 0;
251 f->d0 = nil;
252 f->fid = nil;
253 f->d = nil;
254 f->nd = 0;
255 f->next = freefusefidlist;
256 f->isnodeid = -1;
257 freefusefidlist = f;
258 }
259
260 uvlong
261 _alloc(CFid *fid, int isnodeid)
262 {
263 Fusefid *ff;
264
265 ff = allocfusefid();
266 ff->fid = fid;
267 ff->isnodeid = isnodeid;
268 ff->gen++;
269 return ff->id+2; /* skip 0 and 1 */
270 }
271
272 uvlong
273 allocfh(CFid *fid)
274 {
275 return _alloc(fid, 0);
276 }
277
278 uvlong
279 allocnodeid(CFid *fid)
280 {
281 return _alloc(fid, 1);
282 }
283
284 Fusefid*
285 lookupfusefid(uvlong id, int isnodeid)
286 {
287 Fusefid *ff;
288 if(id < 2 || id >= nfusefid+2)
289 return nil;
290 ff = fusefid[(int)id-2];
291 if(ff->isnodeid != isnodeid)
292 return nil;
293 return ff;
294 }
295
296 CFid*
297 _lookupcfid(uvlong id, int isnodeid)
298 {
299 Fusefid *ff;
300
301 if((ff = lookupfusefid(id, isnodeid)) == nil)
302 return nil;
303 return ff->fid;
304 }
305
306 CFid*
307 fh2fid(uvlong fh)
308 {
309 return _lookupcfid(fh, 0);
310 }
311
312 CFid*
313 nodeid2fid(uvlong nodeid)
314 {
315 if(nodeid == 1)
316 return fsysroot;
317 return _lookupcfid(nodeid, 1);
318 }
319
320 uvlong
321 qid2inode(Qid q)
322 {
323 return q.path | ((uvlong)q.type<<56);
324 }
325
326 void
327 dir2attr(Dir *d, struct fuse_attr *attr)
328 {
329 attr->ino = qid2inode(d->qid);
330 attr->size = d->length;
331 attr->blocks = (d->length+8191)/8192;
332 attr->atime = d->atime;
333 attr->mtime = d->mtime;
334 attr->ctime = d->mtime; /* not right */
335 attr->atimensec = 0;
336 attr->mtimensec = 0;
337 attr->ctimensec = 0;
338 attr->mode = d->mode&0777;
339 if(d->mode&DMDIR)
340 attr->mode |= S_IFDIR;
341 else if(d->mode&DMSYMLINK)
342 attr->mode |= S_IFLNK;
343 else
344 attr->mode |= S_IFREG;
345 attr->nlink = 1; /* works for directories! - see FUSE FAQ */
346 attr->uid = getuid();
347 attr->gid = getgid();
348 attr->rdev = 0;
349 }
350
351 void
352 f2timeout(double f, __u64 *s, __u32 *ns)
353 {
354 *s = f;
355 *ns = (f - (int)f)*1e9;
356 }
357
358 void
359 dir2attrout(Dir *d, struct fuse_attr_out *out)
360 {
361 f2timeout(attrtimeout, &out->attr_valid, &out->attr_valid_nsec);
362 dir2attr(d, &out->attr);
363 }
364
365 /*
366 * Lookup. Walk to the name given as the argument.
367 * The response is a fuse_entry_out giving full stat info.
368 */
369 void
370 fuselookup(FuseMsg *m)
371 {
372 char *name;
373 Fusefid *ff;
374 CFid *fid, *newfid;
375 Dir *d;
376 struct fuse_entry_out out;
377
378 name = m->tx;
379 if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
380 replyfuseerrno(m, ESTALE);
381 return;
382 }
383 if(strchr(name, '/')){
384 replyfuseerrno(m, ENOENT);
385 return;
386 }
387 if((newfid = fswalk(fid, name)) == nil){
388 replyfuseerrstr(m);
389 return;
390 }
391 if((d = fsdirfstat(newfid)) == nil){
392 fsclose(newfid);
393 replyfuseerrstr(m);
394 return;
395 }
396 out.nodeid = allocnodeid(newfid);
397 ff = lookupfusefid(out.nodeid, 1);
398 out.generation = ff->gen;
399 f2timeout(attrtimeout, &out.attr_valid, &out.attr_valid_nsec);
400 f2timeout(entrytimeout, &out.entry_valid, &out.entry_valid_nsec);
401 dir2attr(d, &out.attr);
402 free(d);
403 replyfuse(m, &out, sizeof out);
404 }
405
406 /*
407 * Forget. Reference-counted clunk for nodeids.
408 * Does not send a reply.
409 * Each lookup response gives the kernel an additional reference
410 * to the returned nodeid. Forget says "drop this many references
411 * to this nodeid". Our fuselookup, when presented with the same query,
412 * does not return the same results (it allocates a new nodeid for each
413 * call), but if that ever changes, fuseforget already handles the ref
414 * counts properly.
415 */
416 void
417 fuseforget(FuseMsg *m)
418 {
419 struct fuse_forget_in *in;
420 Fusefid *ff;
421
422 in = m->tx;
423 if((ff = lookupfusefid(m->hdr->nodeid, 1)) == nil)
424 return;
425 if(ff->ref > in->nlookup){
426 ff->ref -= in->nlookup;
427 return;
428 }
429 if(ff->ref < in->nlookup)
430 fprint(2, "bad count in forget\n");
431 ff->ref = 1;
432 freefusefid(ff);
433 freefusemsg(m);
434 }
435
436 /*
437 * Getattr.
438 * Replies with a fuse_attr_out structure giving the
439 * attr for the requested nodeid in out.attr.
440 * Out.attr_valid and out.attr_valid_nsec give
441 * the amount of time that the attributes can
442 * be cached.
443 *
444 * Empirically, though, if I run ls -ld on the root
445 * twice back to back, I still get two getattrs,
446 * even with a one second attribute timeout!
447 */
448 void
449 fusegetattr(FuseMsg *m)
450 {
451 CFid *fid;
452 struct fuse_attr_out out;
453 Dir *d;
454
455 if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
456 replyfuseerrno(m, ESTALE);
457 return;
458 }
459 if((d = fsdirfstat(fid)) == nil){
460 replyfuseerrstr(m);
461 return;
462 }
463 memset(&out, 0, sizeof out);
464 dir2attrout(d, &out);
465 free(d);
466 replyfuse(m, &out, sizeof out);
467 }
468
469 /*
470 * Setattr.
471 * FUSE treats the many Unix attribute setting routines
472 * more or less like 9P does, with a single message.
473 */
474 void
475 fusesetattr(FuseMsg *m)
476 {
477 CFid *fid, *nfid;
478 Dir d, *dd;
479 struct fuse_setattr_in *in;
480 struct fuse_attr_out out;
481
482 in = m->tx;
483 if(in->valid&FATTR_FH){
484 if((fid = fh2fid(in->fh)) == nil){
485 replyfuseerrno(m, ESTALE);
486 return;
487 }
488 }else{
489 if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
490 replyfuseerrno(m, ESTALE);
491 return;
492 }
493 /*
494 * Special case: Linux issues a size change to
495 * truncate a file before opening it OTRUNC.
496 * Synthetic file servers (e.g., plumber) honor
497 * open(OTRUNC) but not wstat.
498 */
499 if(in->valid == FATTR_SIZE && in->size == 0){
500 if((nfid = fswalk(fid, nil)) == nil){
501 replyfuseerrstr(m);
502 return;
503 }
504 if(fsfopen(nfid, OWRITE|OTRUNC) < 0){
505 replyfuseerrstr(m);
506 fsclose(nfid);
507 return;
508 }
509 fsclose(nfid);
510 goto stat;
511 }
512 }
513
514 nulldir(&d);
515 if(in->valid&FATTR_SIZE)
516 d.length = in->size;
517 if(in->valid&FATTR_ATIME)
518 d.atime = in->atime;
519 if(in->valid&FATTR_MTIME)
520 d.mtime = in->mtime;
521 if(in->valid&FATTR_MODE)
522 d.mode = in->mode & 0777;
523 if((in->mode&S_IFMT) == S_IFDIR)
524 d.mode |= DMDIR;
525 if((in->valid&FATTR_UID) || (in->valid&FATTR_GID)){
526 /*
527 * I can't be bothered with these yet.
528 */
529 replyfuseerrno(m, EPERM);
530 return;
531 }
532 if(fsdirfwstat(fid, &d) < 0){
533 replyfuseerrstr(m);
534 return;
535 }
536 stat:
537 if((dd = fsdirfstat(fid)) == nil){
538 replyfuseerrstr(m);
539 return;
540 }
541 memset(&out, 0, sizeof out);
542 dir2attrout(dd, &out);
543 free(dd);
544 replyfuse(m, &out, sizeof out);
545 }
546
547 CFid*
548 _fuseopenfid(uvlong nodeid, int isdir, int openmode, int *err)
549 {
550 CFid *fid, *newfid;
551
552 if((fid = nodeid2fid(nodeid)) == nil){
553 *err = ESTALE;
554 return nil;
555 }
556 if(isdir && !(fsqid(fid).type&QTDIR)){
557 *err = ENOTDIR;
558 return nil;
559 }
560 if(openmode != OREAD && fsqid(fid).type&QTDIR){
561 *err = EISDIR;
562 return nil;
563 }
564
565 /* Clone fid to get one we can open. */
566 newfid = fswalk(fid, nil);
567 if(newfid == nil){
568 *err = errstr2errno();
569 return nil;
570 }
571
572 if(fsfopen(newfid, openmode) < 0){
573 *err = errstr2errno();
574 fsclose(newfid);
575 return nil;
576 }
577
578 return newfid;
579 }
580
581 /*
582 * Open & Opendir.
583 * Argument is a struct fuse_open_in.
584 * The mode field is ignored (presumably permission bits)
585 * and flags is the open mode.
586 * Replies with a struct fuse_open_out.
587 */
588 void
589 _fuseopen(FuseMsg *m, int isdir)
590 {
591 struct fuse_open_in *in;
592 struct fuse_open_out out;
593 CFid *fid;
594 int openmode, flags, err;
595
596 in = m->tx;
597 flags = in->flags;
598 openmode = flags&3;
599 flags &= ~3;
600 flags &= ~(O_DIRECTORY|O_NONBLOCK|O_LARGEFILE|O_CLOEXEC|FMODE_EXEC);
601 #ifdef O_NOFOLLOW
602 flags &= ~O_NOFOLLOW;
603 #endif
604 #ifdef O_LARGEFILE
605 flags &= ~O_LARGEFILE;
606 #endif
607
608 /*
609 * Discarding O_APPEND here is not completely wrong,
610 * because the host kernel will rewrite the offsets
611 * of write system calls for us. That's the best we
612 * can do on Unix anyway.
613 */
614 flags &= ~O_APPEND;
615 if(flags & O_TRUNC){
616 openmode |= OTRUNC;
617 flags &= ~O_TRUNC;
618 }
619
620 /*
621 * Could translate but not standard 9P:
622 * O_DIRECT -> ODIRECT
623 * O_NONBLOCK -> ONONBLOCK
624 */
625 if(flags){
626 fprint(2, "unexpected open flags requested=%#uo unhandled=%#uo\n", (uint)in->flags, (uint)flags);
627 replyfuseerrno(m, EACCES);
628 return;
629 }
630 if((fid = _fuseopenfid(m->hdr->nodeid, isdir, openmode, &err)) == nil){
631 replyfuseerrno(m, err);
632 return;
633 }
634 out.fh = allocfh(fid);
635 out.open_flags = FOPEN_DIRECT_IO; /* no page cache */
636 replyfuse(m, &out, sizeof out);
637 }
638
639 void
640 fuseopen(FuseMsg *m)
641 {
642 _fuseopen(m, 0);
643 }
644
645 void
646 fuseopendir(FuseMsg *m)
647 {
648 _fuseopen(m, 1);
649 }
650
651 /*
652 * Create & Mkdir.
653 */
654 CFid*
655 _fusecreate(uvlong nodeid, char *name, int perm, int ismkdir, int omode, struct fuse_entry_out *out, int *err)
656 {
657 CFid *fid, *newfid, *newfid2;
658 Dir *d;
659 Fusefid *ff;
660
661 if((fid = nodeid2fid(nodeid)) == nil){
662 *err = ESTALE;
663 return nil;
664 }
665 perm &= 0777;
666 if(ismkdir)
667 perm |= DMDIR;
668 if(ismkdir && omode != OREAD){
669 *err = EPERM;
670 return nil;
671 }
672 if((newfid = fswalk(fid, nil)) == nil){
673 *err = errstr2errno();
674 return nil;
675 }
676 if(fsfcreate(newfid, name, omode, perm) < 0){
677 *err = errstr2errno();
678 fsclose(newfid);
679 return nil;
680 }
681 if((d = fsdirfstat(newfid)) == nil){
682 *err = errstr2errno();
683 fsfremove(newfid);
684 return nil;
685 }
686 /*
687 * This fid is no good, because it's open.
688 * We need an unopened fid. Sigh.
689 */
690 if((newfid2 = fswalk(fid, name)) == nil){
691 *err = errstr2errno();
692 free(d);
693 fsfremove(newfid);
694 return nil;
695 }
696 out->nodeid = allocnodeid(newfid2);
697 ff = lookupfusefid(out->nodeid, 1);
698 out->generation = ff->gen;
699 f2timeout(attrtimeout, &out->attr_valid, &out->attr_valid_nsec);
700 f2timeout(entrytimeout, &out->entry_valid, &out->entry_valid_nsec);
701 dir2attr(d, &out->attr);
702 free(d);
703 return newfid;
704 }
705
706 void
707 fusemkdir(FuseMsg *m)
708 {
709 struct fuse_mkdir_in *in;
710 struct fuse_entry_out out;
711 CFid *fid;
712 int err;
713 char *name;
714
715 in = m->tx;
716 name = (char*)(in+1);
717 if((fid = _fusecreate(m->hdr->nodeid, name, in->mode, 1, OREAD, &out, &err)) == nil){
718 replyfuseerrno(m, err);
719 return;
720 }
721 /* Toss the open fid. */
722 fsclose(fid);
723 replyfuse(m, &out, sizeof out);
724 }
725
726 void
727 fusecreate(FuseMsg *m)
728 {
729 struct fuse_open_in *in;
730 struct fuse_create_out out;
731 CFid *fid;
732 int err, openmode, flags;
733 char *name;
734
735 in = m->tx;
736 flags = in->flags;
737 openmode = in->flags&3;
738 flags &= ~3;
739 flags &= ~(O_DIRECTORY|O_NONBLOCK|O_LARGEFILE|O_EXCL);
740 flags &= ~O_APPEND; /* see comment in _fuseopen */
741 flags &= ~(O_CREAT|O_TRUNC); /* huh? */
742 if(flags){
743 fprint(2, "bad mode %#uo\n", in->flags);
744 replyfuseerrno(m, EACCES);
745 return;
746 }
747 name = (char*)(in+1);
748 if((fid = _fusecreate(m->hdr->nodeid, name, in->mode, 0, openmode, &out.e, &err)) == nil){
749 replyfuseerrno(m, err);
750 return;
751 }
752 out.o.fh = allocfh(fid);
753 out.o.open_flags = FOPEN_DIRECT_IO; /* no page cache */
754 replyfuse(m, &out, sizeof out);
755 }
756
757 /*
758 * Access.
759 * Lib9pclient implements this just as Plan 9 does,
760 * by opening the file (or not) and then closing it.
761 */
762 void
763 fuseaccess(FuseMsg *m)
764 {
765 struct fuse_access_in *in;
766 CFid *fid;
767 int err, omode;
768 static int a2o[] = {
769 0,
770 OEXEC,
771 OWRITE,
772 ORDWR,
773 OREAD,
774 OEXEC,
775 ORDWR,
776 ORDWR
777 };
778
779 in = m->tx;
780 if(in->mask >= nelem(a2o)){
781 replyfuseerrno(m, EINVAL);
782 return;
783 }
784 omode = a2o[in->mask];
785 if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
786 replyfuseerrno(m, ESTALE);
787 return;
788 }
789 if(fsqid(fid).type&QTDIR)
790 omode = OREAD;
791 if((fid = _fuseopenfid(m->hdr->nodeid, 0, omode, &err)) == nil){
792 replyfuseerrno(m, err);
793 return;
794 }
795 fsclose(fid);
796 replyfuse(m, nil, 0);
797 }
798
799 /*
800 * Release.
801 * Equivalent of clunk for file handles.
802 * in->flags is the open mode used in Open or Opendir.
803 */
804 void
805 fuserelease(FuseMsg *m)
806 {
807 struct fuse_release_in *in;
808 Fusefid *ff;
809
810 in = m->tx;
811 if((ff = lookupfusefid(in->fh, 0)) != nil)
812 freefusefid(ff);
813 else
814 fprint(2, "fuserelease: fh not found\n");
815 replyfuse(m, nil, 0);
816 }
817
818 void
819 fusereleasedir(FuseMsg *m)
820 {
821 fuserelease(m);
822 }
823
824 /*
825 * Read.
826 * Read from file handle in->fh at offset in->offset for size in->size.
827 * We truncate size to maxwrite just to keep the buffer reasonable.
828 */
829 void
830 fuseread(FuseMsg *m)
831 {
832 int n;
833 uchar *buf;
834 CFid *fid;
835 struct fuse_read_in *in;
836
837 in = m->tx;
838 if((fid = fh2fid(in->fh)) == nil){
839 replyfuseerrno(m, ESTALE);
840 return;
841 }
842 n = in->size;
843 if(n > fusemaxwrite)
844 n = fusemaxwrite;
845 buf = emalloc(n);
846 n = fspread(fid, buf, n, in->offset);
847 if(n < 0){
848 free(buf);
849 replyfuseerrstr(m);
850 return;
851 }
852 replyfuse(m, buf, n);
853 free(buf);
854 }
855
856 /*
857 * Readlink.
858 */
859 void
860 fusereadlink(FuseMsg *m)
861 {
862 Dir *d;
863 CFid *fid;
864
865 if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
866 replyfuseerrno(m, ESTALE);
867 return;
868 }
869 if((d = fsdirfstat(fid)) == nil){
870 replyfuseerrstr(m);
871 return;
872 }
873 if(!(d->mode&DMSYMLINK)){
874 replyfuseerrno(m, EINVAL);
875 return;
876 }
877 replyfuse(m, d->ext, strlen(d->ext));
878 free(d);
879 return;
880 }
881
882 /*
883 * Readdir.
884 * Read from file handle in->fh at offset in->offset for size in->size.
885 * We truncate size to maxwrite just to keep the buffer reasonable.
886 * We assume 9P directory read semantics: a read at offset 0 rewinds
887 * and a read at any other offset starts where we left off.
888 * If it became necessary, we could implement a crude seek
889 * or cache the entire list of directory entries.
890 * Directory entries read from 9P but not yet handed to FUSE
891 * are stored in m->d,nd,d0.
892 */
893 int canpack(Dir*, uvlong, uchar**, uchar*);
894 Dir *dotdir(CFid*);
895 void
896 fusereaddir(FuseMsg *m)
897 {
898 struct fuse_read_in *in;
899 uchar *buf, *p, *ep;
900 int n;
901 Fusefid *ff;
902
903 in = m->tx;
904 if((ff = lookupfusefid(in->fh, 0)) == nil){
905 replyfuseerrno(m, ESTALE);
906 return;
907 }
908 if(in->offset == 0){
909 fsseek(ff->fid, 0, 0);
910 free(ff->d0);
911 ff->d0 = ff->d = dotdir(ff->fid);
912 ff->nd = 1;
913 }
914 n = in->size;
915 if(n > fusemaxwrite)
916 n = fusemaxwrite;
917 buf = emalloc(n);
918 p = buf;
919 ep = buf + n;
920 for(;;){
921 while(ff->nd > 0){
922 if(!canpack(ff->d, ff->off, &p, ep))
923 goto out;
924 ff->off++;
925 ff->d++;
926 ff->nd--;
927 }
928 free(ff->d0);
929 ff->d0 = nil;
930 ff->d = nil;
931 if((ff->nd = fsdirread(ff->fid, &ff->d0)) < 0){
932 replyfuseerrstr(m);
933 free(buf);
934 return;
935 }
936 if(ff->nd == 0)
937 break;
938 ff->d = ff->d0;
939 }
940 out:
941 replyfuse(m, buf, p - buf);
942 free(buf);
943 }
944
945 /*
946 * Fuse assumes that it can always read two directory entries.
947 * If it gets just one, it will double it in the dirread results.
948 * Thus if a directory contains just "a", you see "a" twice.
949 * Adding . as the first directory entry works around this.
950 * We could add .. too, but it isn't necessary.
951 */
952 Dir*
953 dotdir(CFid *f)
954 {
955 Dir *d;
956
957 d = emalloc(1*sizeof *d);
958 d[0].name = ".";
959 d[0].qid = fsqid(f);
960 return d;
961 }
962
963 int
964 canpack(Dir *d, uvlong off, uchar **pp, uchar *ep)
965 {
966 uchar *p;
967 struct fuse_dirent *de;
968 int pad, size;
969
970 p = *pp;
971 size = FUSE_NAME_OFFSET + strlen(d->name);
972 pad = 0;
973 if(size%8)
974 pad = 8 - size%8;
975 if(size+pad > ep - p)
976 return 0;
977 de = (struct fuse_dirent*)p;
978 de->ino = qid2inode(d->qid);
979 de->off = off;
980 de->namelen = strlen(d->name);
981 memmove(de->name, d->name, de->namelen);
982 if(pad > 0)
983 memset(de->name+de->namelen, 0, pad);
984 *pp = p+size+pad;
985 return 1;
986 }
987
988 /*
989 * Write.
990 * Write from file handle in->fh at offset in->offset for size in->size.
991 * Don't know what in->write_flags means.
992 *
993 * Apparently implementations are allowed to buffer these writes
994 * and wait until Flush is sent, but FUSE docs say flush may be
995 * called zero, one, or even more times per close. So better do the
996 * actual writing here. Also, errors that happen during Flush just
997 * show up in the close() return status, which no one checks anyway.
998 */
999 void
1000 fusewrite(FuseMsg *m)
1001 {
1002 struct fuse_write_in *in;
1003 struct fuse_write_out out;
1004 void *a;
1005 CFid *fid;
1006 int n;
1007
1008 in = m->tx;
1009 a = in+1;
1010 if((fid = fh2fid(in->fh)) == nil){
1011 replyfuseerrno(m, ESTALE);
1012 return;
1013 }
1014 if(in->size > fusemaxwrite){
1015 replyfuseerrno(m, EINVAL);
1016 return;
1017 }
1018 n = fspwrite(fid, a, in->size, in->offset);
1019 if(n < 0){
1020 replyfuseerrstr(m);
1021 return;
1022 }
1023 out.size = n;
1024 replyfuse(m, &out, sizeof out);
1025 }
1026
1027 /*
1028 * Flush. Supposed to flush any buffered writes. Don't use this.
1029 *
1030 * Flush is a total crock. It gets called on close() of a file descriptor
1031 * associated with this open file. Some open files have multiple file
1032 * descriptors and thus multiple closes of those file descriptors.
1033 * In those cases, Flush is called multiple times. Some open files
1034 * have file descriptors that are closed on process exit instead of
1035 * closed explicitly. For those files, Flush is never called.
1036 * Even more amusing, Flush gets called before close() of read-only
1037 * file descriptors too!
1038 *
1039 * This is just a bad idea.
1040 */
1041 void
1042 fuseflush(FuseMsg *m)
1043 {
1044 replyfuse(m, nil, 0);
1045 }
1046
1047 /*
1048 * Unlink & Rmdir.
1049 */
1050 void
1051 _fuseremove(FuseMsg *m, int isdir)
1052 {
1053 char *name;
1054 CFid *fid, *newfid;
1055
1056 name = m->tx;
1057 if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
1058 replyfuseerrno(m, ESTALE);
1059 return;
1060 }
1061 if(strchr(name, '/')){
1062 replyfuseerrno(m, ENOENT);
1063 return;
1064 }
1065 if((newfid = fswalk(fid, name)) == nil){
1066 replyfuseerrstr(m);
1067 return;
1068 }
1069 if(isdir && !(fsqid(newfid).type&QTDIR)){
1070 replyfuseerrno(m, ENOTDIR);
1071 fsclose(newfid);
1072 return;
1073 }
1074 if(!isdir && (fsqid(newfid).type&QTDIR)){
1075 replyfuseerrno(m, EISDIR);
1076 fsclose(newfid);
1077 return;
1078 }
1079 if(fsfremove(newfid) < 0){
1080 replyfuseerrstr(m);
1081 return;
1082 }
1083 replyfuse(m, nil, 0);
1084 }
1085
1086 void
1087 fuseunlink(FuseMsg *m)
1088 {
1089 _fuseremove(m, 0);
1090 }
1091
1092 void
1093 fusermdir(FuseMsg *m)
1094 {
1095 _fuseremove(m, 1);
1096 }
1097
1098 /*
1099 * Rename.
1100 *
1101 * FUSE sends the nodeid for the source and destination
1102 * directory and then the before and after names as strings.
1103 * 9P can only do the rename if the source and destination
1104 * are the same. If the same nodeid is used for source and
1105 * destination, we're fine, but if FUSE gives us different nodeids
1106 * that happen to correspond to the same directory, we have
1107 * no way of figuring that out. Let's hope it doesn't happen too often.
1108 */
1109 void
1110 fuserename(FuseMsg *m)
1111 {
1112 struct fuse_rename_in *in;
1113 char *before, *after;
1114 CFid *fid, *newfid;
1115 Dir d;
1116
1117 in = m->tx;
1118 if(in->newdir != m->hdr->nodeid){
1119 replyfuseerrno(m, EXDEV);
1120 return;
1121 }
1122 before = (char*)(in+1);
1123 after = before + strlen(before) + 1;
1124 if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
1125 replyfuseerrno(m, ESTALE);
1126 return;
1127 }
1128 if(strchr(before, '/') || strchr(after, '/')){
1129 replyfuseerrno(m, ENOENT);
1130 return;
1131 }
1132 if((newfid = fswalk(fid, before)) == nil){
1133 replyfuseerrstr(m);
1134 return;
1135 }
1136 nulldir(&d);
1137 d.name = after;
1138 if(fsdirfwstat(newfid, &d) < 0){
1139 replyfuseerrstr(m);
1140 fsclose(newfid);
1141 return;
1142 }
1143 fsclose(newfid);
1144 replyfuse(m, nil, 0);
1145 }
1146
1147 /*
1148 * Fsync. Commit file info to stable storage.
1149 * Not sure what in->fsync_flags are.
1150 */
1151 void
1152 fusefsync(FuseMsg *m)
1153 {
1154 struct fuse_fsync_in *in;
1155 CFid *fid;
1156 Dir d;
1157
1158 in = m->tx;
1159 if((fid = fh2fid(in->fh)) == nil){
1160 replyfuseerrno(m, ESTALE);
1161 return;
1162 }
1163 nulldir(&d);
1164 if(fsdirfwstat(fid, &d) < 0){
1165 replyfuseerrstr(m);
1166 return;
1167 }
1168 replyfuse(m, nil, 0);
1169 }
1170
1171 /*
1172 * Fsyncdir. Commit dir info to stable storage?
1173 */
1174 void
1175 fusefsyncdir(FuseMsg *m)
1176 {
1177 fusefsync(m);
1178 }
1179
1180 /*
1181 * Statfs. Send back information about file system.
1182 * Not really worth implementing, except that if we
1183 * reply with ENOSYS, programs like df print messages like
1184 * df: `/tmp/z': Function not implemented
1185 * and that gets annoying. Returning all zeros excludes
1186 * us from df without appearing to cause any problems.
1187 */
1188 void
1189 fusestatfs(FuseMsg *m)
1190 {
1191 struct fuse_statfs_out out;
1192
1193 memset(&out, 0, sizeof out);
1194 replyfuse(m, &out, sizeof out);
1195 }
1196
1197 void (*fusehandlers[100])(FuseMsg*);
1198
1199 struct {
1200 int op;
1201 void (*fn)(FuseMsg*);
1202 } fuselist[] = {
1203 { FUSE_LOOKUP, fuselookup },
1204 { FUSE_FORGET, fuseforget },
1205 { FUSE_GETATTR, fusegetattr },
1206 { FUSE_SETATTR, fusesetattr },
1207 /*
1208 * FUSE_SYMLINK, FUSE_MKNOD are unimplemented.
1209 */
1210 { FUSE_READLINK, fusereadlink },
1211 { FUSE_MKDIR, fusemkdir },
1212 { FUSE_UNLINK, fuseunlink },
1213 { FUSE_RMDIR, fusermdir },
1214 { FUSE_RENAME, fuserename },
1215 /*
1216 * FUSE_LINK is unimplemented.
1217 */
1218 { FUSE_OPEN, fuseopen },
1219 { FUSE_READ, fuseread },
1220 { FUSE_WRITE, fusewrite },
1221 { FUSE_STATFS, fusestatfs },
1222 { FUSE_RELEASE, fuserelease },
1223 { FUSE_FSYNC, fusefsync },
1224 /*
1225 * FUSE_SETXATTR, FUSE_GETXATTR, FUSE_LISTXATTR, and
1226 * FUSE_REMOVEXATTR are unimplemented.
1227 * FUSE will stop sending these requests after getting
1228 * an -ENOSYS reply (see dispatch below).
1229 */
1230 { FUSE_FLUSH, fuseflush },
1231 /*
1232 * FUSE_INIT is handled in initfuse and should not be seen again.
1233 */
1234 { FUSE_OPENDIR, fuseopendir },
1235 { FUSE_READDIR, fusereaddir },
1236 { FUSE_RELEASEDIR, fusereleasedir },
1237 { FUSE_FSYNCDIR, fusefsyncdir },
1238 { FUSE_ACCESS, fuseaccess },
1239 { FUSE_CREATE, fusecreate },
1240 };
1241
1242 void
1243 fusethread(void *v)
1244 {
1245 FuseMsg *m;
1246
1247 m = v;
1248 if((uint)m->hdr->opcode >= nelem(fusehandlers)
1249 || !fusehandlers[m->hdr->opcode]){
1250 replyfuseerrno(m, ENOSYS);
1251 return;
1252 }
1253 fusehandlers[m->hdr->opcode](m);
1254 }
1255
1256 void
1257 fusedispatch(void *v)
1258 {
1259 int i;
1260 FuseMsg *m;
1261
1262 eofkill9pclient = 1; /* threadexitsall on 9P eof */
1263 atexit(unmountatexit);
1264
1265 recvp(fusechan); /* sync */
1266
1267 for(i=0; i<nelem(fuselist); i++){
1268 if(fuselist[i].op >= nelem(fusehandlers))
1269 sysfatal("make fusehandlers bigger op=%d", fuselist[i].op);
1270 fusehandlers[fuselist[i].op] = fuselist[i].fn;
1271 }
1272
1273 while((m = recvp(fusechan)) != nil) {
1274 switch(m->hdr->opcode) {
1275 case FUSE_FORGET:
1276 fusehandlers[m->hdr->opcode](m);
1277 break;
1278 default:
1279 threadcreate(fusethread, m, STACK);
1280 }
1281 }
1282 }
1283
1284 void*
1285 emalloc(uint n)
1286 {
1287 void *p;
1288
1289 p = malloc(n);
1290 if(p == nil)
1291 sysfatal("malloc(%d): %r", n);
1292 memset(p, 0, n);
1293 return p;
1294 }
1295
1296 void*
1297 erealloc(void *p, uint n)
1298 {
1299 p = realloc(p, n);
1300 if(p == nil)
1301 sysfatal("realloc(..., %d): %r", n);
1302 return p;
1303 }
1304
1305 char*
1306 estrdup(char *p)
1307 {
1308 char *pp;
1309 pp = strdup(p);
1310 if(pp == nil)
1311 sysfatal("strdup(%.20s): %r", p);
1312 return pp;
1313 }
1314
1315 void
1316 watchfd(void *v)
1317 {
1318 int fd = (int)(uintptr)v;
1319
1320 /* wait for exception (file closed) */
1321 fd_set set;
1322 FD_ZERO(&set);
1323 FD_SET(fd, &set);
1324 if(select(fd+1, NULL, NULL, &set, NULL) >= 0)
1325 threadexitsall(nil);
1326 return;
1327 }