fuse4bsd-0.3.9~pre1.20080208/0000755000175000017500000000000011573172317013277 5ustar rmhrmhfuse4bsd-0.3.9~pre1.20080208/Makefile.common0000644000175000017500000000045711151613006016217 0ustar rmhrmh.if defined(DEBUG) DEBUG_FLAGS+= -D_DEBUG -g .endif .if defined(DEBUG2G) DEBUG_FLAGS+= -D_DEBUG2G -g .endif .if defined(DEBUG3G) DEBUG_FLAGS+= -D_DEBUG3G -g .endif .if defined(DEBUG_MSG) DEBUG_FLAGS+= -D_DEBUG_MSG .endif .if defined(F4BVERS) DEBUG_FLAGS+= -DFUSE4BSD_VERSION="\"${F4BVERS}\"" .endif fuse4bsd-0.3.9~pre1.20080208/NEWS0000644000175000017500000000256711151613006013773 0ustar rmhrmhSummary of changes between versions 0.3.0 and 0.3.9-pre1: [the ids in the brackets are Mercurial cset ids] - Code has been split up in a conventional/convenient way [13d8e38653bf] - Blocked I/O and page ops has been rewritten. Now it's not broken and fits more to a non-disk-based fs' needs. [0ef7d580c7c5, d397c387df92, 0ae14278e08a] - Access policies and other stuff has been made compatible to original implementation [70d844d61db0, 0ae14278e08a] - Kernel config can be taken into account [7aae3820b8b8] - Lookup is safer because of eliminating direct parent pointers [79f15dc7be7e] - Device/VFS datatsructures are unified [c4855d4b7637] - Vnode attributes are cached [b85613f18469] - fuse devices poll support [34d79a4a078a] Summary of changes between versions 0.2.20 and 0.3.0-pre1: - Integrated userspace part into FUSE mainline - Added support for Linux style (daemon initiated) mounting - Added support for vnode based I/O (hence enabling writable/shared mmaps and memory disks backed by vnodes under a FUSE mount) - Added support for non-directory root vnodes - Added support for read-only mounting - Implemented two-way access control (by kernel or by userspace) properly (added support for ACCESS message, "default_permissions" mount option) - Added support for atomic create+open (CREATE message) - ... and of course, tons of bugfixes and cleanups fuse4bsd-0.3.9~pre1.20080208/Makefile0000644000175000017500000000013511151613006014721 0ustar rmhrmhSUBDIR = fuse_module mount_fusefs .include fuse4bsd-0.3.9~pre1.20080208/fuse_module/0000755000175000017500000000000011573172317015606 5ustar rmhrmhfuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_dev.c0000644000175000017500000003502011151613006017535 0ustar rmhrmh/* * I/O methods for fuse devices. */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" #include "fuse_session.h" static __inline int fuse_ohead_audit(struct fuse_out_header *ohead, struct uio *uio); static d_open_t fusedev_open; static d_close_t fusedev_close; static d_poll_t fusedev_poll; static d_read_t fusedev_read; static d_write_t fusedev_write; #ifdef USE_OLD_CLONEHANDLER_API void fusedev_clone(void *arg, char *name, int namelen, struct cdev **dev); #else void fusedev_clone(void *arg, struct ucred *cred, char *name, int namelen, struct cdev **dev); #endif static struct cdevsw fuse_cdevsw = { .d_open = fusedev_open, .d_close = fusedev_close, .d_name = "fuse", .d_poll = fusedev_poll, .d_read = fusedev_read, .d_write = fusedev_write, .d_version = D_VERSION, #if ! DO_GIANT_MANUALLY .d_flags = D_NEEDGIANT, #endif }; /* * This struct is not public, but we are eager to use it, * so we have to put its def here. */ struct clonedevs { LIST_HEAD(,cdev) head; }; struct clonedevs *fuseclones; /**************************** * * >>> Fuse device op defs * ****************************/ /* * Resources are set up on a per-open basis */ static int fusedev_open(struct cdev *dev, int oflags, int devtype, struct thread *td) { struct fuse_data *fdata; /* * We need to ensure data consistency on the main entry points * of the module (so that we won't race with module unloading). * I don't see a better way of doing this than using Giant. * The lightest reliance on Giant is realized by the * DO_GIANT_MANUALLY == USE_FUSE_LOCK == 1 combination. * * Then the device will operate D_NEEDGIANT-less, and the only * point where Giant is used (apart from the obligatory places * like module (un)load, (un)mount, etc.) is at the beginning * of the device open routine, where destructive racing is * prevented. */ #if DO_GIANT_MANUALLY mtx_lock(&Giant); #endif if (fuse_useco < 0) { /* Module unload is going on */ #if DO_GIANT_MANUALLY mtx_unlock(&Giant); #endif DEBUG2G("caught in the middle of unload\n"); return (ENOENT); } #if DO_GIANT_MANUALLY && USE_FUSE_LOCK fuse_useco++; mtx_unlock(&Giant); #endif if (dev->si_usecount > 1) goto busy; DEBUG2G("device %p\n", dev); fdata = fdata_alloc(dev, td->td_ucred); FUSE_LOCK; if (fusedev_get_data(dev)) { FUSE_UNLOCK; fdata_destroy(fdata); goto busy; } else { #if ! (DO_GIANT_MANUALLY && USE_FUSE_LOCK) fuse_useco++; #endif fdata->dataflag |= FSESS_OPENED; dev->si_drv1 = fdata; } FUSE_UNLOCK; #if DO_GIANT_MANUALLY && ! USE_FUSE_LOCK mtx_unlock(&Giant); #endif DEBUG("Opened device \"fuse\" (that of minor %d) successfully on thread %d.\n", minor(dev), td->td_tid); return(0); busy: #if DO_GIANT_MANUALLY #if USE_FUSE_LOCK fuse_useco--; #else mtx_unlock(&Giant); #endif #endif return (EBUSY); } static int fusedev_close(struct cdev *dev, int fflag, int devtype, struct thread *td) { struct fuse_data *data; #if DO_GIANT_MANUALLY && ! USE_FUSE_LOCK mtx_lock(&Giant); #endif FUSE_LOCK; data = fusedev_get_data(dev); if (! data) panic("no fuse data upon fuse device close"); KASSERT(data->dataflag | FSESS_OPENED, ("fuse device is already closed upon close")); fdata_kick_set(data); data->dataflag &= ~FSESS_OPENED; mtx_lock(&data->aw_mtx); /* wakup poll()ers */ selwakeuppri(&data->ks_rsel, PZERO + 1); DEBUG2G("mntco %d\n", data->mntco); if (data->mntco > 0) { struct fuse_ticket *tick; /* Don't let syscall handlers wait in vain */ while ((tick = fuse_aw_pop(data))) { mtx_lock(&tick->tk_aw_mtx); fticket_set_answered(tick); tick->tk_aw_errno = ENOTCONN; wakeup(tick); mtx_unlock(&tick->tk_aw_mtx); } mtx_unlock(&data->aw_mtx); FUSE_UNLOCK; goto out; } dev->si_drv1 = NULL; FUSE_UNLOCK; fdata_destroy(data); out: #if DO_GIANT_MANUALLY && ! USE_FUSE_LOCK mtx_unlock(&Giant); #endif fuse_useco--; DEBUG("Closing device \"fuse\" (that of minor %d) on thread %d.\n", minor(dev), td->td_tid); return(0); } int fusedev_poll(struct cdev *dev, int events, struct thread *td) { struct fuse_data *data; int revents = 0; data = fusedev_get_data(dev); if (events & (POLLIN | POLLRDNORM)) { mtx_lock(&data->ms_mtx); if (fdata_kick_get(data) || STAILQ_FIRST(&data->ms_head)) revents |= events & (POLLIN | POLLRDNORM); else selrecord(td, &data->ks_rsel); mtx_unlock(&data->ms_mtx); } if (events & (POLLOUT | POLLWRNORM)) { revents |= events & (POLLOUT | POLLWRNORM); } return (revents); } /* * fusedev_read hangs on the queue of VFS messages. * When it's notified that there is a new one, it picks that and * passes up to the daemon */ int fusedev_read(struct cdev *dev, struct uio *uio, int ioflag) { int err = 0; struct fuse_data *data; struct fuse_ticket *tick; void *buf[] = { NULL, NULL, NULL }; int buflen[3]; int i; data = fusedev_get_data(dev); DEBUG_MSG("fuse device being read on thread %d\n", uio->uio_td->td_tid); mtx_lock(&data->ms_mtx); again: if (fdata_kick_get(data)) { DEBUG2G("we know early on that reader should be kicked so we don't wait for news\n"); mtx_unlock(&data->ms_mtx); return (ENODEV); } if ( ! (tick = fuse_ms_pop(data))) { /* check if we may block */ if (ioflag & O_NONBLOCK) { /* get outa here soon */ mtx_unlock(&data->ms_mtx); return (EAGAIN); } else { err = msleep(data, &data->ms_mtx, PCATCH, "fu_msg", 0); if (err != 0) { mtx_unlock(&data->ms_mtx); return (fdata_kick_get(data) ? ENODEV : err); } tick = fuse_ms_pop(data); } } if (! tick) { /* * We can get here if fuse daemon suddenly terminates, * eg, by being hit by a SIGKILL * -- and some other cases, too, tho not totally clear, when * (cv_signal/wakeup_one signals the whole process ?) */ DEBUG("no message on thread #%d\n", uio->uio_td->td_tid); goto again; } mtx_unlock(&data->ms_mtx); if (fdata_kick_get(data)) { /* * somebody somewhere -- eg., umount routine -- * wants this liaison finished off */ DEBUG2G("reader is to be sacked\n"); if (tick) { DEBUG2G("weird -- \"kick\" is set tho there is message\n"); fuse_ticket_drop_notowned(tick); } return (ENODEV); /* This should make the daemon get off of us */ } DEBUG("message got on thread #%d\n", uio->uio_td->td_tid); KASSERT(tick->tk_ms_bufdata || tick->tk_ms_bufsize == 0, ("non-null buf pointer with positive size")); switch (tick->tk_ms_type) { case FT_M_FIOV: buf[0] = tick->tk_ms_fiov.base; buflen[0] = tick->tk_ms_fiov.len; break; case FT_M_BUF: buf[0] = tick->tk_ms_fiov.base; buflen[0] = tick->tk_ms_fiov.len; buf[1] = tick->tk_ms_bufdata; buflen[1] = tick->tk_ms_bufsize; break; default: panic("unknown message type for fuse_ticket %p", tick); } for (i = 0; buf[i]; i++) { /* * Why not ban mercilessly stupid daemons who can't keep up * with us? (There is no much use of a partial read here...) */ /* * XXX note that in such cases Linux FUSE throws EIO at the * syscall invoker and stands back to the message queue. The * rationale should be made clear (and possibly adopt that * behaviour). Keeping the current scheme at least makes * fallacy as loud as possible... */ if (uio->uio_resid < buflen[i]) { fdata_kick_set(data); DEBUG2G("daemon is stupid, kick it off...\n"); err = ENODEV; break; } err = uiomove(buf[i], buflen[i], uio); if (err) break; } /* * fusedev_read will drop "not owned" tickets * (used when the one who inserted the message thinks the daemon * won't aswer) */ fuse_ticket_drop_notowned(tick); return (err); } static __inline int fuse_ohead_audit(struct fuse_out_header *ohead, struct uio *uio) { DEBUG_MSG("Out header -- len: %i, error: %i, unique: %llu; iovecs: %d\n", ohead->len, ohead->error, (unsigned long long)ohead->unique, uio->uio_iovcnt); if (uio->uio_resid + sizeof(struct fuse_out_header) != ohead->len) { DEBUG_MSG("Format error: body size differs from size claimed by header\n"); return (EINVAL); } if (uio->uio_resid && ohead->error) { DEBUG_MSG("Format error: non zero error but message had a body\n"); return (EINVAL); } /* Sanitize the linuxism of negative errnos */ ohead->error = -(ohead->error); return (0); } /* * fusedev_write first reads the header sent by the daemon. * If that's OK, looks up ticket/callback node by the unique id seen in header. * If the callback node contains a handler function, the uio is passed over * that. */ static int fusedev_write(struct cdev *dev, struct uio *uio, int ioflag) { #if _DEBUG_MSG static int counter=0; #endif struct fuse_out_header ohead; int err = 0; struct fuse_data *data; struct fuse_ticket *tick, *x_tick; int found = 0; DEBUG_MSG("Fuse write -- No: %d, resid: %d, iovcnt: %d, thread: %d\n", ++counter, uio->uio_resid, uio->uio_iovcnt, uio->uio_td->td_tid); data = fusedev_get_data(dev); if (uio->uio_resid < sizeof(struct fuse_out_header)) { DEBUG_MSG("got less than a header!\n"); fdata_kick_set(data); return (EINVAL); } if ((err = uiomove(&ohead, sizeof(struct fuse_out_header), uio)) != 0) return (err); /* * We check header information (which is redundant) and compare it with * what we see. If we see some inconsistency we discard the whole * answer and proceed on as if it had never existed. In particular, no * pretender will be woken up, regardless the "unique" value in the * header. */ if ((err = fuse_ohead_audit(&ohead, uio))) { fdata_kick_set(data); return (err); } /* Pass stuff over to callback if there is one installed */ /* Looking for ticket with the unique id of header */ mtx_lock(&data->aw_mtx); TAILQ_FOREACH_SAFE(tick, &data->aw_head, tk_aw_link, x_tick) { DEBUG_MSG("bumped into callback #%llu\n", (unsigned long long)tick->tk_unique); if (tick->tk_unique == ohead.unique) { found = 1; fuse_aw_remove(tick); break; } } mtx_unlock(&data->aw_mtx); if (found) { if (tick->tk_aw_handler) { /* We found a callback with proper handler. * In this case the out header will be 0wnd by * the callback, so the fun of freeing that is * left for her. * (Then, by all chance, she'll just get that's done * via ticket_drop(), so no manual mucking around...) */ memcpy(&tick->tk_aw_ohead, &ohead, sizeof(ohead)); err = tick->tk_aw_handler(tick, uio); DEBUG_MSG("stuff been passed over to a callback\n"); } else { /* pretender doesn't wanna do anything with answer */ DEBUG_MSG("stuff devalidated, so we drop it\n"); fuse_ticket_drop(tick); return (err); } } else { /* no callback at all! */ /* * this is BAD: * + if unique id was generated by fuse userspace, * that's way too bogus. Userspace should only * pass unique ids back and forth. * + else we generated the unique id by * fuse_ticket_fetch() somewhere in the foggy past. * Now that ticket is either * + dropped, which means it could have been * reused by now, and then this answer we work * with would be misdelivered (it's * just luck that it's not the case now) * + not dropped, which means it's either * + lost: will be kept on busy list for * the whole lifetime * + someone will drop it randomly without * any event based triggering (this * would be the place for such a thing), * which is just nonsense. */ DEBUG_MSG("erhm, no handler for this response\n"); fdata_kick_set(data); return (EINVAL); } return (err); } /* * Modeled after tunclone() of net/if_tun.c ... * boosted with a hack so that devices can be reused. */ #ifdef USE_OLD_CLONEHANDLER_API void fusedev_clone(void *arg, char *name, int namelen, struct cdev **dev) #else void fusedev_clone(void *arg, struct ucred *cred, char *name, int namelen, struct cdev **dev) #endif { /* * Why cloning? We do need per-open info, but we could as well put our * hands on the file struct assigned to an open by implementing * d_fdopen instead of d_open. * * From that on, the usual way to per-open (that is, file aware) * I/O would be pushing our preferred set of ops into the f_op * field of that file at open time. But that wouldn't work in * FreeBSD, as the devfs open routine (which is the one who calls * the device's d_(fd)open) overwrites that f_op with its own * file ops mercilessly. * * Yet... even if we could get devfs to keep our file ops intact, * I'd still say cloning is better. It makes fuse daemons' identity * explicit and globally visible to userspace, and we are not forced * to get the mount done by the daemon itself like in linux (where * I/O is file aware by default). (The possibilities of getting the * daemon do the mount or getting the mount util spawn the daemon * are still open, of course; I guess I will go for the latter * appcocroach.) */ int i, unit; if (*dev != NULL) return; if (strcmp(name, "fuse") == 0) { struct cdev *xdev; unit = -1; /* * Before falling back to the standard routine, we try * to find an existing free device by ourselves, so that * it will be reused instead of having the clone machinery * dummily spawn a new one. */ dev_lock(); LIST_FOREACH(xdev, &fuseclones->head, si_clone) { KASSERT(xdev->si_flags & SI_CLONELIST, ("Dev %p(%s) should be on clonelist", xdev, xdev->si_name)); if (! xdev->si_drv1) { unit = dev2unit(xdev); break; } } dev_unlock(); } else if (dev_stdclone(name, NULL, "fuse", &unit) != 1) { return; } /* find any existing device, or allocate new unit number */ i = clone_create(&fuseclones, &fuse_cdevsw, &unit, dev, 0); if (i) { *dev = make_dev(&fuse_cdevsw, unit2minor(unit), UID_ROOT, GID_OPERATOR, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP, "fuse%d", unit); if (*dev == NULL) return; } KASSERT(*dev, ("no device after apparently successful cloning")); dev_ref(*dev); (*dev)->si_drv1 = NULL; (*dev)->si_flags |= SI_CHEAPCLONE; DEBUG("clone done: %d\n",unit); } fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_session.h0000644000175000017500000002257411151613006020461 0ustar rmhrmh/* * Messaging related stuff and parameters of a session */ /* * Basic data carrying thingy with managed allocations. * fiov_adjust() is the primary public interface. */ struct fuse_iov { /* "public" members, provide an interface similar to that of an iov */ void *base; size_t len; /* nominal length */ /* "private" members */ size_t allocated_size; /* size of allocated buffer */ int credit; /* allow overruns of max permanent size this many times */ }; void fiov_init(struct fuse_iov *fiov, size_t size); void fiov_teardown(struct fuse_iov *fiov); /* make fiov useable for others again */ void fiov_refresh(struct fuse_iov *fiov); /* tune fiov so that its len will be set to size */ void fiov_adjust(struct fuse_iov *fiov, size_t size); #define FUSE_DIMALLOC(fiov, spc1, spc2, amnt) \ do { \ fiov_adjust(fiov, (sizeof(*(spc1)) + (amnt))); \ (spc1) = (fiov)->base; \ (spc2) = (char *)(fiov)->base + (sizeof(*(spc1))); \ } while (0) #define FU_AT_LEAST(siz) max(siz, 128) struct fuse_ticket; struct fuse_data; /* * As the last phase of a message passing, a function of this prototype is * called. */ typedef int fuse_handler_t(struct fuse_ticket *tick, struct uio *uio); /* * fuse_ticket is the basic data structure for kernel / userspace messaging */ struct fuse_ticket { /* fields giving the identity of the ticket */ uint64_t tk_unique; struct fuse_data *tk_data; int tk_flag; unsigned int tk_age; STAILQ_ENTRY(fuse_ticket) tk_freetickets_link; TAILQ_ENTRY(fuse_ticket) tk_alltickets_link; /* fields for initiating an upgoing message */ struct fuse_iov tk_ms_fiov; void *tk_ms_bufdata; unsigned long tk_ms_bufsize; enum { FT_M_FIOV, FT_M_BUF } tk_ms_type; /**/ STAILQ_ENTRY(fuse_ticket) tk_ms_link; /* fields for handling answers coming from userspace */ struct fuse_iov tk_aw_fiov; void *tk_aw_bufdata; unsigned long tk_aw_bufsize; enum { FT_A_FIOV, FT_A_BUF } tk_aw_type; /**/ struct fuse_out_header tk_aw_ohead; int tk_aw_errno; struct mtx tk_aw_mtx; fuse_handler_t *tk_aw_handler; struct fuse_iov tk_aw_handler_parm; TAILQ_ENTRY(fuse_ticket) tk_aw_link; }; #define FT_ANSW 0x01 /* request of ticket has already been answered */ #define FT_NOTOWNED 0x02 /* ticket is not owned */ #define FT_DIRTY 0x04 /* ticket has been used */ static __inline struct fuse_iov * fticket_resp(struct fuse_ticket *tick) { return (&tick->tk_aw_fiov); } static __inline int fticket_answered(struct fuse_ticket *tick) { return (tick->tk_flag & FT_ANSW); } static __inline void fticket_set_answered(struct fuse_ticket *tick) { tick->tk_flag |= FT_ANSW; } static __inline enum fuse_opcode fticket_opcode(struct fuse_ticket *tick) { return (((struct fuse_in_header *)(tick->tk_ms_fiov.base))->opcode); } static __inline void fticket_disown(struct fuse_ticket *tick) { tick->tk_flag |= FT_NOTOWNED; } /* pull in userspace data from uio and pass it to tick */ int fticket_pull(struct fuse_ticket *tick, struct uio *uio); enum mountpri { FM_NOMOUNTED, FM_PRIMARY, FM_SECONDARY }; /* * The data representing a fuse session. * It contains the queues used in the communication * and the respective locks. */ struct fuse_data { enum mountpri mpri; /* queue for upgoing messages */ struct mtx ms_mtx; STAILQ_HEAD(, fuse_ticket) ms_head; /* queue of answer waiters */ struct mtx aw_mtx; TAILQ_HEAD(, fuse_ticket) aw_head; /* fuse_ticket repository */ struct mtx ticket_mtx; STAILQ_HEAD(, fuse_ticket) freetickets_head; TAILQ_HEAD(, fuse_ticket) alltickets_head; uint32_t freeticket_counter; uint32_t deadticket_counter; uint32_t ticketer; #if _DEBUG_UNIQUE uint64_t msgcou; #endif struct sx rename_lock; struct ucred *daemoncred; struct selinfo ks_rsel; int dataflag; struct cdev *fdev; struct mount *mp; struct vnode *rvp; /* mount info */ int mntco; struct sx mhierlock; LIST_HEAD(, fuse_secondary_data) slaves_head; uint32_t fuse_libabi_major; uint32_t fuse_libabi_minor; unsigned max_write; unsigned max_read; }; #define FSESS_KICK 0x0001 /* session is to be closed */ #define FSESS_OPENED 0x0002 /* the device of the session has been opened */ #define FSESS_NOFSYNC 0x0004 /* daemon doesn't implement fsync */ #define FSESS_NOFSYNCDIR 0x0008 /* daemon doesn't implement fsyncdir */ #define FSESS_NOACCESS 0x0010 /* daemon doesn't implement access */ #define FSESS_NOCREATE 0x0020 /* daemon doesn't implement create */ #define FSESS_INITED 0x0040 /* session has been inited */ #define FSESS_DAEMON_CAN_SPY 0x0080 /* let non-owners access this fs (and being observed by the daemon) */ #define FSESS_NEGLECT_SHARES 0x0100 /* presence of secondary mount is not considered as "fs is busy" */ #define FSESS_PRIVATE 0x0200 /* don't allow secondary mounts */ #define FSESS_PUSH_SYMLINKS_IN 0x0400 /* prefix absolute symlinks with mp */ #define FSESS_DEFAULT_PERMISSIONS 0x0800 /* kernel does permission checking, based on file mode */ #define FSESS_SYNC_UNMOUNT 0x1000 /* intends to do a synchronous unmount (ie, wait with unmount 'till daemon signals "ready") */ #define FSESS_CAN_SYNC_UNMOUNT 0x2000 /* capable of doing a sync unmount when the "sync_unmount" sysctl has obligated a privilege check */ static __inline struct fuse_data * fusedev_get_data(struct cdev *fdev) { return (fdev->si_drv1); } static __inline struct fuse_data * fusefs_get_data(struct mount *mp) { struct fuse_data *data = mp->mnt_data; return (data->mpri == FM_PRIMARY ? data : NULL); } /* misc functions for managing queues and alike */ static __inline void fuse_ms_push(struct fuse_ticket *tick) { STAILQ_INSERT_TAIL(&tick->tk_data->ms_head, tick, tk_ms_link); } static __inline struct fuse_ticket * fuse_ms_pop(struct fuse_data *data) { struct fuse_ticket *tick; if ((tick = STAILQ_FIRST(&data->ms_head))) STAILQ_REMOVE_HEAD(&data->ms_head, tk_ms_link); return (tick); } /**/ static __inline void fuse_aw_push(struct fuse_ticket *tick) { TAILQ_INSERT_TAIL(&tick->tk_data->aw_head, tick, tk_aw_link); } static __inline void fuse_aw_remove(struct fuse_ticket *tick) { TAILQ_REMOVE(&tick->tk_data->aw_head, tick, tk_aw_link); } static __inline struct fuse_ticket * fuse_aw_pop(struct fuse_data *data) { struct fuse_ticket *tick; if ((tick = TAILQ_FIRST(&data->aw_head))) fuse_aw_remove(tick); return (tick); } struct fuse_ticket *fuse_ticket_fetch(struct fuse_data *data); void fuse_ticket_drop(struct fuse_ticket *tick); void fuse_ticket_drop_notowned(struct fuse_ticket *tick); void fuse_insert_callback(struct fuse_ticket *tick, fuse_handler_t *handler); void fuse_insert_message(struct fuse_ticket *tick); static __inline int fuse_libabi_geq(struct fuse_data *data, uint32_t maj, uint32_t min) { return (data->fuse_libabi_major > maj || (data->fuse_libabi_major == maj && data->fuse_libabi_minor >= min)); } /* * VFS private data for secondary mount */ struct fuse_secondary_data { enum mountpri mpri; struct mount *mp; struct fuse_data *master; LIST_ENTRY(fuse_secondary_data) slaves_link; }; static __inline struct fuse_secondary_data * fusefs_get_secdata(struct mount *mp) { struct fuse_secondary_data *fsdat = mp->mnt_data; return (fsdat->mpri == FM_SECONDARY ? fsdat : NULL); } struct fuse_data *fdata_alloc(struct cdev *dev, struct ucred *cred); void fdata_destroy(struct fuse_data *data); /* see if session is to be closed */ int fdata_kick_get(struct fuse_data *data); /* mark session to be closed */ void fdata_kick_set(struct fuse_data *data); /* * Structure used by the high level interface to messaging */ struct fuse_dispatcher { /* fields for stage 1 (and 0, 2) */ struct fuse_ticket *tick; struct fuse_in_header *finh; void *indata; size_t iosize; uint64_t nodeid; /* fields for stage 2 */ int answ_stat; void *answ; }; /* High-level routines for different stages of message passing */ /* stage 0 */ static __inline void fdisp_init(struct fuse_dispatcher *fdisp, size_t iosize) { fdisp->iosize = iosize; fdisp->tick = NULL; } /* stage 1 */ void fdisp_make(struct fuse_dispatcher *fdip, struct mount *mp, enum fuse_opcode op, uint64_t nid, struct thread *td, struct ucred *cred); /* a variant using pid instead of a thread */ void fdisp_make_pid(struct fuse_dispatcher *fdip, struct mount *mp, enum fuse_opcode op, uint64_t nid, pid_t pid, struct ucred *cred); /* simpler, vp based variant */ void fdisp_make_vp(struct fuse_dispatcher *fdip, enum fuse_opcode op, struct vnode *vp, struct thread *td, struct ucred *cred); /* stage 2 */ int fdisp_wait_answ(struct fuse_dispatcher *fdip); /* stage 0, 1, 2 together for the simple case when only a header is sent up */ static __inline int fdisp_simple_putget(struct fuse_dispatcher *fdip, enum fuse_opcode op, struct vnode *vp, struct thread *td, struct ucred *cred) { fdisp_init(fdip, 0); fdisp_make_vp(fdip, op, vp, td, cred); return (fdisp_wait_answ(fdip)); } fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_vnops.c0000644000175000017500000027252711151613006020143 0ustar rmhrmh#include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" #include "fuse_session.h" #include "fuse_vnode.h" #include "fuse_io.h" #if USE_PRIVILEGE_API #include #endif /* function prototype for iterators over filehandles (of a vp) */ typedef int fuse_metrics_t(struct fuse_filehandle *fufh, struct thread *td, struct ucred *cred, void *param); /* access related data */ struct fuse_access_param { uid_t xuid; gid_t xgid; unsigned facc_flags; }; #define FACCESS_VA_VALID 0x01 /* flag to sign to reuse cached attributes regardless of cache timeout */ #define FACCESS_DO_ACCESS 0x02 /* flag showing if we are to do access check */ #define FACCESS_STICKY 0x04 /* do sticky dir permission check */ #define FACCESS_CHOWN 0x08 /* do permission check for owner changing */ #define FACCESS_NOCHECKSPY 0x10 /* don't check if daemon is allowed to spy on user */ #define FACCESS_SETGID 0x12 /* do permission check for setting setgid flag */ #define FACCESS_XQUERIES FACCESS_STICKY | FACCESS_CHOWN | FACCESS_SETGID #define FVP_ACCESS_NOOP 0x01 /* vnode based control flag for doing access check */ /* parameter struct for fuse_standard_metrics() */ struct standard_metrics_param { int mode; enum fuse_opcode op; struct fuse_filehandle *fufh; }; struct fuse_release_param { int err; uint8_t fg:1; uint8_t flush:1; }; #if FUSE_HAS_CREATE struct fuse_pidcred { pid_t pid; struct ucred cred; }; #endif static void fuse_send_forget_pid(struct mount *mp, pid_t pid, struct ucred *cred, uint64_t nodeid, uint64_t nlookup, struct fuse_dispatcher *fdip); static void fuse_send_forget(struct mount *mp, struct thread *td, struct ucred *cred, uint64_t nodeid, uint64_t nlookup, struct fuse_dispatcher *fdip); static __inline void fuse_vnode_init_data(struct vnode *vp, struct fuse_vnode_data *fvdat, uint64_t nodeid); static __inline void fuse_vnode_init_misc(struct vnode *vp, enum vtype vtyp, uint64_t parentid); static __inline void fat2vat(struct mount *mp, struct fuse_attr *fat, struct vattr *vap); static __inline int fuse_match_cred(struct ucred *daemoncred, struct ucred *usercred); static __inline int fuse_check_spyable(struct fuse_dispatcher *fdip, struct mount *mp, struct thread *td, struct ucred *cred); static int fuse_recyc_backend(struct vnode *vp, struct thread *td); static void fuse_filehandle_gc(struct vnode *vp, struct thread *td, struct ucred *cred, struct fuse_release_param *frp); static int fuse_access_i(struct vnode *vp, mode_t mode, struct ucred *cred, struct thread *td, struct fuse_access_param *facp); static int iterate_filehandles(struct vnode *vp, struct thread *td, struct ucred *cred, fuse_metrics_t fmetr, void *param); #if FUSE_HAS_CREATE static __inline int create_filehandle(struct vnode *vp, struct thread *td, struct ucred *cred, int mode, struct fuse_dispatcher *fdip); #endif static void fuse_send_release(struct fuse_filehandle *fufh, struct thread *td, struct ucred *cred, int flags, struct fuse_release_param *frp); static int fuse_newentry_backend(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, enum fuse_opcode op, void *buf, size_t bufsize, enum vtype vtyp); static __inline void fuse_make_entry_req(struct mount *mp, uint64_t dnid, struct componentname *cnp, enum fuse_opcode op, void *buf, size_t bufsize, struct fuse_dispatcher *fdip); static __inline int checkentry(struct fuse_entry_out *feo, enum vtype vtyp); static __inline int fuse_newentry_core(struct vnode *dvp, struct vnode **vpp, enum vtype vtyp, struct fuse_dispatcher *fdip); static __inline int fuse_remove_backend(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, enum fuse_opcode op); static __inline int fuse_rename_core(struct vnode *fdvp, struct componentname *fcnp, struct vnode *tdvp, struct componentname *tcnp); extern int fuse_read_directbackend(struct fuse_io_data *fioda); static fuse_buffeater_t fuse_dir_buffeater; static fuse_handler_t fuse_fsync_handler; #if FUSE_HAS_CREATE static fuse_handler_t fuse_forgetful_handler; #endif static fuse_metrics_t fuse_file_ditch; static fuse_metrics_t fuse_standard_metrics; static fuse_metrics_t fuse_fsync_filehandle; static fuse_metrics_t release_filehandle; #if FUSE_HAS_CREATE static vfs_hash_cmp_t fuse_vnode_fgdrop_cmp; #endif static vfs_hash_cmp_t fuse_vnode_findparent_cmp; /* file ops */ static fo_close_t fuse_close_f; /* vnode ops */ static vop_getattr_t fuse_getattr; static vop_reclaim_t fuse_reclaim; static vop_inactive_t fuse_inactive; static vop_access_t fuse_access; static vop_lookup_t fuse_lookup; static vop_open_t fuse_open; static vop_close_t fuse_close; static vop_read_t fuse_read; static vop_readdir_t fuse_readdir; static vop_readlink_t fuse_readlink; static vop_mknod_t fuse_mknod; static vop_create_t fuse_create; static vop_mkdir_t fuse_mkdir; static vop_link_t fuse_link; static vop_symlink_t fuse_symlink; static vop_remove_t fuse_remove; static vop_rmdir_t fuse_rmdir; static vop_rename_t fuse_rename; static vop_setattr_t fuse_setattr; static vop_fsync_t fuse_fsync; static vop_write_t fuse_write; static vop_strategy_t fuse_strategy; static vop_getpages_t fuse_getpages; static vop_putpages_t fuse_putpages; static vop_print_t fuse_print; static vop_unlock_t fuse_unlock; #if FUSE_HAS_CREATE vop_access_t fuse_germ_access; #endif struct fileops fuse_fileops = { .fo_read = fuse_io_file, .fo_write = fuse_io_file, /* * following fields are filled from vnops, but "vnops.foo" is not * legitimate in a definition, so we set them at module load time */ .fo_ioctl = NULL, .fo_poll = NULL, .fo_kqfilter = NULL, .fo_stat = NULL, .fo_close = fuse_close_f, .fo_flags = DFLAG_PASSABLE | DFLAG_SEEKABLE }; struct vop_vector fuse_vnops = { .vop_default = &default_vnodeops, .vop_inactive = fuse_inactive, .vop_reclaim = fuse_reclaim, .vop_getattr = fuse_getattr, .vop_access = fuse_access, .vop_lookup = fuse_lookup, .vop_pathconf = vop_stdpathconf, .vop_open = fuse_open, .vop_close = fuse_close, .vop_read = fuse_read, .vop_write = fuse_write, .vop_readdir = fuse_readdir, .vop_readlink = fuse_readlink, .vop_mknod = fuse_mknod, .vop_create = fuse_create, .vop_mkdir = fuse_mkdir, .vop_link = fuse_link, .vop_symlink = fuse_symlink, .vop_remove = fuse_remove, .vop_rmdir = fuse_rmdir, .vop_rename = fuse_rename, .vop_setattr = fuse_setattr, .vop_fsync = fuse_fsync, .vop_strategy = fuse_strategy, .vop_getpages = fuse_getpages, .vop_putpages = fuse_putpages, .vop_print = fuse_print, .vop_unlock = fuse_unlock, }; #if FUSE_HAS_CREATE struct vop_vector fuse_germ_vnops; #endif MALLOC_DEFINE(M_FUSEVN, "fuse_vnode", "fuse vnode private data"); MALLOC_DEFINE(M_FUSEFH, "fuse_filehandles", "buffer for fuse filehandles"); int fuse_pbuf_freecnt = -1; /******************** * * >>> Vnode related callback handlers * ********************/ static int fuse_fsync_handler(struct fuse_ticket *tick, struct uio *uio) { if (tick->tk_aw_ohead.error == ENOSYS) tick->tk_data->dataflag |= fticket_opcode(tick) == FUSE_FSYNC ? FSESS_NOFSYNC : FSESS_NOFSYNCDIR; fuse_ticket_drop(tick); return (0); } #if FUSE_HAS_CREATE static int fuse_forgetful_handler(struct fuse_ticket *tick, struct uio *uio) { struct fuse_dispatcher fdi; struct fuse_pidcred *pidcred; /* * XXX I think I'm right to send a forget regardless of possible * errors, but... */ fdi.tick = tick; pidcred = tick->tk_aw_handler_parm.base; fuse_send_forget_pid(tick->tk_data->mp, pidcred->pid, &pidcred->cred, ((struct fuse_in_header *)tick->tk_ms_fiov.base)->nodeid, 1, &fdi); return (0); } #endif /****************** * * >>> VFS hash comparators * ******************/ #if FUSE_HAS_CREATE /* * Vnode comparison function with which the given vnode always * gets inserted, but got marked invalid upon a clash. Caller * is free (and expected to) deal with clashes. */ int fuse_vnode_fgdrop_cmp(struct vnode *vp, void *param) { struct fuse_vnode_data *fvdat = param; if (VTOI(vp) == fvdat->nid) fvdat->nid = FUSE_NULL_ID; return (1); } #endif /* * A skewed use of the vfs hash subsystem for finding out parent * nodeid. This comparator never matches, just collects data during * scanning through the nodes (without vnode locking). */ static int fuse_vnode_findparent_cmp(struct vnode *vp, void *param) { struct parentmanager_param *pmp = param; /* * In general, we'd need a (nodeid, vtyp) pair to match * but we may assume that the type is directory, because * that's what users of this function will want. */ if (VTOI(vp) == pmp->nodeid && vp->v_type == VDIR) { KASSERT(! pmp->valid, ("more than one vnode seems to match #%llu", (unsigned long long)pmp->nodeid)); pmp->parent_nid = VTOFUD(vp)->parent_nid; pmp->valid = 1; } return (1); } /****************** * * >>> Vnode related aux routines * ******************/ static __inline void __fuse_send_forget_pid(struct mount *mp, pid_t pid, struct ucred *cred, uint64_t nodeid, uint64_t nlookup, struct fuse_dispatcher *fdip) { struct fuse_forget_in *ffi; KASSERT(nlookup > 0, ("zero-times forget for vp #%llu", (long long unsigned) nodeid)); DEBUG("sending FORGET with %llu lookups\n", (unsigned long long)nlookup); fdisp_init(fdip, sizeof(*ffi)); fdisp_make_pid(fdip, mp, FUSE_FORGET, nodeid, pid, cred); ffi = fdip->indata; ffi->nlookup = nlookup; fticket_disown(fdip->tick); fuse_insert_message(fdip->tick); } static void fuse_send_forget_pid(struct mount *mp, pid_t pid, struct ucred *cred, uint64_t nodeid, uint64_t nlookup, struct fuse_dispatcher *fdip) { return (__fuse_send_forget_pid(mp, pid, cred, nodeid, nlookup, fdip)); } static void fuse_send_forget(struct mount *mp, struct thread *td, struct ucred *cred, uint64_t nodeid, uint64_t nlookup, struct fuse_dispatcher *fdip) { RECTIFY_TDCR(td, cred); return (__fuse_send_forget_pid(mp, td->td_proc->p_pid, cred, nodeid, nlookup, fdip)); } static __inline void fuse_vnode_init_data(struct vnode *vp, struct fuse_vnode_data *fvdat, uint64_t nodeid) { fvdat->nid = nodeid; vp->v_data = fvdat; } static __inline void fuse_vnode_init_misc(struct vnode *vp, enum vtype vtyp, uint64_t parentid) { struct fuse_vnode_data *fvdat = VTOFUD(vp); VNASSERT(fvdat, vp, (("init_misc on virgin vnode"))); fvdat->parent_nid = parentid; vp->v_type = vtyp; LIST_INIT(&fvdat->fh_head); vp->v_bufobj.bo_private = vp; } void fuse_vnode_init(struct vnode *vp, struct fuse_vnode_data *fvdat, uint64_t nodeid, enum vtype vtyp, uint64_t parentid) { fuse_vnode_init_data(vp, fvdat, nodeid); fuse_vnode_init_misc(vp, vtyp, parentid); } void fuse_vnode_ditch(struct vnode *vp, struct thread *td) { if (! td) td = curthread; if (vp->v_vflag & VV_ROOT) { fdata_kick_set(fusefs_get_data(vp->v_mount)); return; } DEBUG2G("vp %p, #%llu\n", vp, VTOILLU(vp)); vnode_destroy_vobject(vp); /* * this implies we won't get feedback on recycling * (other than panicking, or the lack of that) * but creating a customized set of bad vnode ops * would be too much hassle... */ vp->v_op = &dead_vnodeops; fuse_recyc_backend(vp, td); } void fuse_vnode_teardown(struct vnode *vp, struct thread *td, struct ucred *cred, enum vtype vtyp) { struct fuse_dispatcher fdi; struct fuse_vnode_data *fvdat = VTOFUD(vp); if (vp->v_type == vtyp) { bzero(&fdi, sizeof(fdi)); vfs_hash_remove(vp); fuse_send_forget(vp->v_mount, td, cred, fvdat->nid, fvdat->nlookup, &fdi); fvdat->nid = FUSE_NULL_ID; } else fuse_vnode_ditch(vp, td); vput(vp); } static int fuse_file_ditch(struct fuse_filehandle *fufh, struct thread *td, struct ucred *cred, void *param) { if (fufh->fp) { fufh->fp->f_ops = &vnops; fufh->fp->f_data = NULL; fufh->fp = NULL; } fufh->useco = 0; return (0); } /****************** * * >>> Vnode ops and their helpers * ******************/ static int fuse_recyc_backend(struct vnode *vp, struct thread *td) { struct fuse_vnode_data *fvdat = VTOFUD(vp); struct fuse_release_param frp; if (! fvdat) { DEBUG("got a dataless node\n"); return (0); } DEBUG("getting at vnode of ino %llu\n", VTOILLU(vp)); ASSERT_VOP_ELOCKED(vp, "recycling unlocked vnode"); ASSERT_VOP_ELOCKED__FH(vp); iterate_filehandles(vp, td, NULL, fuse_file_ditch, NULL); /* * Sometimes the FORGET message sent below used to hit the target * _sooner_ than the RELEASE-s sent here, and the daemon wasn't * particularly happy about that. * * So now we just peacefully sit here and wait for the answer before * goin' on. */ frp.fg = 1; frp.flush = 0; iterate_filehandles(vp, td, NULL, release_filehandle, &frp); if (! (vp->v_vflag & VV_ROOT)) { if (fvdat->nid != FUSE_NULL_ID) vfs_hash_remove(vp); if (fvdat->nlookup) { struct fuse_dispatcher fdi; fdi.tick = NULL; /* * sending a FORGET is just courtesy toward the daemon * (who might as well be as dead as a stone at this * point), so we don't care a damned shit about it if * something woes during this action. */ fuse_send_forget(vp->v_mount, td, NULL, VTOI(vp), fvdat->nlookup, &fdi); } } vp->v_data = NULL; /* * Taking down fuse_vnode_data structures is just hooked in here... * no separate destructor. */ free(fvdat, M_FUSEVN); /* XXX what does it mean exactly to return a non-zero value from here? */ return (0); } static int release_filehandle(struct fuse_filehandle *fufh, struct thread *td, struct ucred *cred, void *param) { KASSERT(fufh->useco >= 0, ("negative use count for fuse filehandle #%llu@#%llu", (long long unsigned)fufh->fh_id, VTOILLU(fufh->fh_vp))); KASSERT(! fufh->fp || fufh->useco > 0, ("filehandle bound with 0 use counter")); DEBUG2G("vnode #%llu, fufh %p #%llu, owner file %p, useco %d\n", VTOILLU(fufh->fh_vp), fufh, (long long unsigned) fufh->fh_id, fufh->fp, fufh->useco); if (! fufh->fp && fufh->useco == 0) { LIST_REMOVE(fufh, fh_link); fuse_send_release(fufh, td, cred, fufh->mode, param); } return (0); } static void fuse_filehandle_gc(struct vnode *vp, struct thread *td, struct ucred *cred, struct fuse_release_param *frp) { ASSERT_VOP_ELOCKED__FH(vp); iterate_filehandles(vp, td, cred, release_filehandle, frp); } static int fuse_reclaim(ap) struct vop_reclaim_args /* { struct vnode *a_vp; struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct thread *td = ap->a_td; DEBUG("pfft...\n"); #if _DEBUG DEBUG2G("=============>\n"); kdb_backtrace(); vn_printf(vp, " "); DEBUG2G("<=============\n"); #endif vnode_destroy_vobject(vp); return (fuse_recyc_backend(vp, td)); } static int fuse_inactive(ap) struct vop_inactive_args /* { struct vnode *a_vp; struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct thread *td = ap->a_td; int err; DEBUG("getting at vnode of ino %llu\n", VTOILLU(vp)); #if _DEBUG DEBUG2G("=============>\n"); kdb_backtrace(); vn_printf(vp, " "); DEBUG2G("<=============\n"); #endif { struct fuse_release_param frp; frp.fg = 0; frp.flush = 0; fuse_filehandle_gc(vp, td, NULL, &frp); } #ifndef DONT_STORE_FS_MAP /* * Dropping vnodes when they are not in use would mean that * the respective inode must be freed on the daemon's side * (this is ia necessity according to the protocol: if * we drop the vnode, then we lose the associated nlookup * value, which is required to be kept during the lifetime of * the inode, as at the end of the inode's lifetime this info * is required for properly killing it (cf. forget_node() of * lib/fuse.c and the assertion in it), that is, the inode * can't be kept alive further than the vnode). * * So either we aggressively kill both kind of beasts and don't * store permanently a "map" of the fs (thus, eg, same files * pop up with different inode numbers upon different lookups, * which is weird), or we keep them both and don't do anything when * the vnode usecount falls to zero (ie. use a peaceful vop_inactive * which throws away only rotten vegetables). * * The latter approach seems to be the better, partly because of * the above mentioned weirdness, but mostly because fs ops done * by the daemon are considered expensive. * * [To add, all this reasoning doesn't imply I understand the * reason for the enforcement of the thigt synchronization * between in-kernel vnodes and userspace inodes.] */ if (VTOFUD(vp)) return (0); #endif if ((err = fuse_recyc_backend(vp, td))) return err; vrecycle(vp, td); return (0); } /* * It's by-and-large reversing vn_stat() of kern/vfs_vnops.c */ static __inline void fat2vat(struct mount *mp, struct fuse_attr *fat, struct vattr *vap) { DEBUG("node #%llu, mode 0%o\n", (unsigned long long)fat->ino, fat->mode); vattr_null(vap); vap->va_fsid = mp->mnt_stat.f_fsid.val[0]; vap->va_fileid = fat->ino; /* XXX cast from 64 bits to 32 */ vap->va_mode = fat->mode & ~S_IFMT; vap->va_nlink = fat->nlink; vap->va_uid = fat->uid; vap->va_gid = fat->gid; vap->va_rdev = fat->rdev; vap->va_size = fat->size; vap->va_atime.tv_sec = fat->atime; /* XXX on some platforms cast from 64 bits to 32 */ vap->va_atime.tv_nsec = fat->atimensec; vap->va_mtime.tv_sec = fat->mtime; vap->va_mtime.tv_nsec = fat->mtimensec; vap->va_ctime.tv_sec = fat->ctime; vap->va_ctime.tv_nsec = fat->ctimensec; vap->va_blocksize = PAGE_SIZE; vap->va_type = IFTOVT(fat->mode); #if (S_BLKSIZE == 512) /* Optimize this case */ vap->va_bytes = fat->blocks << 9; #else vap->va_bytes = fat->blocks * S_BLKSIZE; #endif vap->va_flags = 0; } #define cache_attrs(vp, fuse_out) do { \ struct timespec uptsp_ ## __func__; \ \ VTOFUD(vp)->cached_attrs_valid.tv_sec = (fuse_out)->attr_valid; \ VTOFUD(vp)->cached_attrs_valid.tv_nsec = (fuse_out)->attr_valid_nsec; \ nanouptime(&uptsp_ ## __func__); \ \ DEBUG("cached attrs for vp #%llu: timo s %d ns %ld\n", VTOILLU(vp), \ VTOFUD(vp)->cached_attrs_valid.tv_sec, \ VTOFUD(vp)->cached_attrs_valid.tv_nsec); \ timespecadd(&VTOFUD(vp)->cached_attrs_valid, &uptsp_ ## __func__); \ \ fat2vat((vp)->v_mount, &(fuse_out)->attr, VTOVA(vp)); \ } while (0) /* * An access check routine based on fuse_allow_task() of the Linux module. * Now we use this one rather than the more permissive function we used to * (and which seemed more logical to me), to ensure uniform behaviour on Linux * and FreeBSD. * * Non-null return value indicates error (ie., "not allowed"). */ static __inline int fuse_match_cred(struct ucred *basecred, struct ucred *usercred) { if (basecred->cr_uid == usercred->cr_uid && basecred->cr_uid == usercred->cr_ruid && basecred->cr_uid == usercred->cr_svuid && basecred->cr_groups[0] == usercred->cr_groups[0] && basecred->cr_groups[0] == usercred->cr_rgid && basecred->cr_groups[0] == usercred->cr_svgid) return (0); return (EPERM); } static __inline int fuse_check_spyable(struct fuse_dispatcher *fdip, struct mount *mp, struct thread *td, struct ucred *cred) { struct fuse_data *data = fusefs_get_data(mp); struct fuse_secondary_data *x_fsdat; int denied; if (data->dataflag & FSESS_DAEMON_CAN_SPY) return (0); /* * The policy is to forbid a user from using the filesystem, * unless she has it mounted. * * This is primarily to * protect her from the daemon spying on her I/O * operations. Although this is not a concern if the user * is more privileged than the daemon, we consistently * demand the per-user mount, in order to be compatible * with the Linux implementation. * * Secondary mounts let arbitrary number of users mount and * use the filesystem. However, the primary mounter must explicitly * allow secondary mounts. This is again for providing Linux like * defaults. */ denied = fuse_match_cred(mp->mnt_cred, cred); if (! denied) goto allow; LIST_FOREACH(x_fsdat, &data->slaves_head, slaves_link) { denied = fuse_match_cred(x_fsdat->mp->mnt_cred, cred); if (! denied) goto allow; } return (EACCES); allow: return (0); } static int fuse_getattr(ap) struct vop_getattr_args /* { struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct vattr *vap = ap->a_vap; struct ucred *cred = ap->a_cred; struct thread *td = ap->a_td; struct fuse_dispatcher fdi; struct timespec uptsp; int err = 0; /* look for cached attributes */ nanouptime(&uptsp); if (timespeccmp(&uptsp, &VTOFUD(vp)->cached_attrs_valid, <=)) { DEBUG("found valid cached attrs for vp #%llu\n", VTOILLU(vp)); if (vap != VTOVA(vp)) memcpy(vap, VTOVA(vp), sizeof(*vap)); return (0); } if (! (fusefs_get_data(vp->v_mount)->dataflag & FSESS_INITED)) { if (! (vp->v_vflag & VV_ROOT)) { fdata_kick_set(fusefs_get_data(vp->v_mount)); err = ENOTCONN; return (err); } else goto fake; } if ((err = fdisp_simple_putget(&fdi, FUSE_GETATTR, vp, td, cred))) { if (err == ENOTCONN && vp->v_vflag & VV_ROOT) /* see comment at similar place in fuse_statfs() */ goto fake; return (err); } cache_attrs(vp, (struct fuse_attr_out *)fdi.answ); if (vap != VTOVA(vp)) memcpy(vap, VTOVA(vp), sizeof(*vap)); fuse_ticket_drop(fdi.tick); if (vp->v_type != vap->va_type) { if (vp->v_type == VNON && vap->va_type != VNON) { DEBUG2G("vnode #%llu with no type\n", VTOILLU(vp)); vp->v_type = vap->va_type; } else { /* stale vnode */ DEBUG2G("node #%lu got stale (old type %#x, new type %#x), kicking...\n", vap->va_fileid, vp->v_type, vap->va_type); fuse_vnode_ditch(vp, td); return (ENOTCONN); } } DEBUG("node #%llu, type %d\n", VTOILLU(vp), vap->va_type); #if _DEBUG DEBUG2G("\n"); vn_printf(vp, " * "); #endif return (0); fake: bzero(vap, sizeof(*vap)); vap->va_type = vp->v_type; return (0); } static int fuse_access(ap) struct vop_access_args /* { struct vnode *a_vp; int a_mode; struct ucred *a_cred; struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct fuse_access_param facp; struct fuse_vnode_data *fvdat = VTOFUD(vp); bzero(&facp, sizeof(facp)); if (fvdat->flags & FVP_ACCESS_NOOP) fvdat->flags &= ~FVP_ACCESS_NOOP; else facp.facc_flags |= FACCESS_DO_ACCESS; return fuse_access_i(vp, ap->a_mode, ap->a_cred, ap->a_td, &facp); } /* * Attribute caching hasn't yet been implemented. * [... Update: it _has been_ implemented.] * However, within one function we don't wanna query attributes * several times. Now it's enough pull the attributes once, and throw * it into the following routine with various modes. */ static int fuse_access_i(struct vnode *vp, mode_t mode, struct ucred *cred, struct thread *td, struct fuse_access_param *facp) { struct fuse_dispatcher fdi; int err = 0; /* * Disallow write attempts on read-only file systems; unless the file * is a socket, fifo, or a block or character device resident on the * file system. */ DEBUG("ro? %#x vp #%llu mode %#x\n", vp->v_mount->mnt_flag & MNT_RDONLY, VTOILLU(vp), mode); RECTIFY_TDCR(td, cred); if (mode & VWRITE) { switch (vp->v_type) { case VDIR: case VLNK: case VREG: if (vp->v_mount->mnt_flag & MNT_RDONLY) { DEBUG("no write access (read-only fs)\n"); return (EROFS); } break; default: break; } } bzero(&fdi, sizeof(fdi)); if (vp->v_vflag & VV_ROOT && ! (facp->facc_flags & FACCESS_NOCHECKSPY)) { if ((err = fuse_check_spyable(&fdi, vp->v_mount, td, cred))) return (err); facp->facc_flags |= FACCESS_NOCHECKSPY; } if (fusefs_get_data(vp->v_mount)->dataflag & FSESS_DEFAULT_PERMISSIONS || /* * According to Linux code, we fall back to in-kernel check * when it comes to executing a file */ (vp->v_type == VREG && mode == VEXEC)) { /* We are to do the check in-kernel */ if (! (facp->facc_flags & FACCESS_VA_VALID)) { err = VOP_GETATTR(vp, VTOVA(vp), cred, td); if (err) return (err); facp->facc_flags |= FACCESS_VA_VALID; } err = vaccess(VTOVA(vp)->va_type, VTOVA(vp)->va_mode, VTOVA(vp)->va_uid, VTOVA(vp)->va_gid, mode, cred, NULL); if (err) return (err); if (facp->facc_flags & FACCESS_STICKY) { if (vp->v_type == VDIR && VTOVA(vp)->va_mode & S_ISTXT && mode == VWRITE) { if (cred->cr_uid != facp->xuid && cred->cr_uid != VTOVA(vp)->va_uid) err = priv_check_cred(cred, PRIV_VFS_ADMIN, 0); } /* * We return here because this flags is exlusive * with the others */ KASSERT(facp->facc_flags == FACCESS_STICKY, ("sticky access check comes in mixed")); return (err); } if (mode != VADMIN) return (err); if (facp->facc_flags & FACCESS_CHOWN) { if ((cred->cr_uid != facp->xuid && facp->xuid != (uid_t)VNOVAL) || (cred->cr_gid != facp->xgid && facp->xgid != (gid_t)VNOVAL && ! groupmember(facp->xgid, cred))) err = priv_check_cred(cred, PRIV_VFS_CHOWN, 0); if (err) return (err); } if (facp->facc_flags & FACCESS_SETGID) { gid_t sgid = facp->xgid; if (sgid == (gid_t)VNOVAL) sgid = VTOVA(vp)->va_gid; if (! groupmember(sgid, cred)) err = priv_check_cred(cred, PRIV_VFS_SETGID, 0); return (err); } } else { #if FUSE_HAS_ACCESS struct fuse_access_in *fai; if (! (facp->facc_flags & FACCESS_DO_ACCESS)) return (0); if (fusefs_get_data(vp->v_mount)->dataflag & FSESS_NOACCESS) return (0); fdisp_init(&fdi, sizeof(*fai)); fdisp_make_vp(&fdi, FUSE_ACCESS, vp, td, cred); fai = fdi.indata; fai->mask = F_OK; if (mode & VREAD) fai->mask |= R_OK; if (mode & VWRITE) fai->mask |= W_OK; if (mode & VEXEC) fai->mask |= X_OK; if (! (err = fdisp_wait_answ(&fdi))) fuse_ticket_drop(fdi.tick); if (err == ENOSYS) { fusefs_get_data(vp->v_mount)->dataflag |= FSESS_NOACCESS; err = 0; } #endif } return err; } /* * Based on sample code of VOP_LOOKUP(9), reiserfs_lookup() * of gnu/fs/reiserfs/reiserfs_namei.c and vfs_cache_lookup() */ int fuse_lookup(ap) struct vop_lookup_args /* { struct vnodeop_desc *a_desc; struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; } */ *ap; { struct vnode *dvp = ap->a_dvp; struct vnode **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; int nameiop = cnp->cn_nameiop; struct thread *td = cnp->cn_thread; struct ucred *cred = cnp->cn_cred; int flags = cnp->cn_flags; int wantparent = flags & WANTPARENT; int islastcn = flags & ISLASTCN; int err = 0; int lookup_err = 0; struct vnode *vp = NULL; struct fuse_dispatcher fdi; struct fuse_attr *fattr = NULL; enum fuse_opcode op; uint64_t nid; uint64_t parentid; struct fuse_access_param facp; #ifdef INVARIANTS int cache_attrs_hit = 0; #endif /* general stuff, based on vfs_cache_lookup */ #if _DEBUG DEBUG2G("root node:\n"); vn_printf(fusefs_get_data(dvp->v_mount)->rvp, " * "); #endif if (dvp->v_type != VDIR) { DEBUG("vnode #%llu of vtype %d is not a dir\n", VTOILLU(dvp), dvp->v_type); return (ENOTDIR); } if (islastcn && (dvp->v_mount->mnt_flag & MNT_RDONLY) && (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) return (EROFS); /* * We do access check prior to doing anything else only in the case * when we are at fs root (we'd like to say, "we are at the first * component", but that's not exactly the same... nevermind). * See further comments at further access checks. */ bzero(&facp, sizeof(facp)); if ( #ifdef NO_EARLY_PERM_CHECK_HACK 1 #else dvp->v_vflag & VV_ROOT #endif ) { if ((err = fuse_access_i(dvp, VEXEC, cred, td, &facp))) return (err); } DEBUG2G("lookup in #%llu, nameiop %lu, with flags %#x\n", VTOILLU(dvp), cnp->cn_nameiop, flags); /* fetching data from "storage" */ if (flags & ISDOTDOT) { DEBUG2G("dotdot lookup!\n"); nid = VTOFUD(dvp)->parent_nid; parentid = FUSE_NULL_ID; fdisp_init(&fdi, 0); op = FUSE_GETATTR; } else if (cnp->cn_namelen == 1 && *(cnp->cn_nameptr) == '.') { DEBUG2G("dot lookup!\n"); nid = VTOI(dvp); parentid = VTOFUD(dvp)->parent_nid; /* irrelevant */ fdisp_init(&fdi, 0); op = FUSE_GETATTR; } else { nid = VTOI(dvp); parentid = VTOI(dvp); fdisp_init(&fdi, cnp->cn_namelen + 1); op = FUSE_LOOKUP; } fdisp_make(&fdi, dvp->v_mount, op, nid, td, cred); if (op == FUSE_LOOKUP) { memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; DEBUG2G("standard lookup, looking up %s\n", (char *)fdi.indata); } lookup_err = fdisp_wait_answ(&fdi); if (op == FUSE_LOOKUP && ! lookup_err) { nid = ((struct fuse_entry_out *)fdi.answ)->nodeid; if (! nid) { /* * zero nodeid is the same as "not found", * but it's also cacheable (which we keep * keep on doing not as of writing this) */ DEBUG2G("zero nid, ie ENOENT\n"); lookup_err = ENOENT; } else if (nid == FUSE_ROOT_ID) { DEBUG2G("root inode found on lookup?!!\n"); lookup_err = EINVAL; } } if (lookup_err && ( (! fdi.answ_stat) || /* this means messaging error */ lookup_err != ENOENT || /* daemon reported other error than "legal" ENOENT */ op != FUSE_LOOKUP /* we tolerate ENOENT only when we sent a LOOKUP */ )) { /* * There is error but not lookup related actually * (messaging error) */ DEBUG("lookup failed b/c messaging crap\n"); return (lookup_err); } /* analyzing answer */ /* * Now we got the answer and filtered out the crap, too, so we know that * "found" iff lookup_err == 0 */ if (lookup_err) { DEBUG("looked up thingy not found\n"); if ((nameiop == CREATE || nameiop == RENAME) && islastcn /* && directory dvp has not been removed */) { if (dvp->v_mount->mnt_flag & MNT_RDONLY) { err = EROFS; goto out; } DEBUG("create/rename -- we have to make it\n"); /* * Check for write access on directory. */ if ((err = fuse_access_i(dvp, VWRITE, cred, td, &facp))) goto out; /* * Possibly record the position of a slot in the * directory large enough for the new component name. * This can be recorded in the vnode private data for * dvp. Set the SAVENAME flag to hold onto the * pathname for use later in VOP_CREATE or VOP_RENAME. */ cnp->cn_flags |= SAVENAME; err = EJUSTRETURN; goto out; } /* * Consider inserting name into cache. */ /* * No we can't use negative caching, as the fs * changes are out of our control. * False positives' falseness turns out just as things * go by, but false negatives' falseness doesn't. * (and aiding the caching mechanism with extra control * mechanisms comes quite close to beating the whole purpose * caching...) */ #if 0 if ((cnp->cn_flags & MAKEENTRY) && nameiop != CREATE) { DEBUG("inserting NULL into cache\n"); cache_enter(dvp, NULL, cnp); } #endif err = ENOENT; goto out; } else { if (op == FUSE_GETATTR) fattr = &((struct fuse_attr_out *)fdi.answ)->attr; else fattr = &((struct fuse_entry_out *)fdi.answ)->attr; DEBUG("we found something...\n"); /* * If deleting, and at end of pathname, return parameters * which can be used to remove file. If the wantparent flag * isn't set, we return only the directory, otherwise we go on * and lock the inode, being careful with ".". */ if (nameiop == DELETE && islastcn) { DEBUG("something to delete\n"); /* * Check for write access on directory. */ facp.xuid = fattr->uid; facp.facc_flags |= FACCESS_STICKY; err = fuse_access_i(dvp, VWRITE, cred, td, &facp); facp.facc_flags &= ~FACCESS_XQUERIES; if (err) goto out; if (nid == VTOI(dvp)) { VREF(dvp); *vpp = dvp; goto out; } err = fuse_vget_i(dvp->v_mount, td, nid, IFTOVT(fattr->mode), &vp, VG_NORMAL, parentid); if (err) goto out; *vpp = vp; goto out; } /* * If rewriting (RENAME), return the inode and the * information required to rewrite the present directory * Must get inode of directory entry to verify it's a * regular file, or empty directory. */ if (nameiop == RENAME && wantparent && islastcn) { DEBUG("something to rename...\n"); facp.xuid = fattr->uid; facp.facc_flags |= FACCESS_STICKY; err = fuse_access_i(dvp, VWRITE, cred, td, &facp); facp.facc_flags &= ~FACCESS_XQUERIES; if (err) goto out; /* * Check for "." */ if (nid == VTOI(dvp)) { err = EISDIR; goto out; } err = fuse_vget_i(dvp->v_mount, td, nid, IFTOVT(fattr->mode), &vp, VG_NORMAL, parentid); if (err) goto out; *vpp = vp; /* * Save the name for use in VOP_RENAME later. */ cnp->cn_flags |= SAVENAME; goto out; } DEBUG("we peacefully found that file\n"); if (nid == VTOI(dvp)) { VREF(dvp); /* We want ourself, ie "." */ *vpp = dvp; } else { if (flags & ISDOTDOT) /* * If doing dotdot, we unlock dvp for vget time * to conform lock order regulations. */ VOP_UNLOCK(dvp, 0 #if VOP_UNLOCK_TAKES_THREAD , td #endif ); err = fuse_vget_i(dvp->v_mount, td, nid, IFTOVT(fattr->mode), &vp, VG_NORMAL, parentid); if (flags & ISDOTDOT) vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY #if VN_LOCK_TAKES_THREAD , td #endif ); if (err) goto out; *vpp = vp; } if (op == FUSE_GETATTR) cache_attrs(*vpp, (struct fuse_attr_out *)fdi.answ); else cache_attrs(*vpp, (struct fuse_entry_out *)fdi.answ); #ifdef INVARIANTS cache_attrs_hit = 1; #endif /* Insert name into cache if appropriate. */ /* * Nooo, caching is evil. With caching, we can't avoid stale * information taking over the playground (cached info is not * just positive/negative, it does have qualitative aspects, * too). And a (VOP/FUSE)_GETATTR is always thrown anyway, when * walking down along cached path components, and that's not * any cheaper than FUSE_LOOKUP. This might change with * implementing kernel side attr caching, but... In Linux, * lookup results are not cached, and the daemon is bombarded * with FUSE_LOOKUPS on and on. This shows that by design, the * daemon is expected to handle frequent lookup queries * efficiently, do its caching in userspace, and so on. * * So just leave the name cache alone. */ /* * Well, now I know, Linux caches lookups, but with a * timeout... So it's the same thing as attribute caching: * we can deal with it when implement timeouts. */ #if 0 if (cnp->cn_flags & MAKEENTRY) { DEBUG("...caching\n"); cache_enter(dvp, *vpp, cnp); } #endif } out: if (! lookup_err) { DEBUG("as the looked up thing was simply found, the cleanup is left for us\n"); if (err) { DEBUG("though inode found, err exit with no vnode\n"); if (op == FUSE_LOOKUP) fuse_send_forget(dvp->v_mount, td, cred, nid, 1, &fdi); return (err); } else { if (op == FUSE_LOOKUP) VTOFUD(*vpp)->nlookup++; if (islastcn && flags & ISOPEN) VTOFUD(*vpp)->flags |= FVP_ACCESS_NOOP; #ifndef NO_EARLY_PERM_CHECK_HACK if (! islastcn) { /* We have the attributes of the next item * *now*, and it's a fact, and we do not have * to do extra work for it (ie, beg the * daemon), and it neither depends on such * accidental things like attr caching. So the * big idea: check credentials *now*, not at * the beginning of the next call to lookup. * * The first item of the lookup chain (fs root) * won't be checked then here, of course, as * its never "the next". But go and see that * the root is taken care about at the very * beginning of this function. * * Now, given we want to do the access check * this way, one might ask: so then why not do * the access check just after fetching the * inode and its attributes from the daemon? * Why bother with producing the corresponding * vnode at all if something is not OK? We know * what's the deal as soon as we get those * attrs... There is one bit of info though not * given us by the daemon: whether his response * is authorative or not... His response should * be ignored if something is mounted over the * dir in question. But that can be known only * by having the vnode... */ bzero(&facp, sizeof(facp)); DEBUG("the early perm check hack\n"); facp.facc_flags |= FACCESS_VA_VALID; KASSERT(cache_attrs_hit, (("invalid reference to cached attrs"))); if ((*vpp)->v_type != VDIR && (*vpp)->v_type != VLNK) err = ENOTDIR; if (! err && ! (*vpp)->v_mountedhere) err = fuse_access_i(*vpp, VEXEC, cred, td, &facp); if (err) { if ((*vpp)->v_type == VLNK) DEBUG("weird, permission error with a symlink?\n"); vput(*vpp); *vpp = NULL; } } #endif } fuse_ticket_drop(fdi.tick); } DEBUG("returning with %d\n", err); #if _DEBUG2G if (!err) { DEBUG2G("looked up node:\n"); vn_printf(*vpp, " * "); } #endif #if _DEBUG DEBUG2G("root node:\n"); vn_printf(fusefs_get_data(dvp->v_mount)->rvp, " * "); #endif return (err); } static int iterate_filehandles(struct vnode *vp, struct thread *td, struct ucred *cred, fuse_metrics_t fmetr, void *param) { struct fuse_filehandle *fufh, *fufhxxx; struct fuse_vnode_data *fvdat = VTOFUD(vp); int rv = 0; RECTIFY_TDCR(td, cred); LIST_FOREACH_SAFE(fufh, &fvdat->fh_head, fh_link, fufhxxx) { KASSERT(fufh->fh_vp == vp, ("vnode mismatch for fuse_filehandle %p\n", fufh)); if ((rv = fmetr(fufh, td, cred, param))) return (rv); } return (0); } static int fuse_standard_metrics(struct fuse_filehandle *fufh, struct thread *td, struct ucred *cred, void *param) { struct standard_metrics_param *stmp = param; DEBUG2G("fufh->mode %#x, mode %#x\n", fufh->mode, stmp->mode); if (fufh->cred->cr_uid == cred->cr_uid && fufh->cred->cr_rgid == cred->cr_rgid && fufh->pid == td->td_proc->p_pid && ((fufh->mode ^ stmp->mode) & ~(O_CREAT | O_EXCL | O_TRUNC)) == 0 && fufh->op == stmp->op) { stmp->fufh = fufh; fufh->useco++; return (-1); } return (0); } static __inline void fuse_make_entry_req(struct mount *mp, uint64_t dnid, struct componentname *cnp, enum fuse_opcode op, void *buf, size_t bufsize, struct fuse_dispatcher *fdip) { fdip->iosize = bufsize + cnp->cn_namelen + 1; fdisp_make(fdip, mp, op, dnid, curthread, NULL); memcpy(fdip->indata, buf, bufsize); memcpy((char *)fdip->indata + bufsize, cnp->cn_nameptr, cnp->cn_namelen); ((char *)fdip->indata)[bufsize + cnp->cn_namelen] = '\0'; } static __inline int checkentry(struct fuse_entry_out *feo, enum vtype vtyp) { if (vtyp != IFTOVT(feo->attr.mode) || feo->nodeid == FUSE_NULL_ID || feo->nodeid == FUSE_ROOT_ID) { DEBUG2G("messy new entry, shall be dropped\n"); return (EINVAL); } return (0); } #if FUSE_HAS_CREATE static __inline int create_filehandle(struct vnode *vp, struct thread *td, struct ucred *cred, int mode, struct fuse_dispatcher *fdip) { struct fuse_vnode_data *fvdat = VTOFUD(vp); uint64_t parentid = fvdat->parent_nid; struct componentname *cnp = fvdat->germcnp; struct fuse_open_in *foi; struct fuse_entry_out *feo; struct fuse_mknod_in fmni; int err; int gone_good_old = 0; struct vnode *clashvp; vp->v_data = NULL; mode &= ~O_NOCTTY; fdisp_init(fdip, sizeof(*foi) + cnp->cn_namelen + 1); if (fusefs_get_data(vp->v_mount)->dataflag & FSESS_NOCREATE) goto good_old; fdisp_make(fdip, vp->v_mount, FUSE_CREATE, parentid, td, cred); /* * Looks stupid, but this is how we could smuggle in these * values from fuse_create... */ foi = fdip->indata; foi->flags = OFLAGS(mode); foi->mode = fvdat->flags; memcpy((char *)fdip->indata + sizeof(*foi), cnp->cn_nameptr, cnp->cn_namelen); ((char *)fdip->indata)[sizeof(*foi) + cnp->cn_namelen] = '\0'; err = fdisp_wait_answ(fdip); if (err == ENOSYS) { fusefs_get_data(vp->v_mount)->dataflag |= FSESS_NOCREATE; fdip->tick = NULL; goto good_old; } else if (err) goto undo; goto bringup; good_old: gone_good_old = 1; fmni.mode = fvdat->flags; fmni.rdev = 0; fuse_make_entry_req(vp->v_mount, parentid, cnp, FUSE_MKNOD, &fmni, sizeof(fmni), fdip); err = fdisp_wait_answ(fdip); if (err) goto undo; bringup: feo = fdip->answ; if ((err = checkentry(feo, VREG))) { fuse_ticket_drop(fdip->tick); goto undo; } bzero(fvdat, sizeof(*fvdat)); fuse_vnode_init(vp, fvdat, feo->nodeid, VREG, parentid); fvdat->nlookup++; vp->v_op = &fuse_vnops; cache_attrs(vp, feo); try_insert: VOP_UNLOCK(vp, 0 #if VOP_UNLOCK_TAKES_THREAD , td #endif ); /* * We can't let the vnode being vput() here, the caller wants * that do by herself. * That means hash collisions must be relaxed. With a funky * comparison function insertion will succeed, but we get a clear * sign of the collision and we can handle it by ourselves. */ err = vfs_hash_get(vp->v_mount, feo->nodeid, LK_EXCLUSIVE, td, &clashvp, fuse_vnode_cmp, &feo->nodeid); if (! err && clashvp) fuse_vnode_teardown(clashvp, td, cred, VREG); #if NEW_VNODES_ADJUSTED_MANUALLY if (! err) { err = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY #if VN_LOCK_TAKES_THREAD , td #endif ); if (err) printf("fuse4bsd: leaking vnode %p\n", vp); else { struct mount *mp = vp->v_mount; vp->v_mount = NULL; err = insmntque(vp, mp); } } #endif if (! err) err = vfs_hash_insert(vp, feo->nodeid, LK_EXCLUSIVE, td, &clashvp, fuse_vnode_fgdrop_cmp, fvdat); if (! err && fvdat->nid == FUSE_NULL_ID) { vfs_hash_remove(vp); fvdat->nid = feo->nodeid; goto try_insert; } if (err) { if (gone_good_old) fuse_send_forget(vp->v_mount, td, cred, feo->nodeid, 1, fdip); else { struct fuse_release_in *fri; uint64_t nodeid = feo->nodeid; uint64_t fh_id = ((struct fuse_open_out *)(feo + 1))->fh; struct fuse_pidcred *pidcred; fdisp_init(fdip, sizeof(*fri)); fdisp_make(fdip, vp->v_mount, FUSE_RELEASE, nodeid, td, cred); fri = fdip->indata; fri->fh = fh_id; fri->flags = OFLAGS(mode); /* * The node must be forgotten after the release. * Release is sent in the background as usual (that's not * necessary, but anyway...), so we do the forgetting * by a dedicated callback handler. * * Current pid/cred is attached to the ticket as a parameter * as the FORGET must be sent with current pid/cred but * it will be sent from another context. */ fiov_adjust(&fdip->tick->tk_aw_handler_parm, sizeof(*pidcred)); pidcred = fdip->tick->tk_aw_handler_parm.base; pidcred->pid = td->td_proc->p_pid; memcpy(&pidcred->cred, cred, sizeof(*cred)); fuse_insert_callback(fdip->tick, fuse_forgetful_handler); fuse_insert_message(fdip->tick); } return (err); } fdip->answ = gone_good_old ? NULL : feo + 1; return (0); undo: free(fvdat, M_FUSEVN); vp->v_data = NULL; return (err); } #endif int fuse_get_filehandle(struct vnode *vp, struct thread *td, struct ucred *cred, int mode, struct fuse_filehandle **fufhp, struct get_filehandle_param *gefhp) { struct fuse_vnode_data *fvdat = VTOFUD(vp); struct fuse_dispatcher fdi; struct fuse_open_in *foi; struct fuse_open_out *foo; int err = 0; struct fuse_filehandle *fufh = NULL; enum fuse_opcode op; int gone_create = 0; RECTIFY_TDCR(td, cred); /* * "create" messaging is almost transparent for get_filehandle. There are * some gotos and status variables though. * And it's totally transparent for fuse_open. * (By transparent I mean that they don't see the special "germic" state of * the vnode... if the vnode is a germ, it will be tried to be initialized * via a dedicated method, but from that on we go on as usual.) */ #if FUSE_HAS_CREATE if (vp->v_op == &fuse_germ_vnops) { KASSERT(gefhp, ("create_filehandle called without get_filehandle_param")); gone_create = 1; if (gefhp) gefhp->do_gc = 0; op = FUSE_OPEN; fdi.answ = NULL; if ((err = create_filehandle(vp, td, cred, mode, &fdi))) goto out; else if (fdi.answ) goto setup_filehandle; } #endif if (gefhp && gefhp->opcode) op = gefhp->opcode; else op = FUSE_OPEN; if (op == FUSE_OPENDIR) mode = FREAD; else mode &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC); if (! (gefhp && gefhp->do_new)) { struct standard_metrics_param stmp; stmp.mode = mode; stmp.op = op; ASSERT_VOP_LOCKED__FH(vp); err = iterate_filehandles(vp, td, cred, fuse_standard_metrics, &stmp); if (err) { if (err == -1) { DEBUG2G("suitable fh of vnode #%llu found\n", VTOILLU(vp)); fufh = stmp.fufh; err = 0; } goto out; } } DEBUG2G("we need to fetch a new filehandle for vnode #%llu\n", VTOILLU(vp)); fdisp_init(&fdi, sizeof(*foi)); fdisp_make_vp(&fdi, op, vp, td, cred); foi = fdi.indata; foi->flags = OFLAGS(mode); if ((err = fdisp_wait_answ(&fdi))) goto out; #if FUSE_HAS_CREATE setup_filehandle: #endif foo = fdi.answ; fufh = malloc(sizeof(*fufh), M_FUSEFH, M_WAITOK | M_ZERO); /* * We need to reference the vnode from fuse private file data * as files' f_vnode field might point to another vnode (eg., * if we are accessed through a nullfs overlay). */ fufh->fh_vp = vp; fufh->fh_id = foo->fh; fufh->flags = foo->open_flags; fuse_ticket_drop(fdi.tick); fufh->mode = mode; fufh->cred = crhold(cred); fufh->pid = td->td_proc->p_pid; fufh->useco = 1; fufh->op = op; ASSERT_VOP_ELOCKED__FH(vp); LIST_INSERT_HEAD(&fvdat->fh_head, fufh, fh_link); if (gefhp && gefhp->do_gc) { /* * The neat idea is that a cache cleanup is the best time for * a gc -- gc'ing unbound filehandles at inactive/reclaim time * is not enough, they can just accumulate while something * happens with the file, given the cache is flushed frequently * (otherwise there is no reason for the system to spawn them, * as the data can be read from core). * So then, let's just tie their gc to cache flush... * Luckily, this won't break the POSIX semantics that an * unlinked file is get kept until there is reference to it, * because that's done via the lookup/forget mechanism, and not * via filehandles. */ /* * Now we use unbound filehandles pretty rarely (as read/write * of regular files doesn't rely on them anymore), only during * exec and reading directories. It's pretty much unlikely that * one can be reused in any way, so we drop them * unconditionally. */ struct fuse_release_param frp; DEBUG2G("gc'ing...\n"); frp.fg = 0; frp.flush = 0; iterate_filehandles(vp, td, cred, release_filehandle, &frp); } fvdat->fh_counter++; #if _DEBUG2G if (gefhp && gefhp->do_gc) { DEBUG2G("after gc...\n"); vn_printf(vp, " "); } #endif out: if (gone_create && ! err) fufh->flags |= FOPEN_KEEP_CACHE; *fufhp = fufh; return (err); } static int fuse_open(ap) struct vop_open_args /* { struct vnode *a_vp; int a_mode; struct ucred *a_cred; struct thread *a_td; int a_fdidx; / struct file *a_fp; } */ *ap; { struct thread *td = ap->a_td; struct vnode *vp = ap->a_vp; struct ucred *cred = ap->a_cred; int mode = ap->a_mode; struct fuse_filehandle *fufh = NULL; int err = 0; #if VOP_OPEN_TAKES_FP struct file *fp = ap->a_fp; #else struct file *fp = NULL; #endif struct get_filehandle_param gefhp; /* * Contrary to that how it used to be, now we go on even if it's an * internal (fileless) open: to match the "specs", we must get the * keep_cache information (and act according to it). */ #if ! VOP_OPEN_TAKES_FP if (ap->a_fdidx >= 0) { /* * That certain "pretty disgustingly long chain" * by which we can put our hands of the file struct * assinged to this call. */ fp = td->td_proc->p_fd->fd_ofiles[ap->a_fdidx]; if (! fp) panic("nonneg file desc passed to us but no file there"); } #endif #if _DEBUG2G if (fp) DEBUG2G("fp->f_flag %#x, open mode %d\n", fp->f_flag, mode); #endif bzero(&gefhp, sizeof(gefhp)); gefhp.do_gc = 1; gefhp.do_new = 1; gefhp.opcode = (vp->v_type == VDIR) ? FUSE_OPENDIR : FUSE_OPEN; if ((err = fuse_get_filehandle(vp, td, cred, mode, &fufh, &gefhp))) goto out; /* * Types: VNON, VREG, VDIR, VBLK, VCHR, VLNK, VSOCK, VFIFO, VBAD * XXX: should we let the fs take over spec files or let the OS * directly handle their IO? */ /* This is neither got right, nor settled */ #if 0 if (! (vp->v_type == VFIFO || vp->v_type == VSOCK)) fp->f_ops = &fuse_fileops; #endif if (! (fufh->flags & FOPEN_KEEP_CACHE)) { DEBUG2G("flushing cache\n"); /* * This is a bit more heavyweight than the analogous function * used in Linux at this point (in their sys/mm/truncate.c, * the description says: * "invalidate_mapping_pages() will not block on IO activity. * It will not invalidate pages which are dirty, locked, under * writeback or mapped into pagetables.") */ err = vinvalbuf(vp, 0, td, PCATCH, 0); fufh->flags |= FOPEN_KEEP_CACHE; } if (! vp->v_object && /* just to avoid needless getattr'ing */ ! (err = vnode_create_vobject(vp, 0, td)) && /* * Duh, we have to check the result by ourselfves, * vnode_create_vobject swallows errors */ ! vp->v_object) err = ENODEV; if (fp && ! err) { fp->f_ops = &fuse_fileops; fufh->fp = fp; fp->f_data = fufh; } else fufh->useco--; out: if (VTOFUD(vp)) /* * If vnode was to be created, but FUSE_CREATE/FUSE_MKNOD * has failed, vp will have no private data. * It seems to be fine to handle that here. */ VTOFUD(vp)->flags &= ~FVP_ACCESS_NOOP; return (err); } static void fuse_send_release(struct fuse_filehandle *fufh, struct thread *td, struct ucred *cred, int flags, struct fuse_release_param *frp) { struct vnode *vp = fufh->fh_vp; struct fuse_dispatcher fdi; struct fuse_release_in *fri; int err = 0; KASSERT(! fufh->fp && fufh->useco == 0, ("active-looking fuse filehandle was attempted to release")); VTOFUD(vp)->fh_counter--; DEBUG2G("filehandle of vnode #%llu being released, fh counter now is %d\n", VTOILLU(vp), VTOFUD(vp)->fh_counter); if (vp->v_type == VBAD) goto out; fdisp_init(&fdi, sizeof(*fri)); fdisp_make_vp(&fdi, fufh->op == FUSE_OPENDIR ? FUSE_RELEASEDIR : FUSE_RELEASE, vp, td, cred); fri = fdi.indata; fri->fh = fufh->fh_id; fri->flags = OFLAGS(flags); #if FUSE_HAS_FLUSH_RELEASE if (frp->flush) fri->release_flags = FUSE_RELEASE_FLUSH; #endif if (frp->fg) { err = fdisp_wait_answ(&fdi); if (err) goto out; else fuse_ticket_drop(fdi.tick); } else { fuse_insert_callback(fdi.tick, NULL); fuse_insert_message(fdi.tick); } out: crfree(fufh->cred); free(fufh, M_FUSEFH); if (err && frp->err == 0) frp->err = err; } static int fuse_close_f(struct file *fp, struct thread *td) { struct fuse_filehandle *fufh; struct vnode *vp = NULL, *ovl_vp = fp->f_vnode; struct fuse_release_param frp; if (! _file_is_fat(fp)) panic("non-fat file passed to close routine"); vn_lock(ovl_vp, LK_EXCLUSIVE | LK_RETRY #if VN_LOCK_TAKES_THREAD , td #endif ); if (_file_is_bad(fp)) { DEBUG2G("fp %p, (overlay) vnode %p: went bad, giving up\n", fp, ovl_vp); goto out; } fufh = FTOFH(fp); vp = fufh->fh_vp; KASSERT(fufh->fp == fp, ("file's filehandle is stolen")); DEBUG2G("vnode #%llu, fufh owner %p, useco %d\n", VTOILLU(vp), fp, fufh->useco); fufh->useco--; ASSERT_VOP_ELOCKED__FH(vp); fufh->fp = NULL; if (fufh->useco == 0) LIST_REMOVE(fufh, fh_link); fp->f_data = NULL; if (fufh->useco == 0) { frp.err = 0; #if FUSE_HAS_FLUSH_RELEASE frp.fg = 1; frp.flush = 1; #else frp.fg = 0; frp.flush = 0; #endif fuse_send_release(fufh, td, NULL, fp->f_flag & ~O_EXCL, &frp); } out: if (fp->f_flag & FWRITE && vp) vp->v_writecount--; vput(ovl_vp); return (frp.err); } static int fuse_close(ap) struct vop_close_args /* { struct vnode *a_vp; int a_fflag; struct ucred *a_cred; struct thread *a_td; } */ *ap; { struct fuse_release_param frp; DEBUG2G("vnode #%llu\n", VTOILLU(ap->a_vp)); frp.err = 0; #if FUSE_HAS_FLUSH_RELEASE frp.fg = 1; frp.flush = 1; #else frp.fg = 0; frp.flush = 0; #endif fuse_filehandle_gc(ap->a_vp, ap->a_td, ap->a_cred, &frp); return (frp.err); } static int fuse_read(ap) struct vop_read_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; struct ucred *a_cred; } */ *ap; { struct vnode *vp = ap->a_vp; struct ucred *cred = ap->a_cred; struct uio *uio = ap->a_uio; int ioflag = ap->a_ioflag; DEBUG2G("vnode #%llu\n", VTOILLU(vp)); return fuse_io_vnode(vp, cred, uio, ioflag); } #define DIRCOOKEDSIZE FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + MAXNAMLEN + 1) static int fuse_readdir(ap) struct vop_readdir_args /* { struct vnode *a_vp; struct uio *a_uio; struct ucred *a_cred; int *a_eofflag; int *ncookies; u_long **a_cookies; } */ *ap; { struct vnode *vp = ap->a_vp; struct ucred *cred = ap->a_cred; struct uio *uio = ap->a_uio; struct thread *td = curthread; int err = 0; struct fuse_iov cookediov; struct fuse_filehandle *fufh; struct fuse_io_data fioda; struct get_filehandle_param gefhp; bzero(&gefhp, sizeof(gefhp)); gefhp.opcode = FUSE_OPENDIR; if ((err = fuse_get_filehandle(vp, td, cred, FREAD, &fufh, &gefhp))) { DEBUG2G("fetching filehandle failed\n"); return (err); } /* * In "most cases" this will do and won't have to resize the buffer * (that is, if the daemon has a "tight" view of the dir entries, * which is the case if userspace uses the old API or the new one * in the analogous way; by our terminology, this means * freclen == bytesavail) * (See fuse_dir_buffeater). */ fiov_init(&cookediov, DIRCOOKEDSIZE); bzero(&fioda, sizeof(fioda)); fioda.vp = vp; fioda.fufh = fufh; fioda.uio = uio; fioda.cred = cred; fioda.opcode = FUSE_READDIR; fioda.buffeater = fuse_dir_buffeater; fioda.param = &cookediov; /* * We tried hard to use bio, but offsety readdir can't be handled * properly that way -- the offset field of fuse_dirents can't be * mapped to an offset of a bio buffer */ err = fuse_read_directbackend(&fioda); fiov_teardown(&cookediov); fufh->useco--; fuse_invalidate_attr(vp); return (err); } /* A hack for being able to please the GENERIC_DIRSIZ macro */ struct pseudo_dirent { uint32_t d_namlen; }; static int fuse_dir_buffeater(struct uio *uio, size_t reqsize, void *buf, size_t bufsize, void *param) { /* * The daemon presents us with a virtual geometry when reading dirents. * This info is stored in the "off" field of fuse_dirent (which is the * struct we can read from her). "off" shows the absolut position of * the next entry (by definition). So I might pull 40 actual bytes from * the daemon, that might count as 60 by her virtual geometry, and when * I translate fuse_dirents to POSIX dirents, I have 20 bytes to pass * to the userspace reader. * * How to keep these in sync? We don't want to make the general read * routine complex (to which here we serve a background, and which * naively treats reading by a liner logic). So we artifically inflate * dirents: we pad them with as much zeros as we need them to get to * next offset (as the deamon declared), and we pass it to the reader * thusly (this will work as fuse dirents are bigger than std ones). So * we do more IO with the reader than absolutely necessary, but it's * hardly a problem as the expensive thing is reading from the daemon, * not sending data to the reader. * * There is no use to change this simple geometry translation scheme * 'till we do page caching. [We do now, but it's still fine as is.] */ struct dirent *de; struct fuse_dirent *fudge; int err = 0; size_t freclen; int cou = 0; int bytesavail; struct fuse_iov *cookediov; KASSERT(bufsize <= reqsize, ("read more than asked for?")); DEBUG2G("starting\n"); /* * Sanity check: if this fails, we would overrun the allocated space * upon entering the loop below, so we'd better leave right now. * If so, we return -1 to terminate reading. */ if (bufsize < FUSE_NAME_OFFSET) return (-1); cookediov = param; DEBUG2G("entering loop with bufsize %d\n", (int)bufsize); /* * Can we avoid infite loops? An infinite loop could occur only if we * leave this function with 0 return value, because otherwise we wont't * be called again. But both 0 exit points imply that some data has * been consumed... because * 1) if a turn is not aborted, it consumes positive amount of data * 2) the 0 jump-out from within the loop can't occur in the first * turn * 3) if we exit 0 after the loop is over, then at least one turn * was completed, otherwise we hed exited above with -1. */ for (;;) { if (bufsize < FUSE_NAME_OFFSET) { err = -1; break; } cou++; fudge = (struct fuse_dirent *)buf; freclen = FUSE_DIRENT_SIZE(fudge); DEBUG("bufsize %d, freclen %d\n", (int)bufsize, (int)freclen); /* * Here is an exit condition: we terminate the whole reading * process if a fresh chunk of buffer is already too short to * cut out an entry. * (It it was not the first turn in the loop, nevermind, * return with asking for more) */ if (bufsize < freclen) { err = ((cou == 1) ? -1 : 0); break; } #if FUSELIB_CONFORM_BIOREAD if (isbzero(buf, FUSE_NAME_OFFSET)) { err = -1; break; } #endif /* Sanity checks */ if (!fudge->namelen || fudge->namelen > MAXNAMLEN) { DEBUG2G("bogus namelen %d at turn %d\n", fudge->namelen, cou); err = EINVAL; break; } bytesavail = GENERIC_DIRSIZ((struct pseudo_dirent *)&fudge->namelen); /* * Exit condition 2: if the pretended amount of input is more * than that the userspace wants, then it's time to stop * reading. */ if (bytesavail > uio->uio_resid) { DEBUG2G("leaving at %d-th item as we have %d bytes but only %d is asked for\n", cou, bytesavail, uio->uio_resid); err = -1; break; } fiov_refresh(cookediov); fiov_adjust(cookediov, bytesavail); de = (struct dirent *) cookediov->base; de->d_fileno = fudge->ino; /* XXX cast from 64 to 32 bytes */ de->d_reclen = bytesavail; de->d_type = fudge->type; de->d_namlen = fudge->namelen; memcpy((char *)cookediov->base + sizeof(struct dirent) - MAXNAMLEN - 1, (char *)buf + FUSE_NAME_OFFSET, fudge->namelen); ((char *)cookediov->base)[bytesavail] = '\0'; DEBUG("bytesavail %d, fudge->off %llu, fudge->namelen %d, uio->uio_offset %d, name %s\n", bytesavail, (unsigned long long)fudge->off, fudge->namelen, (int)uio->uio_offset, (char *)cookediov->base + sizeof(struct dirent) - MAXNAMLEN - 1); err = uiomove(cookediov->base, cookediov->len, uio); if (err) break; buf = (char*)buf + freclen; bufsize -= freclen; uio->uio_offset = fudge->off; } return (err); } static int fuse_readlink(ap) struct vop_readlink_args /* { struct vnode *a_vp; struct uio *a_uio; struct ucred *a_cred; } */ *ap; { struct vnode *vp = ap->a_vp; struct uio *uio = ap->a_uio; struct fuse_dispatcher fdi; int err; if ((err = fdisp_simple_putget(&fdi, FUSE_READLINK, vp, curthread, ap->a_cred))) return (err); if (((char *)fdi.answ)[0] == '/' && fusefs_get_data(vp->v_mount)->dataflag & FSESS_PUSH_SYMLINKS_IN) { char *mpth = vp->v_mount->mnt_stat.f_mntonname; err = uiomove(mpth, strlen(mpth), uio); } if (! err) err = uiomove(fdi.answ, fdi.iosize, uio); fuse_ticket_drop(fdi.tick); fuse_invalidate_attr(vp); return (err); } static __inline int fuse_newentry_core(struct vnode *dvp, struct vnode **vpp, enum vtype vtyp, struct fuse_dispatcher *fdip) { struct mount *mp = dvp->v_mount; struct fuse_entry_out *feo; int err = 0; KASSERT(! (mp->mnt_flag & MNT_RDONLY), ("request for new entry in a read-only mount")); if ((err = fdisp_wait_answ(fdip))) return (err); feo = fdip->answ; if ((err = checkentry(feo, vtyp))) goto out; /* * The Linux code doesn't seem to make a fuss about * getting a nodeid for a new entry which is already * in use. Therefore we used to do the same. * This is not possible with our implementation of * atomic create+open; so, even if we could ignore this * fuzz here, we don't do, for the sake of consistency. */ err = fuse_vget_i(mp, curthread, feo->nodeid, vtyp, vpp, VG_FORCENEW, VTOI(dvp)); if (err) { DEBUG2G("failed to fetch vnode for nodeid\n"); fuse_send_forget(mp, curthread, NULL, feo->nodeid, 1, fdip); return (err); } VTOFUD(*vpp)->nlookup++; cache_attrs(*vpp, feo); out: fuse_ticket_drop(fdip->tick); return (err); } static int fuse_newentry_backend(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, enum fuse_opcode op, void *buf, size_t bufsize, enum vtype vtyp) { struct fuse_dispatcher fdi; int err; fdisp_init(&fdi, 0); fuse_make_entry_req(dvp->v_mount, VTOI(dvp), cnp, op, buf, bufsize, &fdi); err = fuse_newentry_core(dvp, vpp, vtyp, &fdi); fuse_invalidate_attr(dvp); return (err); } static int fuse_mknod(ap) struct vop_mknod_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ *ap; { struct vnode *dvp = ap->a_dvp; struct vnode **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct vattr *vap = ap->a_vap; struct fuse_mknod_in fmni; fmni.mode = MAKEIMODE(vap->va_type, vap->va_mode); fmni.rdev = vap->va_rdev; return fuse_newentry_backend(dvp, vpp, cnp, FUSE_MKNOD, &fmni, sizeof(fmni), vap->va_type); } static int fuse_create(ap) struct vop_create_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ *ap; { struct vnode *dvp = ap->a_dvp; struct vnode **vpp = ap->a_vpp; struct vattr *vap = ap->a_vap; #if FUSE_HAS_CREATE struct fuse_vnode_data *fvdat; int err; if (vap->va_type != VREG || fusefs_get_data(dvp->v_mount)->dataflag & FSESS_NOCREATE) goto good_old; /* * We cobble together here a new vnode as the caller expects that, * but we don't yet fully initialize it (that will happen when it * will be opened). We keep it in a "germic" state. */ if ((err = getnewvnode("fuse", dvp->v_mount, &fuse_vnops, vpp))) return (err); if ((err = vn_lock(*vpp, LK_EXCLUSIVE | LK_RETRY #if VN_LOCK_TAKES_THREAD , curthread #endif ))) { #if NEW_VNODES_ADJUSTED_MANUALLY printf("fuse4bsd: leaking vnode %p\n", *vpp); #endif return (err); } fvdat = malloc(sizeof(*fvdat), M_FUSEVN, M_WAITOK | M_ZERO); fvdat->parent_nid = VTOI(dvp); /* * We overload some fields of the vnode data to carry the information * which will be needed to make the proper CREATE query in open. * germcnp is a dedicated field for this purpose though. */ fvdat->flags = MAKEIMODE(vap->va_type, vap->va_mode); fvdat->germcnp = ap->a_cnp; /* * Stub vnops, almost the same as "dead", with the exception of the * critical ones which will let the vnode get fully emerged. */ (*vpp)->v_op = &fuse_germ_vnops; (*vpp)->v_data = fvdat; #if NEW_VNODES_ADJUSTED_MANUALLY (*vpp)->v_mount = dvp->v_mount; #endif fuse_invalidate_attr(dvp); return (0); good_old: #endif vap->va_rdev = 0; return (VOP_MKNOD(dvp, vpp, ap->a_cnp, vap)); } static int fuse_mkdir(ap) struct vop_mkdir_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; } */ *ap; { struct vnode *dvp = ap->a_dvp; struct vnode **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; struct vattr *vap = ap->a_vap; struct fuse_mkdir_in fmdi; fmdi.mode = MAKEIMODE(vap->va_type, vap->va_mode); return fuse_newentry_backend(dvp, vpp, cnp, FUSE_MKDIR, &fmdi, sizeof(fmdi), VDIR); } static int fuse_link(ap) struct vop_link_args /* { struct vnode *a_tdvp; struct vnode *a_vp; struct componentname *a_cnp; } */ *ap; { struct vnode *dvp = ap->a_tdvp; struct vnode *vp = ap->a_vp; struct componentname *cnp = ap->a_cnp; struct fuse_dispatcher fdi; struct fuse_link_in fli; struct fuse_entry_out *feo; int err = 0; if (dvp->v_mount != vp->v_mount) return (EXDEV); fli.oldnodeid = VTOI(vp); /* * Unlike Linux, we proceed here lazily: here we do nothing on * the kernel side for registering the new, hardlinked entry. * (That will just happen when the hardlinked entry is looked up * first time). We just send the request to the daemon. * This suits better for the BSD VFS. */ fdisp_init(&fdi, 0); fuse_make_entry_req(dvp->v_mount, VTOI(dvp), cnp, FUSE_LINK, &fli, sizeof(fli), &fdi); if ((err = fdisp_wait_answ(&fdi))) return (err); feo = fdi.answ; err = checkentry(feo, vp->v_type); fuse_ticket_drop(fdi.tick); fuse_invalidate_attr(dvp); /* * It depends on userspace if the hardlinked entry is really the * same vnode or not. Sort of unconventionally, the latter happens * if linking is managed by the hi-level FUSE library (in which case * syncing between the two nodes is up to the actual fs code). * Therefore we can't just cache the attrs we got for the hardlink node, * -- that regards to the hardlinked node and not the original. * What we do instead is invalidating cached attrs of the original so * the fs gets a chance to pass on updated attributes also for the * original node. * * See also remark at the similar place in the Linux kernel code. */ fuse_invalidate_attr(vp); VTOFUD(vp)->nlookup++; return (err); } static int fuse_symlink(ap) struct vop_symlink_args /* { struct vnode *a_dvp; struct vnode **a_vpp; struct componentname *a_cnp; struct vattr *a_vap; char *a_target; } */ *ap; { struct vnode *dvp = ap->a_dvp; struct vnode **vpp = ap->a_vpp; struct componentname *cnp = ap->a_cnp; char *target = ap->a_target; struct fuse_dispatcher fdi; size_t len; int err; /* * Unlike the other creator type calls, here we have to create a message * where the name of the new entry comes first, and the data describing * the entry comes second. * Hence we can't rely on our handy fuse_newentry_backend() routine, * but put together the message manually and just call the core part. */ len = strlen(target) + 1; fdisp_init(&fdi, len + cnp->cn_namelen + 1); fdisp_make_vp(&fdi, FUSE_SYMLINK, dvp, curthread, NULL); memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; memcpy((char *)fdi.indata + cnp->cn_namelen + 1, target, len); err = fuse_newentry_core(dvp, vpp, VLNK, &fdi); fuse_invalidate_attr(dvp); return (err); } static __inline int fuse_remove_backend(struct vnode *dvp, struct vnode *vp, struct componentname *cnp, enum fuse_opcode op) { struct fuse_dispatcher fdi; int err = 0; fdisp_init(&fdi, cnp->cn_namelen + 1); fdisp_make_vp(&fdi, op, dvp, curthread, NULL); memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen); ((char *)fdi.indata)[cnp->cn_namelen] = '\0'; if (! (err = fdisp_wait_answ(&fdi))) fuse_ticket_drop(fdi.tick); fuse_invalidate_attr(dvp); fuse_invalidate_attr(vp); return (err); } static int fuse_remove(ap) struct vop_remove_args /* { struct vnode *a_dvp; struct vnode *a_vp; struct componentname *a_cnp; } */ *ap; { return (fuse_remove_backend(ap->a_dvp, ap->a_vp, ap->a_cnp, FUSE_UNLINK)); } static int fuse_rmdir(ap) struct vop_rmdir_args /* { struct vnode *a_dvp; struct vnode *a_vp; struct componentname *a_cnp; } */ *ap; { struct vnode *vp = ap->a_vp; int err; struct vnode *xvp; struct parentmanager_param pmp; err = fuse_remove_backend(ap->a_dvp, vp, ap->a_cnp, FUSE_RMDIR); if (err) return (err); /* * Resetting parent field via VFS hash API so * that the nodeid of this directory can be * reused */ pmp.nodeid = VTOI(vp); pmp.parent_nid = 0; pmp.valid = 0; err = vfs_hash_get(vp->v_mount, pmp.nodeid, 0, curthread, &xvp, fuse_vnode_setparent_cmp, &pmp); KASSERT(xvp == NULL, ("findparent routine has fetched a vnode")); return err; } static __inline int fuse_rename_core(struct vnode *fdvp, struct componentname *fcnp, struct vnode *tdvp, struct componentname *tcnp) { struct fuse_dispatcher fdi; struct fuse_rename_in *fri; int err = 0; fdisp_init(&fdi, sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 2); fdisp_make_vp(&fdi, FUSE_RENAME, fdvp, curthread, NULL); fri = fdi.indata; fri->newdir = VTOI(tdvp); memcpy((char *)fdi.indata + sizeof(*fri), fcnp->cn_nameptr, fcnp->cn_namelen); ((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen] = '\0'; memcpy((char *)fdi.indata + sizeof(*fri) + fcnp->cn_namelen + 1, tcnp->cn_nameptr, tcnp->cn_namelen); ((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 1] = '\0'; if (! (err = fdisp_wait_answ(&fdi))) fuse_ticket_drop(fdi.tick); fuse_invalidate_attr(fdvp); if (tdvp != fdvp) fuse_invalidate_attr(tdvp); return (err); } static int fuse_rename(ap) struct vop_rename_args /* { struct vnode *a_fdvp; struct vnode *a_fvp; struct componentname *a_fcnp; struct vnode *a_tdvp; struct vnode *a_tvp; struct componentname *a_tcnp; } */ *ap; { struct vnode *tvp = ap->a_tvp; struct vnode *tdvp = ap->a_tdvp; struct vnode *fvp = ap->a_fvp; struct vnode *fdvp = ap->a_fdvp; struct componentname *tcnp = ap->a_tcnp; struct componentname *fcnp = ap->a_fcnp; int doingdirectory = 0; int err = 0; struct thread *td; struct fuse_access_param facp; uint64_t fnid, tdnid; struct fuse_data *data = NULL; struct parentmanager_param pmp; struct vnode *xvp; td = curthread; bzero(&facp, sizeof(facp)); /* * Check for cross-device rename. */ if (fvp->v_mount != tdvp->v_mount || (tvp && fvp->v_mount != tvp->v_mount)) { DEBUG("cross-device move. Why am I expected to deal with it?!\n"); err = EXDEV; goto out; } /* * To ensure consistent view upon walking the vnode tree, * we let only one rename op at a time. * (FYI: Linux does this at the VFS level, BSDs usually * go for more fine grained solutions. Now it's good enough * for us.) * * Although we want to guarantee exclusive access for the lock holder, * we use an sx lock instead of a mutex, because it lets us sleep * while we are holding the lock. */ data = fusefs_get_data(tdvp->v_mount); sx_xlock(&data->rename_lock); /* * Check if just deleting a link name. */ if (fvp == tvp) { if (fvp->v_type == VDIR) { err = EINVAL; goto out; } sx_unlock(&data->rename_lock); /* * Release destination. */ vput(tdvp); vput(tvp); /* * Delete source. Pretty bizarre stuff. */ vrele(fdvp); vrele(fvp); fcnp->cn_flags &= ~MODMASK; fcnp->cn_flags |= LOCKPARENT | LOCKLEAF; fcnp->cn_nameiop = DELETE; VREF(fdvp); err = relookup(fdvp, &fvp, fcnp); if (err == 0) vrele(fdvp); return VOP_REMOVE(fdvp, fvp, fcnp); } /* * No LK_RETRY. See discussion in thread * http://thread.gmane.org/gmane.os.dragonfly-bsd.kernel/8952/focus=8964 */ err = vn_lock(fvp, LK_EXCLUSIVE #if VN_LOCK_TAKES_THREAD , td #endif ); if (err) goto out; if (fvp->v_type == VDIR) { /* * Avoid ".", "..", and aliases of "." for obvious reasons. */ if ((fcnp->cn_namelen == 1 && fcnp->cn_nameptr[0] == '.') || fdvp == fvp || ((fcnp->cn_flags | tcnp->cn_flags) & ISDOTDOT)) { VOP_UNLOCK(fvp, 0 #if VOP_UNLOCK_TAKES_THREAD , td #endif ); err = EINVAL; goto out; } doingdirectory = 1; } /* vrele(fdvp); ???? */ /* * If ".." must be changed (ie the directory gets a new * parent) then the source directory must not be in the * directory hierarchy above the target, as this would * orphan everything below the source directory. Also * the user must have write permission in the source so * as to be able to change "..". */ err = fuse_access_i(fvp, VWRITE, tcnp->cn_cred, tcnp->cn_thread, &facp); fnid = VTOI(fvp); VOP_UNLOCK(fvp, 0 #if VOP_UNLOCK_TAKES_THREAD , td #endif ); if (err) goto out; if (doingdirectory && fdvp != tdvp) { /* * Check for pathname conflict. * * That is, moved vnode should not be over target and * if target is in an isolated subtree, target and source * should be in the same subtree. */ int isolated = 0; uint64_t trootid = 0; pmp.nodeid = VTOI(tdvp); climbup: if (isolated) /* Climbing up again, this time from fvp */ pmp.nodeid = fnid; for (;;) { if (! isolated && pmp.nodeid == fnid) { /* target is above source, bail out */ err = EINVAL; goto out; } if (pmp.nodeid == FUSE_ROOT_ID) /* * we successfully arrived to the top, * life can go on */ break; /* fetching parent info via abusing vfs_hash_get */ pmp.valid = 0; err = vfs_hash_get(fvp->v_mount, pmp.nodeid, 0, td, &xvp, fuse_vnode_findparent_cmp, &pmp); KASSERT(xvp == NULL, ("findparent routine has fetched a vnode")); if (err) goto out; if (! pmp.valid) /* * No valid parent found, we are in an isolated * subtree. */ break; pmp.nodeid = pmp.parent_nid; } if (isolated) { /* * Second climbup completed, * let's see if local roots match... */ if (trootid != pmp.nodeid) { err = EINVAL; goto out; } } else if (! pmp.valid) { /* * ... we are isolated: in this case we require that * target and source lives in the same subtree. * To see that, we'll have to climb up also from fvp. */ isolated = 1; trootid = pmp.nodeid; goto climbup; } } /* * If the target doesn't exist, link the target to the source and * unlink the source. Otherwise, rewrite the target directory to * reference the source and remove the original entry. */ if (tvp) { /* * Target must be empty if a directory and have no links * to it. Also, ensure source and target are compatible * (both directories, or both not directories). */ if (tvp->v_type == VDIR) { /* * "not empty" misery is handled by the fine daemon * (in nulix too) */ if (!doingdirectory) { err = ENOTDIR; goto out; } /* * Update name cache since directory is going away. */ /* cache_purge(tdvp); */ } else if (doingdirectory) { err = ENOTDIR; goto out; } } /* Fuse-specific code */ if ((err = fuse_rename_core(fdvp, fcnp, tdvp, tcnp))) goto out; out: tdnid = VTOI(tdvp); if (tdvp == tvp) vrele(tdvp); else vput(tdvp); if (tvp) vput(tvp); vrele(fdvp); if (! err) { /* Adjusting parent field via VFS hash API */ pmp.nodeid = VTOI(fvp); pmp.parent_nid = tdnid; pmp.valid = 0; err = vfs_hash_get(fvp->v_mount, pmp.nodeid, 0, td, &xvp, fuse_vnode_setparent_cmp, &pmp); KASSERT(xvp == NULL, ("findparent routine has fetched a vnode")); } vrele(fvp); if (data) sx_xunlock(&data->rename_lock); return err; } static int fuse_setattr(ap) struct vop_setattr_args /* { struct vnode *a_vp; struct vattr *a_vap; struct ucred *a_cred; struct thread *a_td; } */ *ap; { struct vattr *vap = ap->a_vap; struct vnode *vp = ap->a_vp; struct ucred *cred = ap->a_cred; struct thread *td = ap->a_td; int err = 0; struct fuse_dispatcher fdi; struct fuse_setattr_in *fsai; enum vtype vtyp; struct fuse_access_param facp; /* * Check for unsettable attributes. */ if ((vap->va_type != VNON) || (vap->va_nlink != VNOVAL) || (vap->va_fsid != VNOVAL) || (vap->va_fileid != VNOVAL) || (vap->va_blocksize != VNOVAL) || (vap->va_rdev != VNOVAL) || ((int)vap->va_bytes != VNOVAL) || (vap->va_gen != VNOVAL)) return (EINVAL); if (vap->va_flags != VNOVAL) return (EOPNOTSUPP); fdisp_init(&fdi, sizeof(*fsai)); fdisp_make_vp(&fdi, FUSE_SETATTR, vp, td, cred); fsai = fdi.indata; KASSERT(isbzero(fsai, sizeof(*fsai)), ("non-clean buffer passed to setattr")); bzero(&facp, sizeof(facp)); #if FUSE_KERNELABI_GEQ(7, 3) #define FUSEATTR(x) x #else #define FUSEATTR(x) attr.x #endif facp.xuid = vap->va_uid; facp.xgid = vap->va_gid; if (vap->va_uid != (uid_t)VNOVAL) { facp.facc_flags |= FACCESS_CHOWN; fsai->FUSEATTR(uid) = vap->va_uid; fsai->valid |= FATTR_UID; } if (vap->va_gid != (gid_t)VNOVAL) { facp.facc_flags |= FACCESS_CHOWN; fsai->FUSEATTR(gid) = vap->va_gid; fsai->valid |= FATTR_GID; } if (vap->va_size != VNOVAL) { fsai->FUSEATTR(size) = vap->va_size; fsai->valid |= FATTR_SIZE; } if (vap->va_mode != (mode_t)VNOVAL) { #if _DEBUG if (vap->va_mode & S_IFMT) DEBUG("fuse_setattr -- weird: " "format bits in mode field, 0%o\n", vap->va_mode); #endif if (vap->va_mode & S_ISGID) facp.facc_flags |= FACCESS_SETGID; fsai->FUSEATTR(mode) = vap->va_mode & ALLPERMS; fsai->valid |= FATTR_MODE; } /* XXX: fuse code says, the (atime, mtime) pair should be set * atomically. On the contrary, BSD code doesn't seem to care * about such a constraint. Is this a fuseism or a linuxism? * Should we enforce the constraint? */ if (vap->va_atime.tv_sec != VNOVAL) { /* XXX on some platforms 32 -> bits cast ? */ fsai->FUSEATTR(atime) = vap->va_atime.tv_sec; fsai->FUSEATTR(atimensec) = vap->va_atime.tv_nsec; fsai->valid |= FATTR_ATIME; } if (vap->va_mtime.tv_sec != VNOVAL) { fsai->FUSEATTR(mtime) = vap->va_mtime.tv_sec; fsai->FUSEATTR(mtimensec) = vap->va_mtime.tv_nsec; fsai->valid |= FATTR_MTIME; } #undef FUSEATTR if (! fsai->valid) goto out; if (fsai->valid & FATTR_SIZE && vp->v_type == VDIR) { err = EISDIR; goto out; } if (vp->v_mount->mnt_flag & MNT_RDONLY && (fsai->valid & ~FATTR_SIZE || vp->v_type == VREG)) { err = EROFS; goto out; } if (fsai->valid & ~FATTR_SIZE) err = fuse_access_i(vp, VADMIN, cred, td, &facp); facp.facc_flags &= ~FACCESS_XQUERIES; /* * If we set the times and nothing else, we get one more choice, * as the quoted ufs_setattr comment explains... */ /* * From utimes(2): * If times is NULL, ... The caller must be the owner of * the file, have permission to write the file, or be the * super-user. * If times is non-NULL, ... The caller must be the owner of * the file or be the super-user. */ if (err && ! (fsai->valid & ~(FATTR_ATIME | FATTR_MTIME)) && vap->va_vaflags & VA_UTIMES_NULL) err = fuse_access_i(vp, VWRITE, cred, td, &facp); if (err) { fuse_invalidate_attr(vp); goto out; } if ((err = fdisp_wait_answ(&fdi))) { fuse_invalidate_attr(vp); return (err); } vtyp = IFTOVT(((struct fuse_attr_out *)fdi.answ)->attr.mode); if (vp->v_type != vtyp) { if (vp->v_type == VNON && vtyp != VNON) { DEBUG2G("vnode #%llu with no type\n", VTOILLU(vp)); vp->v_type = vtyp; } else { fuse_vnode_ditch(vp, td); err = ENOTCONN; goto out; } } cache_attrs(vp, (struct fuse_attr_out *)fdi.answ); out: fuse_ticket_drop(fdi.tick); return (err); } static int fuse_fsync_filehandle(struct fuse_filehandle *fufh, struct thread *td, struct ucred *cred, void *param) { struct fuse_fsync_in *ffsi; struct fuse_dispatcher *fdip = param; fdip->iosize = sizeof(*ffsi); fdip->tick = NULL; fdisp_make_vp(fdip, (fufh->op == FUSE_OPENDIR) ? FUSE_FSYNCDIR : FUSE_FSYNC, fufh->fh_vp, td, cred); ffsi = fdip->indata; ffsi->fh = fufh->fh_id; /* * this sets that we wanna sync file data, * not just metadata; a 0 value would have no * counterpart in BSD semantics */ ffsi->fsync_flags = 1; fuse_insert_callback(fdip->tick, fuse_fsync_handler); fuse_insert_message(fdip->tick); return (0); } static int fuse_fsync(ap) struct vop_fsync_args /* { struct vnodeop_desc *a_desc; struct vnode * a_vp; struct ucred * a_cred; int a_waitfor; struct thread * a_td; } */ *ap; { struct vnode *vp = ap->a_vp; struct thread *td = ap->a_td; int err = 0; struct fuse_dispatcher fdi; DEBUG("got flag %d\n", ap->a_waitfor); /* * Usually, the call to vop_stdfsync is expected to do nothing, as we * tend to leave no dirty buffers behind. However, they might show up, * eg., after an interrupted write. * To be able to release the kernel's cleanup-dirty-buffers machinery * this is advised to be inserted here. */ if ((err = vop_stdfsync(ap))) return (err); /* * In Linux, the fsync syscall handler is file based. * Hence in fuse too -- and this approach does make sense, * for exapmle, when it comes to implementing things like * sshfs: the sshfs userspace fsync handler flushes data * associated with the given filehandle, ie. sftp * messaging thread. * * On the other hand, BSD fsync is inherently not file * but vnode based: even fsync(2), to which one passes * a file descriptor, the corresponding file is used for * nothing but looking up the vnode behind (see fsync() * in kern/vfs_syscalls.c). * * We have thus two choices here: either grab the first * open file and use that for the fsync message or run * through all files (at least, the ones we have acces to, * ie., those belonging to the current process). The first * is bad: as we mentioned concerning sshfs, dirty data can belong * to each ssh messaging thread, being associated to file * handles independently. * * So we wanna sync all our open files. "Nowait" sync is easy, * just walk over all the files, and send FUSE_FSYNC(DIR) with * a null callback, and leave. "Wait" sync is harder: syncing * the files linearly, one after the other would be very easy * indeed but would be far more than a lethal dose of the KISS * principle. So sending of the messages and waiting for them * should be done synchronously. The messaging backend is flexible * enough for making the implementation of this not too hard, * but now I don't wanna go mucking with the proper handling of * interrupts, and other issues; and I don't wanna break the nice * hi-level messaging API which serves us well otherwise. So * currently I just say no here... * * Just to note: even the "nowait" type fsync could be optimized * if we went beyond the api, and lock/unlock all mutexes (tickets', * messages', callbacks') only once, and take out/put in stuff for all * files together, with one big breath. But doing not so is not as much * overhead as it would be worth for the trouble. */ /* * It seemed to be a good idea to lock the filehandle lock only before * doing iterate_filehandle but that configuration is suspected to cause * LOR alerts, so now we get the filehandle lock before the fuse_data * lock. */ ASSERT_VOP_LOCKED__FH(vp); if (fusefs_get_data(vp->v_mount)->dataflag & (vp->v_type == VDIR ? FSESS_NOFSYNCDIR : FSESS_NOFSYNC)) goto out; fdisp_init(&fdi, 0); iterate_filehandles(vp, td, NULL, fuse_fsync_filehandle, &fdi); out: return (err); } static int fuse_write(ap) struct vop_write_args /* { struct vnode *a_vp; struct uio *a_uio; int a_ioflag; struct ucred *a_cred; } */ *ap; { struct vnode *vp = ap->a_vp; struct ucred *cred = ap->a_cred; struct uio *uio = ap->a_uio; int ioflag = ap->a_ioflag; DEBUG2G("vnode #%llu\n", VTOILLU(vp)); return fuse_io_vnode(vp, cred, uio, ioflag); } /* * Do an I/O operation to/from a cache block. This may be called * synchronously or from an nfsiod. */ static int fuse_strategy(ap) struct vop_strategy_args /* { struct vnode *a_vp; struct buf *a_bp; } */ *ap; { (void)fuse_strategy_i(ap->a_vp, ap->a_bp, NULL, 0); /* * This is a dangerous function. If returns error, that might mean a * panic. We prefer pretty much anything over being forced to panic by * a malicious daemon (a demon?). So we just return 0 anyway. You * should never mind this: this function has its own error propagation * mechanism via the argument buffer, so not-that-melodramatic * residents of the call chain still will be able to know what to do. */ return (0); } /* * [gs]etpages taken & stripped off from nfsclient */ #ifndef PAGEOP_TRANSLATE_UIO #define PAGEOP_TRANSLATE_UIO 1 #endif #if PAGEOP_TRANSLATE_UIO #define FUSE_PAGEOPS_RESID uio.uio_resid #else #define FUSE_PAGEOPS_RESID bp->b_resid #endif int fuse_getpages(ap) struct vop_getpages_args /* { struct vnode *a_vp; vm_page_t *a_m; int a_count; int a_reqpage; vm_ooffset_t a_offset; } */ *ap; { int i, error, nextoff, size, toff, count, npages; #if PAGEOP_TRANSLATE_UIO struct uio uio; struct iovec iov; #endif vm_offset_t kva; struct buf *bp; struct vnode *vp; struct thread *td; struct ucred *cred; vm_page_t *pages; DEBUG2G("heh\n"); vp = ap->a_vp; KASSERT(vp->v_object, ("objectless vp passed to getpages")); td = curthread; /* XXX */ cred = curthread->td_ucred; /* XXX */ pages = ap->a_m; count = ap->a_count; npages = btoc(count); /* * If the requested page is partially valid, just return it and * allow the pager to zero-out the blanks. Partially valid pages * can only occur at the file EOF. */ { vm_page_t m = pages[ap->a_reqpage]; VM_OBJECT_LOCK(vp->v_object); vm_page_lock_queues(); if (m->valid != 0) { /* handled by vm_fault now */ /* vm_page_zero_invalid(m, TRUE); */ for (i = 0; i < npages; ++i) { if (i != ap->a_reqpage) vm_page_free(pages[i]); } vm_page_unlock_queues(); VM_OBJECT_UNLOCK(vp->v_object); return(0); } vm_page_unlock_queues(); VM_OBJECT_UNLOCK(vp->v_object); } /* * We use only the kva address for the buffer, but this is extremely * convienient and fast. */ bp = getpbuf(&fuse_pbuf_freecnt); kva = (vm_offset_t) bp->b_data; pmap_qenter(kva, pages, npages); cnt.v_vnodein++; cnt.v_vnodepgsin += npages; #if PAGEOP_TRANSLATE_UIO iov.iov_base = (caddr_t) kva; iov.iov_len = count; uio.uio_iov = &iov; uio.uio_iovcnt = 1; uio.uio_offset = IDX_TO_OFF(pages[0]->pindex); uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_READ; uio.uio_td = td; error = fuse_io_dispatch(vp, NULL, &uio, cred, FREAD | O_DIRECT, td); #else error = fuse_strategy_i(vp, bp, NULL, 0); #endif pmap_qremove(kva, npages); relpbuf(bp, &fuse_pbuf_freecnt); if (error && (FUSE_PAGEOPS_RESID == count)) { DEBUG2G("error %d\n", error); VM_OBJECT_LOCK(vp->v_object); vm_page_lock_queues(); for (i = 0; i < npages; ++i) { if (i != ap->a_reqpage) vm_page_free(pages[i]); } vm_page_unlock_queues(); VM_OBJECT_UNLOCK(vp->v_object); return VM_PAGER_ERROR; } /* * Calculate the number of bytes read and validate only that number * of bytes. Note that due to pending writes, size may be 0. This * does not mean that the remaining data is invalid! */ size = count - FUSE_PAGEOPS_RESID; VM_OBJECT_LOCK(vp->v_object); vm_page_lock_queues(); for (i = 0, toff = 0; i < npages; i++, toff = nextoff) { vm_page_t m; nextoff = toff + PAGE_SIZE; m = pages[i]; if (nextoff <= size) { /* * Read operation filled an entire page */ m->valid = VM_PAGE_BITS_ALL; vm_page_undirty(m); } else if (size > toff) { /* * Read operation filled a partial page. */ m->valid = 0; vm_page_set_validclean(m, 0, size - toff); /* handled by vm_fault now */ /* vm_page_zero_invalid(m, TRUE); */ } else { /* * Read operation was short. If no error occured * we may have hit a zero-fill section. We simply * leave valid set to 0. */ ; } if (i != ap->a_reqpage) { /* * Whether or not to leave the page activated is up in * the air, but we should put the page on a page queue * somewhere (it already is in the object). Result: * It appears that emperical results show that * deactivating pages is best. */ /* * Just in case someone was asking for this page we * now tell them that it is ok to use. */ if (!error) { #ifdef VPO_WANTED if (m->oflags & VPO_WANTED) #else if (m->flags & PG_WANTED) #endif vm_page_activate(m); else vm_page_deactivate(m); vm_page_wakeup(m); } else { vm_page_free(m); } } } vm_page_unlock_queues(); VM_OBJECT_UNLOCK(vp->v_object); return 0; } /* * Vnode op for VM putpages. */ int fuse_putpages(ap) struct vop_putpages_args /* { struct vnode *a_vp; vm_page_t *a_m; int a_count; int a_sync; int *a_rtvals; vm_ooffset_t a_offset; } */ *ap; { #if PAGEOP_TRANSLATE_UIO struct uio uio; struct iovec iov; #endif vm_offset_t kva; struct buf *bp; int i, error, npages, count; off_t offset; int *rtvals; struct vnode *vp; struct thread *td; struct ucred *cred; vm_page_t *pages; vm_ooffset_t fsize; DEBUG2G("heh\n"); vp = ap->a_vp; KASSERT(vp->v_object, ("objectless vp passed to putpages")); fsize = vp->v_object->un_pager.vnp.vnp_size; td = curthread; /* XXX */ cred = curthread->td_ucred; /* XXX */ pages = ap->a_m; count = ap->a_count; rtvals = ap->a_rtvals; npages = btoc(count); offset = IDX_TO_OFF(pages[0]->pindex); for (i = 0; i < npages; i++) rtvals[i] = VM_PAGER_AGAIN; /* * When putting pages, do not extend file past EOF. */ if (offset + count > fsize) { count = fsize - offset; if (count < 0) count = 0; } /* * We use only the kva address for the buffer, but this is extremely * convienient and fast. */ bp = getpbuf(&fuse_pbuf_freecnt); kva = (vm_offset_t) bp->b_data; pmap_qenter(kva, pages, npages); cnt.v_vnodeout++; cnt.v_vnodepgsout += count; #if PAGEOP_TRANSLATE_UIO iov.iov_base = (caddr_t) kva; iov.iov_len = count; uio.uio_iov = &iov; uio.uio_iovcnt = 1; uio.uio_offset = offset; uio.uio_resid = count; uio.uio_segflg = UIO_SYSSPACE; uio.uio_rw = UIO_WRITE; uio.uio_td = td; error = fuse_io_dispatch(vp, NULL, &uio, cred, FWRITE | O_DIRECT, td); #else error = fuse_strategy_i(vp, bp, NULL, 0); #endif pmap_qremove(kva, npages); relpbuf(bp, &fuse_pbuf_freecnt); if (!error) { int nwritten = round_page(count - FUSE_PAGEOPS_RESID) / PAGE_SIZE; for (i = 0; i < nwritten; i++) { rtvals[i] = VM_PAGER_OK; vm_page_undirty(pages[i]); } } return rtvals[0]; } #undef FUSE_PAGEOPS_RESID int fuse_print(ap) struct vop_print_args /* { struct vnode *a_vp; } */ *ap; { struct fuse_vnode_data *fvdat = VTOFUD(ap->a_vp); printf("nodeid: %llu, parent_nid: %llu, fh_counter: %d, " "nlookup: %llu, flags: %#x\n", VTOILLU(ap->a_vp), (unsigned long long) fvdat->parent_nid, fvdat->fh_counter, (unsigned long long)fvdat->nlookup, fvdat->flags); return (0); } static int fuse_unlock(ap) struct vop_unlock_args /* { struct vnode *a_vp; int a_flags; struct thread *a_td; } */ *ap; { struct vnode *vp = ap->a_vp; if (VTOFUD(vp)) VTOFUD(vp)->flags &= ~FVP_ACCESS_NOOP; return vop_stdunlock(ap); } #if FUSE_HAS_CREATE int fuse_germ_access(struct vop_access_args *ap) { return (0); } #endif fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_vfsops.c0000644000175000017500000005400511151613006020303 0ustar rmhrmh#include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" #include "fuse_session.h" #include "fuse_vnode.h" #if USE_PRIVILEGE_API #include #include #else #include #endif /* This will do for privilege types for now */ #ifndef PRIV_VFS_FUSE_ALLOWOTHER #define PRIV_VFS_FUSE_ALLOWOTHER PRIV_VFS_MOUNT_NONUSER #endif #ifndef PRIV_VFS_FUSE_MOUNT_NONUSER #define PRIV_VFS_FUSE_MOUNT_NONUSER PRIV_VFS_MOUNT_NONUSER #endif #ifndef PRIV_VFS_FUSE_SYNC_UNMOUNT #define PRIV_VFS_FUSE_SYNC_UNMOUNT PRIV_VFS_MOUNT_NONUSER #endif static int fuse_init_handler(struct fuse_ticket *tick, struct uio *uio); static void fuse_send_init(struct fuse_data *data, struct thread *td); static vfs_hash_cmp_t fuse_vnode_bgdrop_cmp; static vfs_mount_t fuse_mount; static vfs_unmount_t fuse_unmount; static vfs_root_t fuse_root; static vfs_statfs_t fuse_statfs; struct vfsops fuse_vfsops = { .vfs_mount = fuse_mount, .vfs_unmount = fuse_unmount, .vfs_root = fuse_root, .vfs_statfs = fuse_statfs, }; SYSCTL_INT(_vfs_fuse, OID_AUTO, init_backgrounded, CTLFLAG_RD, 0, 1, "indicate async handshake"); static int fuse_enforce_dev_perms = 0; SYSCTL_LONG(_vfs_fuse, OID_AUTO, enforce_dev_perms, CTLFLAG_RW, &fuse_enforce_dev_perms, 0, "enforce fuse device permissions for secondary mounts"); static unsigned sync_unmount = 1; SYSCTL_UINT(_vfs_fuse, OID_AUTO, sync_unmount, CTLFLAG_RW, &sync_unmount, 0, "specify when to use synchronous unmount"); MALLOC_DEFINE(M_FUSEVFS, "fuse_filesystem", "buffer for fuse vfs layer"); extern struct vop_vector fuse_vnops; /******************** * * >>> callback handlers for VFS ops * ********************/ static int fuse_init_handler(struct fuse_ticket *tick, struct uio *uio) { struct fuse_data *data = tick->tk_data; #if FUSE_KERNELABI_GEQ(7, 5) struct fuse_init_out *fiio; #else struct fuse_init_in_out *fiio; #endif int err = 0; if ((err = tick->tk_aw_ohead.error)) goto out; if ((err = fticket_pull(tick, uio))) goto out; fiio = fticket_resp(tick)->base; /* XXX is the following check adequate? */ if (fiio->major < 7) { DEBUG2G("userpace version too low\n"); err = EPROTONOSUPPORT; goto out; } data->fuse_libabi_major = fiio->major; data->fuse_libabi_minor = fiio->minor; if (FUSE_KERNELABI_GEQ(7, 5) && fuse_libabi_geq(data, 7, 5)) { #if FUSE_KERNELABI_GEQ(7, 5) if (fticket_resp(tick)->len == sizeof(struct fuse_init_out)) data->max_write = fiio->max_write; else err = EINVAL; #endif } else /* Old fix values */ data->max_write = 4096; out: fuse_ticket_drop(tick); if (err) fdata_kick_set(data); mtx_lock(&data->ticket_mtx); data->dataflag |= FSESS_INITED; wakeup(&data->ticketer); mtx_unlock(&data->ticket_mtx); return (0); } /****************** * * >>> VFS hash comparators * ******************/ int fuse_vnode_cmp(struct vnode *vp, void *nidp) { return (VTOI(vp) != *((uint64_t *)nidp)); } /* * This comparator is used for safely setting the parent_nid. */ int fuse_vnode_setparent_cmp(struct vnode *vp, void *param) { struct parentmanager_param *pmp = param; if (VTOI(vp) == pmp->nodeid) { KASSERT(! pmp->valid, ("more than one vnode seems to match #%llu", (unsigned long long)pmp->nodeid)); VTOFUD(vp)->parent_nid = pmp->parent_nid; pmp->valid = 1; } return (1); } /* * Vnode comparison function which expicitly marks * clashing vnodes as unhashed (via setting id to 0) * before dropping them. So at gc time we'll know if * we have to remove the node from the hash. */ static int fuse_vnode_bgdrop_cmp(struct vnode *vp, void *param) { struct fuse_vnode_data *fvdat = param; if (VTOI(vp) != fvdat->nid) return (1); fvdat->nid = FUSE_NULL_ID; return (0); } /************* * * >>> VFS ops * *************/ static __inline void fuse_send_init(struct fuse_data *data, struct thread *td) { #if FUSE_KERNELABI_GEQ(7, 5) struct fuse_init_in *fiii; #else struct fuse_init_in_out *fiii; #endif struct fuse_dispatcher fdi; fdisp_init(&fdi, sizeof(*fiii)); fdisp_make(&fdi, data->mp, FUSE_INIT, 0, td, NULL); fiii = fdi.indata; fiii->major = FUSE_KERNEL_VERSION; fiii->minor = FUSE_KERNEL_MINOR_VERSION; fuse_insert_callback(fdi.tick, fuse_init_handler); fuse_insert_message(fdi.tick); } /* * Mount system call */ static int fuse_mount(struct mount *mp, struct thread *td) { int err = 0; size_t len; char *fspec, *subtype = NULL; struct vnode *devvp; struct vfsoptlist *opts; struct nameidata nd, *ndp = &nd; struct cdev *fdev; struct sx *slock; struct fuse_data *data; int mntopts = 0, __mntopts = 0, max_read_set = 0, secondary = 0; unsigned max_read = ~0; struct vnode *rvp; struct fuse_vnode_data *fvdat; GIANT_REQUIRED; KASSERT(fuse_useco >= 0, ("negative fuse usecount despite Giant")); if (mp->mnt_flag & MNT_UPDATE) return (EOPNOTSUPP); mp->mnt_flag |= MNT_SYNCHRONOUS; /* Get the new options passed to mount */ opts = mp->mnt_optnew; if (!opts) return (EINVAL); /* `fspath' contains the mount point (eg. /mnt/fuse/sshfs); REQUIRED */ if (!vfs_getopts(opts, "fspath", &err)) return (err); /* `from' contains the device name (eg. /dev/fuse0); REQUIRED */ fspec = vfs_getopts(opts, "from", &err); if (!fspec) return (err); mp->mnt_data = NULL; /* * Not an update, or updating the name: look up the name * and verify that it refers to a sensible disk device. */ NDINIT(ndp, LOOKUP, FOLLOW, UIO_SYSSPACE, fspec, td); if ((err = namei(ndp)) != 0) return (err); NDFREE(ndp, NDF_ONLY_PNBUF); devvp = ndp->ni_vp; if (devvp->v_type != VCHR) { vrele(devvp); return (ENXIO); } fdev = devvp->v_rdev; dev_ref(fdev); if (fuse_enforce_dev_perms) { /* * Check if mounter can open the fuse device. * * This has significance only if we are doing a secondary mount * which doesn't involve actually opening fuse devices, but we * still want to enforce the permissions of the device (in * order to keep control over the circle of fuse users). * * (In case of primary mounts, we are either the superuser so * we can do anything anyway, or we can mount only if the * device is already opened by us, ie. we are permitted to open * the device.) */ #ifdef MAC err = mac_check_vnode_open(td->td_ucred, devvp, VREAD|VWRITE); if (! err) #endif err = VOP_ACCESS(devvp, VREAD|VWRITE, td->td_ucred, td); if (err) { vrele(devvp); return (err); } } /* * according to coda code, no extra lock is needed -- * although in sys/vnode.h this field is marked "v" */ vrele(devvp); FUSE_LOCK; if (! fdev->si_devsw || strcmp("fuse", fdev->si_devsw->d_name)) { FUSE_UNLOCK; return (ENXIO); } if ((data = fusedev_get_data(fdev)) && data->dataflag & FSESS_OPENED) data->mntco++; else { FUSE_UNLOCK; dev_rel(fdev); return (ENXIO); } FUSE_UNLOCK; /* * With the help of underscored options the mount program * can inform us from the flags it sets by default */ #define FUSE_FLAGOPT(fnam, fval) do { \ vfs_flagopt(opts, #fnam, &mntopts, fval); \ vfs_flagopt(opts, "__" #fnam, &__mntopts, fval); \ } while (0) FUSE_FLAGOPT(private, FSESS_PRIVATE); FUSE_FLAGOPT(neglect_shares, FSESS_NEGLECT_SHARES); FUSE_FLAGOPT(allow_other, FSESS_DAEMON_CAN_SPY); FUSE_FLAGOPT(push_symlinks_in, FSESS_PUSH_SYMLINKS_IN); FUSE_FLAGOPT(default_permissions, FSESS_DEFAULT_PERMISSIONS); #if FUSE_HAS_DESTROY FUSE_FLAGOPT(sync_unmount, FSESS_SYNC_UNMOUNT); #endif #undef FUSE_FLAGOPT if (vfs_scanopt(opts, "max_read=", "%u", &max_read) == 1) max_read_set = 1; subtype = vfs_getopts(opts, "subtype=", &err); err = 0; if (fdata_kick_get(data)) err = ENOTCONN; if (mntopts & FSESS_DAEMON_CAN_SPY) err = priv_check(td, PRIV_VFS_FUSE_ALLOWOTHER); slock = &data->mhierlock; /* Note that sx_try_xlock returns 0 on _failure_ */ if (! err && sx_try_xlock(slock) == 0) { err = EBUSY; DEBUG2G("lock contested\n"); } if (err) goto out; DEBUG2G("mntopts 0x%x\n", mntopts); /* Sanity + permission checks */ if (! data->daemoncred) panic("fuse daemon found, but identity unknown"); if (data->mpri == FM_PRIMARY) { secondary = 1; if (data->dataflag & FSESS_PRIVATE) /* * device is owned and owner doesn't * wanna share it with us */ err = EPERM; if (/* actual option set differs from default */ mntopts != __mntopts || max_read_set || subtype) /* * Secondary mounts not allowed to have * options (basicly, that would be * useless though harmless, just let's * be explicit about it) */ err = EINVAL; } else { if (td->td_ucred->cr_uid != data->daemoncred->cr_uid) /* are we allowed to do the first mount? */ err = priv_check(td, PRIV_VFS_FUSE_MOUNT_NONUSER); } if (err) { sx_xunlock(slock); goto out; } /* We need this here as this slot is used by getnewvnode() */ mp->mnt_stat.f_iosize = MAXBSIZE; if (secondary) { struct fuse_secondary_data *fsdat; fsdat = malloc(sizeof(*fsdat), M_FUSEVFS, M_WAITOK| M_ZERO); fsdat->mpri = FM_SECONDARY; mp->mnt_data = fsdat; fsdat->mp = mp; fsdat->master = data; LIST_INSERT_HEAD(&data->slaves_head, fsdat, slaves_link); goto rootdone; } mp->mnt_data = data; /* code stolen from portalfs */ fvdat = malloc(sizeof(*fvdat), M_FUSEVN, M_WAITOK | M_ZERO); err = getnewvnode("fuse", mp, &fuse_vnops, &rvp); if (! err) { err = vn_lock(rvp, LK_EXCLUSIVE | LK_RETRY #if VN_LOCK_TAKES_THREAD , td #endif ); #if NEW_VNODES_ADJUSTED_MANUALLY if (err) printf("fuse4bsd: leaking vnode %p\n", rvp); #endif } if (! err) { /* * FUSE_ROOT_ID as an inode number will be resolved directly. * without resorting to the vfs hashing mechanism, thus it also * can be inserted directly to the v_hash slot. */ rvp->v_hash = FUSE_ROOT_ID; data->rvp = rvp; fuse_vnode_init(rvp, fvdat, FUSE_ROOT_ID, VNON, 0); rvp->v_vflag |= VV_ROOT; #if NEW_VNODES_ADJUSTED_MANUALLY err = insmntque(rvp, mp); #endif } if (err) { fdata_kick_set(data); sx_xunlock(slock); free(fvdat, M_FUSEVN); goto out; } else VOP_UNLOCK(rvp, 0 #if VOP_UNLOCK_TAKES_THREAD , td #endif ); data->mp = mp; data->mpri = FM_PRIMARY; data->dataflag |= mntopts; data->max_read = max_read; if (! priv_check(td, PRIV_VFS_FUSE_SYNC_UNMOUNT)) data->dataflag |= FSESS_CAN_SYNC_UNMOUNT; rootdone: sx_xunlock(slock); vfs_getnewfsid(mp); mp->mnt_flag |= MNT_LOCAL; #ifdef MNTK_MPSAFE mp->mnt_kern_flag |= MNTK_MPSAFE; #endif if (subtype) { strlcat(mp->mnt_stat.f_fstypename, ".", MFSNAMELEN); strlcat(mp->mnt_stat.f_fstypename, subtype, MFSNAMELEN); } copystr(fspec, mp->mnt_stat.f_mntfromname, MNAMELEN - 1, &len); if (secondary && len >= 1) { /* * I've considered using s1, s2,... for shares, instead * #1, #2,... as s* is more conventional... * Finally I chose #* as I feel it's more expressive * and s* can be misleading (slices are strung up * serially, shares exist in parallell) */ mp->mnt_stat.f_mntfromname[len-1] = '#'; if (len < MNAMELEN - 1) { /* Duhh, ain't there a better way of doing this? */ int log = 0, lim = 1; while (data->mntco > lim) { lim *= 10; log++; } if (log >= MNAMELEN - len) { mp->mnt_stat.f_mntfromname[len] = '?'; len++; } else { sprintf(mp->mnt_stat.f_mntfromname + len, "%d", data->mntco - 1); len += log; } } } bzero(mp->mnt_stat.f_mntfromname + len, MNAMELEN - len); DEBUG2G("mp %p: %s\n", mp, mp->mnt_stat.f_mntfromname); if (! secondary) /* Now handshaking with daemon */ fuse_send_init(data, td); out: if (err ) { data->mntco--; FUSE_LOCK; if (data->mntco == 0 && ! (data->dataflag & FSESS_OPENED)) { fdev->si_drv1 = NULL; fdata_destroy(data); } FUSE_UNLOCK; dev_rel(fdev); } return (err); } /* * Unmount system call */ static int fuse_unmount(struct mount *mp, int mntflags, struct thread *td) { int flags = 0, err = 0; struct fuse_data *data; struct fuse_secondary_data *fsdat = NULL; struct cdev *fdev; GIANT_REQUIRED; DEBUG2G("mp %p: %s\n", mp, mp->mnt_stat.f_mntfromname); /* Flag handling */ if (mntflags & MNT_FORCE) flags |= FORCECLOSE; data = fusefs_get_data(mp); if (! data) { fsdat = fusefs_get_secdata(mp); data = fsdat->master; } if (sx_try_xlock(&data->mhierlock) == 0) { DEBUG2G("lock contested\n"); return (EBUSY); } if (! fsdat) { #if _DEBUG struct vnode *vp, *nvp; #endif if (! (mntflags & MNT_FORCE || data->dataflag & FSESS_NEGLECT_SHARES || LIST_EMPTY(&data->slaves_head))) { err = EBUSY; goto unlock; } #if _DEBUG MNT_ILOCK(mp); DEBUG2G("vnodes:\n"); MNT_VNODE_FOREACH(vp, mp, nvp) { DEBUG2G("\n"); vn_printf(vp, "..."); } MNT_IUNLOCK(mp); #endif /* Flush files -> vflush */ /* There is 1 extra root vnode reference (mp->mnt_data). */ if ((err = vflush(mp, 1, flags, td))) { DEBUG2G("err %d\n", err); goto unlock; } } if (fsdat) { LIST_REMOVE(fsdat, slaves_link); free(fsdat, M_FUSEVFS); } else { #if FUSE_HAS_DESTROY if (data->dataflag & FSESS_SYNC_UNMOUNT && ((sync_unmount == 1 && data->dataflag & FSESS_CAN_SYNC_UNMOUNT) || sync_unmount == 2) && !(mntflags & MNT_FORCE)) { struct fuse_dispatcher fdi; fdisp_init(&fdi, 0); fdisp_make(&fdi, mp, FUSE_DESTROY, FUSE_ROOT_ID, td, NULL); fdisp_wait_answ(&fdi); /* ignore return value */ } #endif fdata_kick_set(data); data->mpri = FM_NOMOUNTED; } unlock: sx_xunlock(&data->mhierlock); if (err) return (err); data->mntco--; FUSE_LOCK; fdev = data->fdev; DEBUG2G("mntco %d, opened 0x%x\n", data->mntco, data->dataflag & FSESS_OPENED); if (data->mntco == 0 && ! (data->dataflag & FSESS_OPENED)) { data->fdev->si_drv1 = NULL; fdata_destroy(data); } FUSE_UNLOCK; dev_rel(fdev); mp->mnt_data = NULL; /* Other guys do this, I don't know what it is good for... */ mp->mnt_flag &= ~MNT_LOCAL; return (0); } /* stolen from portalfs */ static int fuse_root(struct mount *mp, int flags, struct vnode **vpp, struct thread *td) { /* * Return locked reference to root. */ struct fuse_data *data = fusefs_get_data(mp); struct vnode *vp; DEBUG2G("mp %p: %s\n", mp, mp->mnt_stat.f_mntfromname); if (! data) { struct fuse_secondary_data *fsdat = fusefs_get_secdata(mp); int err; data = fsdat->master; sx_slock(&data->mhierlock); if (data->mpri == FM_PRIMARY) err = fuse_root(data->mp, flags, vpp, td); else err = ENXIO; sx_sunlock(&data->mhierlock); return (err); } vp = data->rvp; vref(vp); vn_lock(vp, flags | LK_RETRY #if VN_LOCK_TAKES_THREAD , td #endif ); if (vp->v_type == VNON) { struct vattr va; (void)VOP_GETATTR(vp, &va, td->td_ucred, td); } *vpp = vp; #if _DEBUG2G DEBUG2G("root node:\n"); vn_printf(vp, " * "); #endif return (0); } static int fuse_statfs(struct mount *mp, struct statfs *sbp, struct thread *td) { struct fuse_dispatcher fdi; struct fuse_statfs_out *fsfo; struct fuse_data *data; int err = 0; DEBUG2G("mp %p: %s\n", mp, mp->mnt_stat.f_mntfromname); data = fusefs_get_data(mp); if (! data) { struct fuse_secondary_data *fsdat; fsdat = fusefs_get_secdata(mp); data = fsdat->master; sx_slock(&data->mhierlock); if (data->mpri == FM_PRIMARY) err = fuse_statfs(data->mp, sbp, td); else err = ENXIO; sx_sunlock(&data->mhierlock); return (err); } if (! (data->dataflag & FSESS_INITED)) goto fake; if ((err = fdisp_simple_putget(&fdi, FUSE_STATFS, data->rvp, td, NULL))) { if (err == ENOTCONN) /* * We want to seem a legitimate fs even if the daemon * is stiff dead... (so that, eg., we can still do path * based unmounting after the daemon dies). */ goto fake; return (err); } fsfo = fdi.answ; sbp->f_blocks = fsfo->st.blocks; sbp->f_bfree = fsfo->st.bfree; sbp->f_bavail = fsfo->st.bavail; sbp->f_files = fsfo->st.files; sbp->f_ffree = fsfo->st.ffree; /* cast from uint64_t to int64_t */ sbp->f_namemax = fsfo->st.namelen; if (fuse_libabi_geq(fusefs_get_data(mp), 7, 3)) { /* * fuse_kstatfs is created from a struct statvfs, we can fill * the statfs struct by inverting sfs2svfs() of lib/libc/gen/statvfs.c */ #if 0 /* * This would pretty much **ck up buffered IO, * since this would overwrite mnt_stat.f_iosize */ sbp->f_iosize = fsfo->st.bsize; /* cast from uint32_t to uint64_t */ #endif sbp->f_bsize = 0; /* userspace data is broken ... */ #if FUSE_KERNELABI_GEQ(7, 4) if (fuse_libabi_geq(fusefs_get_data(mp), 7, 4)) /* ... unless both kernel and userspace speak 7.4 */ sbp->f_bsize = fsfo->st.frsize; /* cast from uint32_t to uint64_t */ #endif } else /* * fuse_kstatfs is also created from a struct statfs, * conversion is direct */ sbp->f_bsize = fsfo->st.bsize; /* cast from uint32_t to uint64_t */ DEBUG("fuse_statfs_out -- blocks: %llu, bfree: %llu, bavail: %llu, files: %llu, ffree: %llu, bsize: %i, namelen: %i\n", (unsigned long long)fsfo->st.blocks, (unsigned long long)fsfo->st.bfree, (unsigned long long)fsfo->st.bavail, (unsigned long long)fsfo->st.files, (unsigned long long)fsfo->st.ffree, fsfo->st.bsize, fsfo->st.namelen); fuse_ticket_drop(fdi.tick); return (0); fake: sbp->f_blocks = 0; sbp->f_bfree = 0; sbp->f_bavail = 0; sbp->f_files = 0; sbp->f_ffree = 0; sbp->f_namemax = 0; sbp->f_bsize = 0; return (0); } /* * ..._i, as "internal" -- we don't need to register it as a VFS op, * so we might alter from the VFS_VGET signature */ int fuse_vget_i(struct mount *mp, struct thread *td, uint64_t nodeid, enum vtype vtyp, struct vnode **vpp, enum vget_mode vmod, uint64_t parentid) { #define myflags LK_EXCLUSIVE | LK_RETRY int err = 0; struct fuse_vnode_data *fvdat; struct vnode *vp2; DEBUG("been asked for vno #%llu, parent #%llu\n", (long long unsigned)nodeid, (long long unsigned)parentid); if (vtyp == VNON) return (EINVAL); if (nodeid == FUSE_ROOT_ID) { if (parentid != FUSE_NULL_ID) return (ENOENT); err = VFS_ROOT(mp, myflags, vpp, td); if (err) return (err); KASSERT(*vpp, ("we neither err'd nor found the root node")); goto found; } /* * With vmod == VG_WANTNEW, caller wants to get a vnode for the id * only if it's a new one. Hence, no use of trying to get * to get one with the given id. */ if (vmod == VG_WANTNEW) *vpp = NULL; else if ((err = vfs_hash_get(mp, nodeid, /*flags*/ myflags, td, vpp, fuse_vnode_cmp, &nodeid))) return (err); /* * If vmod == VG_FORCENEW, we also want a new vnode, but instead of * just bitching when there is an old one with the given id, we * go and search & destroy those ones... */ if (*vpp && vmod == VG_FORCENEW) { fuse_vnode_teardown(*vpp, td, NULL, vtyp); *vpp = NULL; } audit: if (*vpp) { DEBUG("vnode taken from hash\n"); if ((*vpp)->v_type == vtyp) { if (vtyp == VDIR && parentid != FUSE_NULL_ID && VTOFUD(*vpp)->parent_nid != parentid) { DEBUG("parent mismatch\n"); if (VTOFUD(*vpp)->parent_nid == FUSE_NULL_ID) { /* * Deleted directory is to be reused. * We adjust the nodeid to the new scenario. */ struct parentmanager_param pmp; struct vnode *xvp; DEBUG("dir has no parent, pushing in required\n"); pmp.nodeid = nodeid; pmp.parent_nid = parentid; pmp.valid = 0; err = vfs_hash_get(mp, pmp.nodeid, 0, td, &xvp, fuse_vnode_setparent_cmp, &pmp); KASSERT(xvp == NULL, ("findparent routine has fetched a vnode")); } else /* parent mismatch for a directory */ err = EIO; if (err) { vput(*vpp); *vpp = NULL; return (err); } } goto found; } else if ((*vpp)->v_type == VNON) { DEBUG2G("vnode #%llu with no type\n", VTOILLU(*vpp)); (*vpp)->v_type = vtyp; goto found; } else { fuse_vnode_ditch(*vpp, td); vput(*vpp); } } else if (parentid == FUSE_NULL_ID) { DEBUG("no vpp, no parentid => ENOENT\n"); *vpp = NULL; return (ENOENT); } /* as the big guys say, malloc for your data before getnewvnode() */ fvdat = malloc(sizeof(*fvdat), M_FUSEVN, M_WAITOK | M_ZERO); err = getnewvnode("fuse", mp, &fuse_vnops, vpp); #if _DEBUG DEBUG2G("allocated new vnode:\n"); vn_printf(*vpp, " * "); #endif if (err) { free(fvdat, M_FUSEVN); VNASSERT(! *vpp, *vpp, ("Maybe I misunderstood how getnewvnode() works...")); return (err); } #if NEW_VNODES_ADJUSTED_MANUALLY err = vn_lock(*vpp, myflags #if VN_LOCK_TAKES_THREAD , td #endif ); if (err) printf("fuse4bsd: leaking vnode %p\n", *vpp); else err = insmntque(*vpp, mp); if (err) { free(fvdat, M_FUSEVN); return (err); } #endif /* * There is no harm in fully initializing the vnode before trying * at insertion, because vnodes are gc-d anyway. For the same reason, * they _do_ have to be fully initialized here -- the gc routines should * get the node in an as much predictable state as it's possible. */ fuse_vnode_init(*vpp, fvdat, nodeid, vtyp, parentid); err = vfs_hash_insert(*vpp, nodeid, /*flags*/ myflags, td, &vp2, fuse_vnode_bgdrop_cmp, fvdat); if (err) { free(fvdat, M_FUSEVN); /* XXX do something to tear down allocated inode? * (other fss' code doesn't, so neither I...) */ return (err); } if (vp2) { DEBUG("gee, vfs hash collision for node #%llu\n", (unsigned long long)nodeid); if (vmod == VG_WANTNEW) { vput(vp2); *vpp = NULL; return (EEXIST); } else if (vmod == VG_FORCENEW) { fuse_vnode_teardown(vp2, td, NULL, vtyp); *vpp = NULL; goto audit; } vpp = &vp2; goto audit; } found: #if _DEBUG DEBUG2G("\n"); vn_printf(*vpp, " * "); #endif return (0); #undef myflags } fuse4bsd-0.3.9~pre1.20080208/fuse_module/Makefile0000644000175000017500000000215611151613006017235 0ustar rmhrmh.include "../Makefile.common" SRCS = fuse_main.c \ fuse_msg.c \ fuse_dev.c \ fuse_vfsops.c \ fuse_vnops.c \ fuse_io.c \ fuse_subr.c \ fuse.h \ fuse_session.h \ fuse_io.h \ fuse_vnode.h \ vnode_if.h CFLAGS+= -I../include .if defined(FMASTER) SRCS+= fmaster.c CFLAGS+= -DFMASTER .endif .if defined(KERNCONF) KERNCONF1!= echo ${KERNCONF} | sed -e 's/ .*//g' KERNCONFDIR= /usr/obj/usr/src/sys/${KERNCONF1} .endif .if defined(KERNCONFDIR) CFLAGS+= -DKERNCONFDIR="\"${KERNCONFDIR}\"" -I${KERNCONFDIR} .endif .if defined(DEBUG_MSG) DEBUG_FLAGS+= -D_DEBUG_MSG .endif .if defined(FMASTER) || defined(DEBUG) || defined(DEBUG2G) || \ defined(DEBUG3G) || defined(DEBUG_MSG) SRCS+= fuse_opnames.c .endif KMOD=fuse CLEANFILES+= fuse_opnames.c fuse_opnames.o fuse_subr.o fmaster.o vnode_if.h \ vnode_if_typedef.h vnode_if_newproto.h fuse.ko.debug \ fuse.ko.symbols fuse.ko: fuse_kernel.h fuse_opnames.c: env OUTF=fuse_opnames.c ${AWK} -f ../tools/genopnames.awk fuse_kernel.h .include fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse.h0000644000175000017500000001432111151613006016705 0ustar rmhrmh/* * Just macros for switching some features on and off, some allover used macros * and debugging. */ #include "fuse4bsd.h" #include "fuse_kernel.h" /* Mapping versions to features */ #define FUSE_KERNELABI_GEQ(maj, min) \ (FUSE_KERNEL_VERSION > (maj) || (FUSE_KERNEL_VERSION == (maj) && FUSE_KERNEL_MINOR_VERSION >= (min))) #ifndef USE_OLD_CLONEHANDLER_API #if __FreeBSD_version < 600034 || ( __FreeBSD_version >= 700000 && __FreeBSD_version < 700002 ) #define USE_OLD_CLONEHANDLER_API #endif #endif #ifndef NEW_VNODES_ADJUSTED_MANUALLY #if __FreeBSD_version >= 700034 #define NEW_VNODES_ADJUSTED_MANUALLY 1 #else #define NEW_VNODES_ADJUSTED_MANUALLY 0 #endif #endif #ifndef VOP_OPEN_TAKES_FP #if __FreeBSD_version >= 700044 #define VOP_OPEN_TAKES_FP 1 #else #define VOP_OPEN_TAKES_FP 0 #endif #endif #ifndef VN_LOCK_TAKES_THREAD #if __FreeBSD_version >= 800010 #define VN_LOCK_TAKES_THREAD 0 #else #define VN_LOCK_TAKES_THREAD 1 #endif #endif #ifndef VOP_UNLOCK_TAKES_THREAD #if __FreeBSD_version >= 800011 #define VOP_UNLOCK_TAKES_THREAD 0 #else #define VOP_UNLOCK_TAKES_THREAD 1 #endif #endif #ifndef USE_PRIVILEGE_API /* * __FreeBSD_version bump was omitted for introduction of * the privilege API (both when it's been added and when the * legacy API has been removed), so here we just use the first * value of __FreeBSD_version after adding the priv stuff. */ #if __FreeBSD_version >= 700025 #define USE_PRIVILEGE_API 1 #else #define USE_PRIVILEGE_API 0 #endif #endif #if ! USE_PRIVILEGE_API #define priv_check(td, priv) suser(td) #define priv_check_cred(cred, priv, flag) suser_cred(cred, SUSER_ALLOWJAIL) #endif /* * Appearance of new FUSE operations is not always in par with version * numbering... At least, 7.3 is a sufficient condition for having * FUSE_{ACCESS,CREATE}. */ #if FUSE_KERNELABI_GEQ(7, 3) #ifndef FUSE_HAS_ACCESS #define FUSE_HAS_ACCESS 1 #endif #ifndef FUSE_HAS_CREATE #define FUSE_HAS_CREATE 1 #endif #else /* FUSE_KERNELABI_GEQ(7, 3) */ #ifndef FUSE_HAS_ACCESS #define FUSE_HAS_ACCESS 0 #endif #ifndef FUSE_HAS_CREATE #define FUSE_HAS_CREATE 0 #endif #endif #if FUSE_KERNELABI_GEQ(7, 7) #ifndef FUSE_HAS_GETLK #define FUSE_HAS_GETLK 1 #endif #ifndef FUSE_HAS_SETLK #define FUSE_HAS_SETLK 1 #endif #ifndef FUSE_HAS_SETLKW #define FUSE_HAS_SETLKW 1 #endif #ifndef FUSE_HAS_INTERRUPT #define FUSE_HAS_INTERRUPT 1 #endif #else /* FUSE_KERNELABI_GEQ(7, 7) */ #ifndef FUSE_HAS_GETLK #define FUSE_HAS_GETLK 0 #endif #ifndef FUSE_HAS_SETLK #define FUSE_HAS_SETLK 0 #endif #ifndef FUSE_HAS_SETLKW #define FUSE_HAS_SETLKW 0 #endif #ifndef FUSE_HAS_INTERRUPT #define FUSE_HAS_INTERRUPT 0 #endif #endif #if FUSE_KERNELABI_GEQ(7, 8) #ifndef FUSE_HAS_FLUSH_RELEASE #define FUSE_HAS_FLUSH_RELEASE 1 /* * "DESTROY" came in the middle of the 7.8 era, * so this is not completely exact... */ #ifndef FUSE_HAS_DESTROY #define FUSE_HAS_DESTROY 1 #endif #endif #else /* FUSE_KERNELABI_GEQ(7, 8) */ #ifndef FUSE_HAS_FLUSH_RELEASE #define FUSE_HAS_FLUSH_RELEASE 0 #ifndef FUSE_HAS_DESTROY #define FUSE_HAS_DESTROY 0 #endif #endif #endif #ifndef FUSELIB_CONFORM_BIOREAD /* * make BIO behave as it's prescribed in fuselib's fuse.h, * ie. in case of buffered reading, short reads instruct * the kernel to fill the rest of the buffer with zeroes */ #define FUSELIB_CONFORM_BIOREAD 1 #endif /* misc */ extern int fuse_useco; SYSCTL_DECL(_vfs_fuse); /* Fuse locking */ #ifndef DO_GIANT_MANUALLY #define DO_GIANT_MANUALLY 1 #endif #ifndef USE_FUSE_LOCK #define USE_FUSE_LOCK 1 #endif #if USE_FUSE_LOCK extern struct mtx fuse_mtx; #define FUSE_LOCK mtx_lock(&fuse_mtx) #define FUSE_UNLOCK mtx_unlock(&fuse_mtx) #else #define FUSE_LOCK #define FUSE_UNLOCK #endif #define RECTIFY_TDCR(td, cred) \ do { \ if (! (td)) \ (td) = curthread; \ if (! (cred)) \ (cred) = (td)->td_ucred; \ } while (0) /* Debug related stuff */ #ifndef DEBUGTOLOG #define DEBUGTOLOG 0 #endif #if DEBUGTOLOG #define dprintf(args ...) log(LOG_DEBUG, args) #else #define dprintf(args ...) printf(args) #endif #define DEBLABEL "[fuse-debug] " #ifndef _DEBUG #define _DEBUG 0 #endif #if _DEBUG #ifndef _DEBUG2G #define _DEBUG2G 1 #endif #define DEBUG(args, ...) \ printf(DEBLABEL "%s <%s@%d>: " args, __func__, __FILE__, __LINE__, ## __VA_ARGS__) #else #define DEBUG(args ...) #endif #ifndef _DEBUG2G #define _DEBUG2G 0 #endif #if _DEBUG2G #ifndef _DEBUG3G #define _DEBUG3G 1 #endif #define DEBUG2G(args, ...) \ printf(DEBLABEL "%s <%s@%d>: " args, __func__, __FILE__, __LINE__, ## __VA_ARGS__) #else #define DEBUG2G(args ...) #endif #ifndef _DEBUG3G #define _DEBUG3G 0 #endif #if _DEBUG3G #define DEBUG3G(args, ...) \ printf(DEBLABEL "%s <%s@%d>: " args, __func__, __FILE__, __LINE__, ## __VA_ARGS__) #else #define DEBUG3G(args ...) #endif #ifndef FMASTER #define FMASTER 0 #endif #if FMASTER #ifndef _DEBUG_MSG #define _DEBUG_MSG 1 #endif #endif #ifndef _DEBUG_MSG #define _DEBUG_MSG 0 #endif #if _DEBUG_MSG #define DEBUG_MSG(args, ...) \ printf(DEBLABEL "%s <%s@%d>: " args, __func__, __FILE__, __LINE__, ## __VA_ARGS__) #else #define DEBUG_MSG(args...) #endif #ifndef _DEBUG_UNIQUE #if _DEBUG || _DEBUG2G || _DEBUG3G || _DEBUG_MSG #define _DEBUG_UNIQUE 1 #else #define _DEBUG_UNIQUE 0 #endif #endif #if _DEBUG || _DEBUG2G || _DEBUG3G || FMASTER extern char *fuse_opnames[]; extern int fuse_opnames_entries; struct fuse_iov; void uprettyprint(char *buf, size_t len); void prettyprint(char *buf, size_t len); void fprettyprint(struct fuse_iov *fiov, size_t dlen); #endif #if _DEBUG || _DEBUG2G || _DEBUG3G || defined(INVARIANTS) || FUSELIB_CONFORM_BIOREAD int isbzero(void *buf, size_t len); #endif #if _DEBUG || _DEBUG2G || _DEBUG3G #include #define bp_print(bp) \ printf("b_bcount %d, b_data %p, b_error %#x, b_iocmd %#x, b_ioflags %#x, b_iooffset %lld, b_resid %d, b_blkno %d, b_offset %lld, b_flags %#x, b_bufsize %d, b_lblkno %d, b_vp %p, b_vp_ino %llu, b_dirtyoff %d, b_dirtyend %d, b_npages %d\n", \ (int)(bp)->b_bcount, (bp)->b_data, (bp)->b_error, (bp)->b_iocmd, (bp)->b_ioflags, (long long)(bp)->b_iooffset, (int)(bp)->b_resid, (int)(bp)->b_blkno, (long long)(bp)->b_offset, (bp)->b_flags, (int)(bp)->b_bufsize, (int)(bp)->b_lblkno, (bp)->b_vp, VTOILLU((bp)->b_vp), (int)(bp)->b_dirtyoff, (int)(bp)->b_dirtyend, (int)(bp)->b_npages) #endif fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_io.c0000644000175000017500000005756111151613006017404 0ustar rmhrmh#include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" #include "fuse_session.h" #include "fuse_vnode.h" #include "fuse_io.h" int fuse_read_directbackend(struct fuse_io_data *fioda); static int fuse_io_p2p(struct fuse_io_data *fioda, struct fuse_dispatcher *fdip); static int fuse_read_biobackend(struct fuse_io_data *fioda); static int fuse_write_directbackend(struct fuse_io_data *fioda); static int fuse_write_biobackend(struct fuse_io_data *fioda); static fuse_buffeater_t fuse_std_buffeater; /**************** * * >>> Low level I/O routines and interface to them * ****************/ /* main I/O dispatch routine */ int fuse_io_dispatch(struct vnode *vp, struct fuse_filehandle *fufh, struct uio *uio, struct ucred *cred, int flag, struct thread *td) { int err; struct fuse_io_data fioda; int directio; RECTIFY_TDCR(td, cred); ASSERT_VOP_LOCKED__FH(vp); if (fufh) fufh->useco++; else if ((err = fuse_get_filehandle(vp, NULL, cred, flag, &fufh, NULL))) { DEBUG2G("no filehandle for vnode #%llu\n", VTOILLU(vp)); return (err); } bzero(&fioda, sizeof(fioda)); fioda.vp = vp; fioda.fufh = fufh; fioda.uio = uio; fioda.cred = cred; fioda.td = td; /* * Ideally, when the daemon asks for direct io at open time, the * standard file flag should be set according to this, so that would * just change the default mode, which later on could be changed via * fcntl(2). * But this doesn't work, the O_DIRECT flag gets cleared at some point * (don't know where). So to make any use of the Fuse direct_io option, * we hardwire it into the file's private data (similarly to Linux, * btw.). */ directio = (flag & O_DIRECT) || (fufh->flags & FOPEN_DIRECT_IO); switch (uio->uio_rw) { case UIO_READ: fioda.opcode = FUSE_READ; fioda.buffeater = fuse_std_buffeater; if (directio) { DEBUG2G("direct read of vnode %llu via file handle %llu\n", VTOILLU(vp), (unsigned long long)fufh->fh_id); err = fuse_read_directbackend(&fioda); } else { DEBUG2G("buffered read of vnode %llu\n", VTOILLU(vp)); err = fuse_read_biobackend(&fioda); } break; case UIO_WRITE: if (directio) { DEBUG2G("direct write of vnode %llu via file handle %llu\n", VTOILLU(vp), (unsigned long long)fufh->fh_id); err = fuse_write_directbackend(&fioda); } else { DEBUG2G("buffered write of vnode %llu\n", VTOILLU(vp)); err = fuse_write_biobackend(&fioda); } break; default: panic("uninterpreted mode passed to fuse_io_dispatch"); } if (VTOFUD(vp)) fufh->useco--; else DEBUG2G("poor nasty nasty vnode %p...\n", vp); fuse_invalidate_attr(vp); return (err); } /* dispatch routine for file based I/O */ int fuse_io_file(struct file *fp, struct uio *uio, struct ucred *cred, int flags, struct thread *td) { struct fuse_filehandle *fufh; struct vattr va; struct vnode *vp, *ovl_vp = fp->f_vnode; int err = 0; vn_lock(ovl_vp, LK_EXCLUSIVE | LK_RETRY #if VN_LOCK_TAKES_THREAD , td #endif ); if (_file_is_bad(fp) || ! _file_is_fat(fp)) { err = EBADF; goto out; } fufh = FTOFH(fp); vp = fufh->fh_vp; ASSERT_VOP_LOCKED__FH(vp); if (uio->uio_resid == 0) goto out; if (uio->uio_rw == UIO_WRITE && fp->f_flag & O_APPEND) { if ((err = VOP_GETATTR(vp, &va, cred, td))) goto out; uio->uio_offset = va.va_size; } else if ((flags & FOF_OFFSET) == 0) uio->uio_offset = fp->f_offset; err = fuse_io_dispatch(vp, fufh->op == FUSE_OPEN ? fufh : NULL, uio, cred, fp->f_flag, td); if ((flags & FOF_OFFSET) == 0) fp->f_offset = uio->uio_offset; fp->f_nextoff = uio->uio_offset; out: VOP_UNLOCK(ovl_vp, 0 #if VOP_UNLOCK_TAKES_THREAD , td #endif ); DEBUG("leaving with %d\n", err); return (err); } /* dispatch routine for vnode based I/O */ int fuse_io_vnode(struct vnode *vp, struct ucred *cred, struct uio *uio, int ioflag) { int fflag = (uio->uio_rw == UIO_READ) ? FREAD : FWRITE; int err; if (ioflag & IO_DIRECT) fflag |= O_DIRECT; if (ioflag & IO_NDELAY) fflag |= FNONBLOCK; if (ioflag & IO_APPEND) fflag |= O_APPEND; if (ioflag & IO_ASYNC) fflag |= O_ASYNC; if (ioflag & IO_SYNC) fflag |= O_SYNC; err = fuse_io_dispatch(vp, NULL, uio, cred, fflag, NULL); DEBUG("return with %d\n", err); return (err); } int fuse_read_biobackend(struct fuse_io_data *fioda) { struct vnode *vp = fioda->vp; struct fuse_filehandle *fufh = fioda->fufh; struct uio *uio = fioda->uio; enum fuse_opcode op = fioda->opcode; fuse_buffeater_t *buffe = fioda->buffeater; void *param = fioda->param; int biosize; struct buf *bp; daddr_t lbn; int bcount; int bbcount; int err = 0, n = 0, on = 0; if (uio->uio_resid == 0) return (0); biosize = vp->v_mount->mnt_stat.f_iosize; bcount = MIN(MAXBSIZE, biosize); DEBUG2G("entering loop\n"); do { lbn = uio->uio_offset / biosize; on = uio->uio_offset & (biosize - 1); DEBUG2G("biosize %d, lbn %d, on %d\n", biosize, (int)lbn, on); /* * Obtain the buffer cache block. Figure out the buffer size * when we are at EOF. If we are modifying the size of the * buffer based on an EOF condition we need to hold * nfs_rslock() through obtaining the buffer to prevent * a potential writer-appender from messing with n_size. * Otherwise we may accidently truncate the buffer and * lose dirty data. * * Note that bcount is *not* DEV_BSIZE aligned. */ bp = getblk(vp, lbn, bcount, PCATCH, 0, 0); if (!bp) return (EINTR); /* * If B_CACHE is not set, we must issue the read. If this * fails, we return an error. */ if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); err = fuse_strategy_i(vp, bp, fufh, op); #if _DEBUG prettyprint(bp->b_data, 48); printf("\n"); prettyprint(bp->b_data + PAGE_SIZE, 48); printf("\n"); #endif if (err) { brelse(bp); return (err); } } /* * on is the offset into the current bp. Figure out how many * bytes we can copy out of the bp. Note that bcount is * NOT DEV_BSIZE aligned. * * Then figure out how many bytes we can copy into the uio. */ n = 0; /* * If we zero pad the buf, bp->b_resid will be 0, so then * just ignore it */ bbcount = bcount - bp->b_resid; if (on < bbcount) n = bbcount - on; if (n > 0) { DEBUG2G("feeding buffeater with %d bytes of buffer %p, saying %d was asked for\n", n, bp->b_data + on, n + (int)bp->b_resid); #if 0 && _DEBUG prettyprint(bp->b_data + on, n); printf("\n"); #endif err = buffe(uio, n + bp->b_resid, bp->b_data + on, n, param); } brelse(bp); DEBUG2G("end of turn, err %d, uio->uio_resid %d, n %d\n", err, uio->uio_resid, n); } while (err == 0 && uio->uio_resid > 0 && n > 0); return ((err == -1) ? 0 : err); } int fuse_read_directbackend(struct fuse_io_data *fioda) { struct vnode *vp = fioda->vp; struct fuse_filehandle *fufh = fioda->fufh; struct uio *uio = fioda->uio; struct ucred *cred = fioda->cred; struct thread *td = fioda->td; enum fuse_opcode op = fioda->opcode; fuse_buffeater_t *buffe = fioda->buffeater; void *param = fioda->param; struct fuse_dispatcher fdi; struct fuse_read_in *fri; int err = 0; if (uio->uio_resid == 0) return (0); DEBUG("bug daemon for food\n"); fdisp_init(&fdi, 0); /* * XXX In "normal" case we use an intermediate kernel buffer for * transmitting data from daemon's context to ours. Eventually, we should * get rid of this. Anyway, if the target uio lives in sysspace (we are * called from pageops), and the input data doesn't need kernel-side * processing (we are not called from readdir) we can already invoke * an optimized, "peer-to-peer" I/O routine. */ if (buffe == fuse_std_buffeater && uio->uio_segflg == UIO_SYSSPACE) { if ((err = fuse_io_p2p(fioda, &fdi))) goto out; else goto done; } while (uio->uio_resid > 0) { fdi.iosize = sizeof(*fri); fdisp_make_vp(&fdi, op, vp, td, cred); fri = fdi.indata; fri->fh = fufh->fh_id; fri->offset = uio->uio_offset; fri->size = MIN(uio->uio_resid, fusefs_get_data(vp->v_mount)->max_read); DEBUG2G("fri->fh %llu, fri->offset %d, fri->size %d\n", (unsigned long long)fri->fh, (int)fri->offset, fri->size); if ((err = fdisp_wait_answ(&fdi))) goto out; DEBUG2G("%d bytes asked for from offset %d, passing on the %d we got\n", uio->uio_resid, (int)uio->uio_offset, (int)fdi.iosize); if ((err = buffe(uio, fri->size, fdi.answ, fdi.iosize, param))) break; } done: fuse_ticket_drop(fdi.tick); out: return ((err == -1) ? 0 : err); } /* direct I/O routine with no intermediate buffer */ static int fuse_io_p2p(struct fuse_io_data *fioda, struct fuse_dispatcher *fdip) { struct vnode *vp = fioda->vp; struct fuse_filehandle *fufh = fioda->fufh; struct uio *uio = fioda->uio; struct ucred *cred = fioda->cred; struct thread *td = fioda->td; enum fuse_opcode op; int err = 0; int chunksize = 0; struct iovec *iov; int nmax = (uio->uio_rw == UIO_READ) ? fusefs_get_data(vp->v_mount)->max_read : fusefs_get_data(vp->v_mount)->max_write; op = fioda->opcode ?: ((uio->uio_rw == UIO_READ) ? FUSE_READ : FUSE_WRITE); iov = uio->uio_iov; while (uio->uio_resid > 0) { int transfersize; chunksize = MIN(iov->iov_len, nmax); if (uio->uio_rw == UIO_READ) { struct fuse_read_in *fri; fdip->iosize = sizeof(struct fuse_read_in); fdisp_make_vp(fdip, op, vp, td, cred); fri = fdip->indata; fri->fh = fufh->fh_id; fri->offset = uio->uio_offset; fri->size = chunksize; fdip->tick->tk_aw_type = FT_A_BUF; fdip->tick->tk_aw_bufdata = iov->iov_base; } else { struct fuse_write_in *fwi; fdip->iosize = sizeof(struct fuse_write_in) + chunksize; fdisp_make_vp(fdip, op, vp, td, cred); fwi = fdip->indata; fwi->fh = fufh->fh_id; fwi->offset = uio->uio_offset; fwi->size = chunksize; fdip->tick->tk_ms_type = FT_M_BUF; fdip->tick->tk_ms_bufdata = iov->iov_base; fdip->tick->tk_ms_bufsize = chunksize; } DEBUG2G("chunksize %d\n", chunksize); fdip->finh->len = (sizeof *fdip->finh) + chunksize; err = fdisp_wait_answ(fdip); if (err) return (err); transfersize = (uio->uio_rw == UIO_READ) ? fdip->tick->tk_aw_ohead.len - sizeof(struct fuse_out_header) : ((struct fuse_write_out *)fdip->answ)->size; uio->uio_resid -= transfersize; uio->uio_offset += transfersize; iov->iov_len -= transfersize; iov->iov_base = (char *)iov->iov_base + transfersize; if (iov->iov_len == 0) { iov++; uio->uio_iovcnt--; } DEBUG2G("resid %d, offset %llu, iovcnt %d, iov_len %d, " "transfersize %d\n", uio->uio_resid, (long long unsigned)uio->uio_offset, uio->uio_iovcnt, iov->iov_len, transfersize); if (transfersize < chunksize) break; } return (0); } /* Simple standard way for transmitting input */ static int fuse_std_buffeater(struct uio *uio, size_t reqsize, void *buf, size_t bufsize, void *param) { int err; if ((err = uiomove(buf, MIN(reqsize, bufsize), uio))) return (err); if (bufsize < reqsize) return (-1); return (0); } static int fuse_write_directbackend(struct fuse_io_data *fioda) { struct vnode *vp = fioda->vp; uint64_t fh_id = fioda->fufh->fh_id; struct uio *uio = fioda->uio; struct ucred *cred = fioda->cred; struct thread *td = fioda->td; size_t chunksize; int diff; struct fuse_write_in *fwi; struct fuse_dispatcher fdi; int err = 0; if (! uio->uio_resid) return (0); fdisp_init(&fdi, 0); if (uio->uio_segflg == UIO_SYSSPACE) { if ((err = fuse_io_p2p(fioda, &fdi))) return (err); else goto out; } while (uio->uio_resid > 0) { chunksize = MIN(uio->uio_resid, fusefs_get_data(vp->v_mount)->max_write); fdi.iosize = sizeof(*fwi) + chunksize; fdisp_make_vp(&fdi, FUSE_WRITE, vp, td, cred); fwi = fdi.indata; fwi->fh = fh_id; fwi->offset = uio->uio_offset; fwi->size = chunksize; if ((err = uiomove((char *)fdi.indata + sizeof(*fwi), chunksize, uio))) break; if ((err = fdisp_wait_answ(&fdi))) return(err); diff = chunksize - ((struct fuse_write_out *)fdi.answ)->size; if (diff < 0) { err = EINVAL; break; } uio->uio_resid += diff; uio->uio_offset -= diff; } out: fuse_ticket_drop(fdi.tick); return (err); } /* * Vnode op for write using bio */ static int fuse_write_biobackend(struct fuse_io_data *fioda) { struct vnode *vp = fioda->vp; struct uio *uio = fioda->uio; struct ucred *cred = fioda->cred; int biosize; struct buf *bp; daddr_t lbn; int bcount; int n, on, err = 0; vm_ooffset_t fsize = vp->v_object->un_pager.vnp.vnp_size; DEBUG2G("fsize %lld\n", (long long int)fsize); biosize = vp->v_mount->mnt_stat.f_iosize; /* * Find all of this file's B_NEEDCOMMIT buffers. If our writes * would exceed the local maximum per-file write commit size when * combined with those, we must decide whether to flush, * go synchronous, or return err. We don't bother checking * IO_UNIT -- we just make all writes atomic anyway, as there's * no point optimizing for something that really won't ever happen. */ do { lbn = uio->uio_offset / biosize; on = uio->uio_offset & (biosize-1); n = MIN((unsigned)(biosize - on), uio->uio_resid); DEBUG2G("lbn %d, on %d, n %d, uio offset %d, uio resid %d\n", (int)lbn, on, n, (int)uio->uio_offset, uio->uio_resid); again: /* * Handle direct append and file extension cases, calculate * unaligned buffer size. */ if (uio->uio_offset == fsize && n) { /* * Get the buffer (in its pre-append state to maintain * B_CACHE if it was previously set). Resize the * nfsnode after we have locked the buffer to prevent * readers from reading garbage. */ bcount = on; DEBUG("getting block from OS, bcount %d\n", bcount); bp = getblk(vp, lbn, bcount, PCATCH, 0, 0); if (bp != NULL) { long save; fsize = uio->uio_offset + n; vnode_pager_setsize(vp, fsize); save = bp->b_flags & B_CACHE; bcount += n; allocbuf(bp, bcount); bp->b_flags |= save; } } else { /* * Obtain the locked cache block first, and then * adjust the file's size as appropriate. */ bcount = on + n; if ((off_t)lbn * biosize + bcount < fsize) { if ((off_t)(lbn + 1) * biosize < fsize) bcount = biosize; else bcount = fsize - (off_t)lbn * biosize; } DEBUG("getting block from OS, bcount %d\n", bcount); bp = getblk(vp, lbn, bcount, PCATCH, 0, 0); if (uio->uio_offset + n > fsize) { fsize = uio->uio_offset + n; vnode_pager_setsize(vp, fsize); } } if (!bp) { err = EINTR; break; } /* * Issue a READ if B_CACHE is not set. In special-append * mode, B_CACHE is based on the buffer prior to the write * op and is typically set, avoiding the read. If a read * is required in special append mode, the server will * probably send us a short-read since we extended the file * on our end, resulting in b_resid == 0 and, thusly, * B_CACHE getting set. * * We can also avoid issuing the read if the write covers * the entire buffer. We have to make sure the buffer state * is reasonable in this case since we will not be initiating * I/O. See the comments in kern/vfs_bio.c's getblk() for * more information. * * B_CACHE may also be set due to the buffer being cached * normally. */ if (on == 0 && n == bcount) { bp->b_flags |= B_CACHE; bp->b_flags &= ~B_INVAL; bp->b_ioflags &= ~BIO_ERROR; } if ((bp->b_flags & B_CACHE) == 0) { bp->b_iocmd = BIO_READ; vfs_busy_pages(bp, 0); fuse_strategy_i(vp, bp, NULL, 0); if ((err = bp->b_error)) { brelse(bp); break; } } if (bp->b_wcred == NOCRED) bp->b_wcred = crhold(cred); /* * If dirtyend exceeds file size, chop it down. This should * not normally occur but there is an append race where it * might occur XXX, so we log it. * * If the chopping creates a reverse-indexed or degenerate * situation with dirtyoff/end, we 0 both of them. */ if (bp->b_dirtyend > bcount) { DEBUG2G("Fuse append race @%lx:%d\n", (long)bp->b_blkno * biosize, bp->b_dirtyend - bcount); bp->b_dirtyend = bcount; } if (bp->b_dirtyoff >= bp->b_dirtyend) bp->b_dirtyoff = bp->b_dirtyend = 0; /* * If the new write will leave a contiguous dirty * area, just update the b_dirtyoff and b_dirtyend, * otherwise force a write rpc of the old dirty area. * * While it is possible to merge discontiguous writes due to * our having a B_CACHE buffer ( and thus valid read data * for the hole), we don't because it could lead to * significant cache coherency problems with multiple clients, * especially if locking is implemented later on. * * as an optimization we could theoretically maintain * a linked list of discontinuous areas, but we would still * have to commit them separately so there isn't much * advantage to it except perhaps a bit of asynchronization. */ if (bp->b_dirtyend > 0 && (on > bp->b_dirtyend || (on + n) < bp->b_dirtyoff)) { /* * Yes, we mean it. Write out everything to "storage" * immediatly, without hesitation. (Apart from other * reasons: the only way to know if a write is valid * if its actually written out.) */ bwrite(bp); if (bp->b_error == EINTR) { err = EINTR; break; } goto again; } err = uiomove((char *)bp->b_data + on, n, uio); /* * Since this block is being modified, it must be written * again and not just committed. Since write clustering does * not work for the stage 1 data write, only the stage 2 * commit rpc, we have to clear B_CLUSTEROK as well. */ bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK); if (err) { bp->b_ioflags |= BIO_ERROR; bp->b_error = err; brelse(bp); break; } /* * Only update dirtyoff/dirtyend if not a degenerate * condition. */ if (n) { if (bp->b_dirtyend > 0) { bp->b_dirtyoff = MIN(on, bp->b_dirtyoff); bp->b_dirtyend = MAX((on + n), bp->b_dirtyend); } else { bp->b_dirtyoff = on; bp->b_dirtyend = on + n; } vfs_bio_set_validclean(bp, on, n); } bwrite(bp); if ((err = bp->b_error)) break; } while (uio->uio_resid > 0 && n > 0); return (err); } /* core strategy like routine */ int fuse_strategy_i(struct vnode *vp, struct buf *bp, struct fuse_filehandle *fufh, enum fuse_opcode op) { struct fuse_dispatcher fdi; struct ucred *cred; int err = 0; int chunksize, respsize; caddr_t bufdat; int biosize = vp->v_mount->mnt_stat.f_iosize; if (! (vp->v_type == VREG || vp->v_type == VDIR)) { DEBUG("for vnode #%llu v_type is %d, dropping\n", VTOILLU(vp), vp->v_type); return (EOPNOTSUPP); } if (bp->b_iocmd != BIO_READ && bp->b_iocmd != BIO_WRITE) { DEBUG("for vnode #%llu bio tried with biocmd %#x, dropping\n", VTOILLU(vp), bp->b_iocmd); return (EOPNOTSUPP); } /* * clear BIO_ERROR and B_INVAL state prior to initiating the I/O. We * do this here so we do not have to do it in all the code that * calls us. */ bp->b_flags &= ~B_INVAL; bp->b_ioflags &= ~BIO_ERROR; KASSERT(!(bp->b_flags & B_DONE), ("fuse_strategy: bp %p already marked done", bp)); if (bp->b_bcount == 0) return (0); cred = bp->b_iocmd == BIO_READ ? bp->b_rcred : bp->b_wcred; #if _DEBUG DEBUG2G("reading from block #%d at vnode:\n", (int)bp->b_blkno); vn_printf(vp, " * "); #endif if (fufh) { DEBUG2G("we have a useable filehandle passed on\n"); fufh->useco++; } else err = fuse_get_filehandle(vp, NULL, cred, bp->b_iocmd == BIO_READ ? FREAD : FWRITE, &fufh, NULL); if (err) { DEBUG2G("fetching filehandle failed\n"); goto out; } DEBUG2G("vp #%llu, fufh #%llu\n", VTOILLU(vp), (unsigned long long)fufh->fh_id); fdisp_init(&fdi, 0); if (bp->b_iocmd == BIO_READ) { struct fuse_read_in *fri; int ioff = 0; #if FUSELIB_CONFORM_BIOREAD struct vattr va; if ((err = VOP_GETATTR(vp, &va, cred, curthread))) goto out; #endif bufdat = bp->b_data; bp->b_resid = bp->b_bcount; while (bp->b_resid > 0) { DEBUG2G("starting bio with resid %ld\n", bp->b_resid); chunksize = MIN(bp->b_resid, fusefs_get_data(vp->v_mount)->max_read); fdi.iosize = sizeof(*fri); if (! op) op = vp->v_type == VDIR ? FUSE_READDIR : FUSE_READ; fdisp_make_vp(&fdi, op, vp, curthread, cred); fri = fdi.indata; fri->fh = fufh->fh_id; fri->offset = ((off_t)bp->b_blkno) * biosize + ioff; #if FUSELIB_CONFORM_BIOREAD chunksize = MIN(chunksize, MIN(fri->offset + bp->b_resid, va.va_size) - fri->offset); if (chunksize == 0) { respsize = -1; goto eval; } #endif fri->size = chunksize; fdi.tick->tk_aw_type = FT_A_BUF; fdi.tick->tk_aw_bufdata = bufdat; DEBUG("waiting for answer\n"); if ((err = fdisp_wait_answ(&fdi))) goto out; respsize = fdi.tick->tk_aw_bufsize; DEBUG2G("chunksize %d, respsize %d, bp->b_resid %ld, bp->b_bcount %ld\n", chunksize, respsize, bp->b_resid, bp->b_bcount); bp->b_resid -= respsize; bufdat += respsize; ioff += respsize; #if FUSELIB_CONFORM_BIOREAD eval: #endif DEBUG2G("%d bytes asked for from offset %llu, passing on the %d we got\n", chunksize, (long long unsigned)fri->offset, respsize); if (respsize < chunksize) { /* * if we don't get enough data, just fill the * rest with zeros. */ DEBUG("zeroing tail of %ld bytes\n", bp->b_resid); bzero((char *)bp->b_data + bp->b_bcount - bp->b_resid, bp->b_resid); #if FUSELIB_CONFORM_BIOREAD if (chunksize) bp->b_resid = 0; #endif break; } if (respsize > chunksize) { fuse_ticket_drop(fdi.tick); err = EINVAL; goto out; } DEBUG("bp->b_data %p\n", bp->b_data); } } else { struct fuse_write_in *fwi; struct fuse_write_out *fwo; int diff; int merr = 0; bufdat = bp->b_data + bp->b_dirtyoff; while (bp->b_dirtyend > bp->b_dirtyoff) { chunksize = MIN(bp->b_dirtyend - bp->b_dirtyoff, fusefs_get_data(vp->v_mount)->max_write); fdi.iosize = sizeof(*fwi); op = op ?: FUSE_WRITE; fdisp_make_vp(&fdi, op, vp, NULL, cred); fwi = fdi.indata; fwi->fh = fufh->fh_id; fwi->offset = (off_t)bp->b_blkno * biosize + bp->b_dirtyoff; fwi->size = chunksize; fdi.tick->tk_ms_type = FT_M_BUF; fdi.tick->tk_ms_bufdata = bufdat; fdi.tick->tk_ms_bufsize = chunksize; if ((err = fdisp_wait_answ(&fdi))) { merr = 1; break; } fwo = fdi.answ; diff = chunksize - fwo->size; if (diff < 0) { err = EINVAL; break; } if (diff > 0) { /* * Tolerating a short read would mean * keeping dirty data around and we * don't do that. */ err = EIO; break; } bp->b_dirtyoff += fwo->size; } if (bp->b_dirtyend == bp->b_dirtyoff) bp->b_dirtyend = bp->b_dirtyoff = 0; bp->b_resid = bp->b_dirtyend - bp->b_dirtyoff; if (merr) goto out; } if (fdi.tick) fuse_ticket_drop(fdi.tick); else DEBUG("no ticket on leave\n"); out: if (fufh) fufh->useco--; if (err) { bp->b_ioflags |= BIO_ERROR; bp->b_error = err; } DEBUG("calling bufdone\n"); bufdone(bp); return (err); } fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_vnode.h0000644000175000017500000000377011151613006020106 0ustar rmhrmh/* * Private data of a fuse vnode */ struct fuse_vnode_data { uint64_t nid; uint64_t nlookup; uint64_t parent_nid; int flags; LIST_HEAD(, fuse_filehandle) fh_head; int fh_counter; struct vattr cached_attrs; struct timespec cached_attrs_valid; #ifdef FUSE_HAS_CREATE struct componentname *germcnp; #endif }; #define VTOFUD(vp) (((struct fuse_vnode_data *)(vp)->v_data)) #define VTOI(vp) (VTOFUD(vp)->nid) #define VTOVA(vp) (&(VTOFUD(vp)->cached_attrs)) #define VTOILLU(vp) ((unsigned long long)(VTOFUD(vp) ? VTOI(vp) : 0)) #define FUSE_NULL_ID 0 static __inline void fuse_invalidate_attr(struct vnode *vp) { if (VTOFUD(vp)) bzero(&VTOFUD(vp)->cached_attrs_valid, sizeof(struct timespec)); } MALLOC_DECLARE(M_FUSEVN); /* Parameter structure for parent management via the VFS hash */ struct parentmanager_param { uint64_t nodeid; uint64_t parent_nid; uint8_t valid:1; }; /* * vnode comparison routines for the VFS hash */ vfs_hash_cmp_t fuse_vnode_cmp; vfs_hash_cmp_t fuse_vnode_setparent_cmp; /* * vnode management routines */ void fuse_vnode_init(struct vnode *vp, struct fuse_vnode_data *fvdat, uint64_t nodeid, enum vtype vtyp, uint64_t parentid); /* prohibit further usage of vnode */ void fuse_vnode_ditch(struct vnode *vp, struct thread *td); /* lazy vnode teardown routine */ void fuse_vnode_teardown(struct vnode *vp, struct thread *td, struct ucred *cred, enum vtype vtyp); enum vget_mode { VG_NORMAL, VG_WANTNEW, VG_FORCENEW }; int fuse_vget_i(struct mount *mp, struct thread *td, uint64_t nodeid, enum vtype vtyp, struct vnode **vpp, enum vget_mode vmod, uint64_t parentid); /* parameter struct for fuse_get_filehandle() */ struct get_filehandle_param { enum fuse_opcode opcode; uint8_t do_gc:1; uint8_t do_new:1; }; int fuse_get_filehandle(struct vnode *vp, struct thread *td, struct ucred *cred, int mode, struct fuse_filehandle **fufhp, struct get_filehandle_param *gefhp); fuse4bsd-0.3.9~pre1.20080208/fuse_module/fmaster.c0000644000175000017500000003741111151613006017404 0ustar rmhrmh/* * THIS FILE SERVES JUST FOR DIAGNOSTIC PURPOSES. * It implements devices for emulating vfs events for fuse, for testing and * for showing demo code of how vfs event handlers can interact with fuse * messaging. */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" #include "fuse_session.h" #if ! FUSE_KERNELABI_GEQ(7, 5) #define fuse_init_out fuse_init_in_out #endif #define fuprintf(args...) \ uprintf("[kern] " args) /* We need some data from other components which are normally kept private */ extern int __fticket_aw_pull_uio(struct fuse_ticket *tick, struct uio *uio); extern int __fuse_body_audit(struct fuse_ticket *tick, size_t blen); extern int __fticket_wait_answer(struct fuse_ticket *tick); extern fuse_handler_t __fuse_standard_handler; MALLOC_DECLARE(M_FUSEMSG); struct clonedevs { LIST_HEAD(,cdev) head; }; extern struct clonedevs *fuseclones; /* prettyprint routines */ static void pp_fuse_entry_out(struct fuse_entry_out *stru); static void pp_fuse_open_out(struct fuse_open_out *stru); static void pp_fuse_write_out(struct fuse_write_out *stru); #if 0 static void pp_fuse_getxattr_out(struct fuse_getxattr_out *stru); #endif static void pp_fuse_init_out(struct fuse_init_out *stru); static void pp_fuse_attr_out(struct fuse_attr_out *stru); static void pp_fuse_statfs_out(struct fuse_statfs_out *stru); static void pp_buf(struct fuse_iov *fiov); static void fuse_response_prettyprint(enum fuse_opcode opcode, struct fuse_iov *fresp); fuse_handler_t prettyprint_handler; d_open_t fmaster_open; d_close_t fmaster_close; // d_read_t fmaster_read; d_write_t fmaster0_write, fmaster1_write, fmaster2_write, fmaster3_write, fmaster4_write; struct cdevsw fmaster_cdevsw[] = { { .d_open = fmaster_open, .d_close = fmaster_close, .d_name = "fmaster0", // .d_read = fmaster_read, .d_write = fmaster0_write, .d_version = D_VERSION #if ! DO_GIANT_MANUALLY .d_flags = D_NEEDGIANT, #endif }, { .d_open = fmaster_open, .d_close = fmaster_close, .d_name = "fmaster1", // .d_read = fmaster_read, .d_write = fmaster1_write, .d_version = D_VERSION #if ! DO_GIANT_MANUALLY .d_flags = D_NEEDGIANT, #endif }, { .d_open = fmaster_open, .d_close = fmaster_close, .d_name = "fmaster2", // .d_read = fmaster_read, .d_write = fmaster2_write, .d_version = D_VERSION #if ! DO_GIANT_MANUALLY .d_flags = D_NEEDGIANT, #endif }, { .d_open = fmaster_open, .d_close = fmaster_close, .d_name = "fmaster3", // .d_read = fmaster_read, .d_write = fmaster3_write, .d_version = D_VERSION #if ! DO_GIANT_MANUALLY .d_flags = D_NEEDGIANT, #endif }, { .d_open = fmaster_open, .d_close = fmaster_close, .d_name = "fmaster4", // .d_read = fmaster_read, .d_write = fmaster3_write, .d_version = D_VERSION #if ! DO_GIANT_MANUALLY .d_flags = D_NEEDGIANT, #endif } }; /******************************* * * >>> Fuse master device dev ops * ******************************/ int fmaster_open(struct cdev *dev, int oflags, int devtype, struct thread *td) { #if DO_GIANT_MANUALLY mtx_lock(&Giant); #endif if (fuse_useco < 0) { /* Module unload is going on */ #if DO_GIANT_MANUALLY mtx_unlock(&Giant); #endif DEBUG2G("caught in the middle of unload\n"); return (ENOENT); } fuse_useco++; #if DO_GIANT_MANUALLY mtx_unlock(&Giant); #endif DEBUG2G("Opened device \"fmaster\" (that of minor %d) successfully on thread %d.\n", minor(dev), td->td_tid); return(0); } int fmaster_close(struct cdev *dev, int fflag, int devtype, struct thread *td) { fuse_useco--; DEBUG2G("Closed device \"fmaster\" (that of minor %d) successfully on thread %d.\n", minor(dev), td->td_tid); return(0); } #if DO_GIANT_MANUALLY && ! USE_FUSE_LOCK #define FMASTER_LOCK mtx_lock(&Giant) #define FMASTER_UNLOCK mtx_unlock(&Giant) #else #define FMASTER_LOCK FUSE_LOCK #define FMASTER_UNLOCK FUSE_UNLOCK #endif #define FMASTER_COMMON_INBLAHBLAH \ int err = 0; \ struct fuse_ticket *tick; \ size_t len; \ struct fuse_in_header *ihead; \ struct cdev *fusedev; \ struct fuse_data *data; \ \ FMASTER_LOCK; \ if (! (fusedev = LIST_FIRST(&fuseclones->head))) { \ FMASTER_UNLOCK; \ return (ENXIO); \ } \ \ if (! (data = fusedev_get_data(fusedev))) { \ FMASTER_UNLOCK; \ uprintf("first fuse device is not in use\n"); \ err = ENXIO; \ goto out; \ } \ data->mntco++; \ dev_ref(fusedev); \ FMASTER_UNLOCK; \ \ len = uio->uio_iov->iov_len; \ \ if (len > 2 * data->max_write || len < sizeof(*ihead)) { \ uprintf("Bogus input for fmaster!"); \ err = EINVAL; \ goto out; \ } \ \ tick = fuse_ticket_fetch(data); \ fiov_adjust(&tick->tk_ms_fiov, len); \ \ err = uiomove(tick->tk_ms_fiov.base, len, uio); \ \ if (err != 0) { \ uprintf("Write failed: bad address!\n"); \ fuse_ticket_drop(tick); \ goto out; \ } \ \ ihead = (struct fuse_in_header *)tick->tk_ms_fiov.base; \ ihead->unique = tick->tk_unique; #define FMASTER_COMMON_OUTBLAHBLAH \ out: \ if (data) { \ data->mntco--; \ FMASTER_LOCK; \ if (data->mntco == 0 && \ ! (data->dataflag & FSESS_OPENED)) { \ fusedev->si_drv1 = NULL; \ fdata_destroy(data); \ } \ FMASTER_UNLOCK; \ dev_rel(fusedev); \ } \ return (err); /* * example how a syscall handler routine can send a request when answer is ignorable */ int fmaster0_write(struct cdev *dev, struct uio *uio, int ioflag) { FMASTER_COMMON_INBLAHBLAH /* style(9) don't say you shouldn't do this ;P */ /* Hey, I mean it's demo code... */ fuse_insert_callback(tick, NULL); fuse_insert_message(tick); FMASTER_COMMON_OUTBLAHBLAH } /* example how a syscall handler routine can send a "background" request (that is, the syscall handler itself is ended, but the installed callback handler will be invoked upon response) (Note: I don't yet know how useful this mechanism is, but at least currently this is used for sending init upon open -- obviously, fuse_dev_open() can't wait for device I/O ... see fuse_dev_open() and fuse_init_handler() in fuse.c) */ int fmaster1_write(struct cdev *dev, struct uio *uio, int ioflag) { FMASTER_COMMON_INBLAHBLAH fuse_insert_callback(tick, prettyprint_handler); fuse_insert_message(tick); FMASTER_COMMON_OUTBLAHBLAH } /* example how a syscall handler routine can send a request and handle response by itself */ int fmaster2_write(struct cdev *dev, struct uio *uio, int ioflag) { FMASTER_COMMON_INBLAHBLAH fuse_insert_callback(tick, __fuse_standard_handler); fuse_insert_message(tick); /* so now we go to sleep till answer arrives */ if ((err = __fticket_wait_answer(tick))) { fuprintf("For Heaven's sake, we've been interrupted!\n"); fuse_ticket_drop(tick); goto out; } if ((err = tick->tk_aw_errno)) fuprintf("some IO or data format error occurred when answer was written to us"); else fuse_response_prettyprint(fticket_opcode(tick), fticket_resp(tick)); fuse_ticket_drop(tick); FMASTER_COMMON_OUTBLAHBLAH } /* example how a syscall handler routine can send a request when no answer is expected */ int fmaster3_write(struct cdev *dev, struct uio *uio, int ioflag) { FMASTER_COMMON_INBLAHBLAH fticket_disown(tick); /* so ticket will be dropped after read passes it up */ fuse_insert_message(tick); FMASTER_COMMON_OUTBLAHBLAH } /* a not too effective application of the new API. * that kind of preparement stage is not suitable here, * and fuse_response_prettyprint() wants a fuse_iov so it * can't use fdi.answ. * Functionally by-and-large equiv. with fmaster2_write(), though * it's less verbose, and might set different errno value. */ int fmaster4_write(struct cdev *dev, struct uio *uio, int ioflag) { struct fuse_dispatcher fdi; FMASTER_COMMON_INBLAHBLAH fdi.tick = tick; if ((err = fdisp_wait_answ(&fdi))) return (err); fuse_response_prettyprint(fticket_opcode(tick), fticket_resp(tick)); fuse_ticket_drop(tick); FMASTER_COMMON_OUTBLAHBLAH } /****************************** * * >>> Prettyprintintig stuff * ******************************/ static void pp_fuse_entry_out(struct fuse_entry_out *stru) { fuprintf("fuse_entry_out -- nodeid: %llu, generation: %llu, entry_valid: %llu, attr_valid: %llu, entry_valid_nsec: %i, attr_valid_nsec: %i, struct attr...\n", (unsigned long long)stru->nodeid, (unsigned long long)stru->generation, (unsigned long long)stru->entry_valid, (unsigned long long)stru->attr_valid, stru->entry_valid_nsec, stru->attr_valid_nsec); fuprintf("\tattr -- ino: %llu, size: %llu, blocks: %llu, atime: %llu, mtime: %llu, ctime: %llu, atimensec: %i, mtimensec: %i, ctimensec: %i, mode: %i, nlink: %i, uid: %i, gid: %i, rdev: %i\n", (unsigned long long)stru->attr.ino, (unsigned long long)stru->attr.size, (unsigned long long)stru->attr.blocks, (unsigned long long)stru->attr.atime, (unsigned long long)stru->attr.mtime, (unsigned long long)stru->attr.ctime, stru->attr.atimensec, stru->attr.mtimensec, stru->attr.ctimensec, stru->attr.mode, stru->attr.nlink, stru->attr.uid, stru->attr.gid, stru->attr.rdev); } static void pp_fuse_open_out(struct fuse_open_out *stru) { fuprintf("fuse_open_out -- fh: %llu, open_flags: %i, padding: %i\n", (unsigned long long)stru->fh, stru->open_flags, stru->padding); } static void pp_fuse_write_out(struct fuse_write_out *stru) { fuprintf("fuse_write_out -- size: %i, padding: %i\n", stru->size, stru->padding); } #if 0 static void pp_fuse_getxattr_out(struct fuse_getxattr_out *stru) { fuprintf("fuse_getxattr_out -- size: %i, padding: %i\n", stru->size, stru->padding); } #endif static void pp_fuse_init_out(struct fuse_init_out *stru) { fuprintf("major: %i, minor: %i", stru->major, stru->minor); #if FUSE_KERNELABI_GEQ(7, 5) fuprintf( #if ! FUSE_KERNELABI_GEQ(7, 6) "name_max: %i, symlink_max: %i, xattr_size_max: %i, " #endif "max_write: %i", #if ! FUSE_KERNELABI_GEQ(7, 6) stru->name_max, stru->symlink_max, stru->xattr_size_max, #endif stru->max_write); #endif fuprintf("\n"); } static void pp_fuse_attr_out(struct fuse_attr_out *stru) { fuprintf("fuse_entry_out -- attr_valid: %llu, attr_valid_nsec: %i, dummy: %i, struct attr...\n", (unsigned long long)stru->attr_valid, stru->attr_valid_nsec, stru->dummy); fuprintf("\tattr -- ino: %llu, size: %llu, blocks: %llu, atime: %llu, mtime: %llu, ctime: %llu, atimensec: %i, mtimensec: %i, ctimensec: %i, mode: %i, nlink: %i, uid: %i, gid: %i, rdev: %i\n", (unsigned long long)stru->attr.ino, (unsigned long long)stru->attr.size, (unsigned long long)stru->attr.blocks, (unsigned long long)stru->attr.atime, (unsigned long long)stru->attr.mtime, (unsigned long long)stru->attr.ctime, stru->attr.atimensec, stru->attr.mtimensec, stru->attr.ctimensec, stru->attr.mode, stru->attr.nlink, stru->attr.uid, stru->attr.gid, stru->attr.rdev); } static void pp_fuse_statfs_out(struct fuse_statfs_out *stru) { fuprintf("fuse_statfs_out -- blocks: %llu, bfree: %llu, bavail: %llu, files: %llu, ffree: %llu, bsize: %i, namelen: %i\n", (unsigned long long)stru->st.blocks, (unsigned long long)stru->st.bfree, (unsigned long long)stru->st.bavail, (unsigned long long)stru->st.files, (unsigned long long)stru->st.ffree, stru->st.bsize, stru->st.namelen); } static void pp_buf(struct fuse_iov *fiov) { fuprintf("buffer -- "); fprettyprint(fiov, 80); } static void fuse_response_prettyprint(enum fuse_opcode opcode, struct fuse_iov *fresp) { fuprintf("daemon sent reply to op %s (#%d)\n", fuse_opnames[opcode], opcode); switch (opcode) { case FUSE_LOOKUP: pp_fuse_entry_out((struct fuse_entry_out*)fresp->base); break; case FUSE_FORGET: KASSERT(0, ("a handler has been intalled for FUSE_FORGET")); break; case FUSE_GETATTR: pp_fuse_attr_out((struct fuse_attr_out*)fresp->base); break; case FUSE_SETATTR: pp_fuse_attr_out((struct fuse_attr_out*)fresp->base); break; case FUSE_READLINK: break; case FUSE_SYMLINK: pp_fuse_entry_out((struct fuse_entry_out*)fresp->base); break; case FUSE_MKNOD: pp_fuse_entry_out((struct fuse_entry_out*)fresp->base); break; case FUSE_MKDIR: pp_fuse_entry_out((struct fuse_entry_out*)fresp->base); break; case FUSE_UNLINK: //pp_buf(fresp); break; case FUSE_RMDIR: //pp_buf(fresp); break; case FUSE_RENAME: //pp_buf(fresp); break; case FUSE_LINK: pp_fuse_entry_out((struct fuse_entry_out*)fresp->base); break; case FUSE_OPEN: pp_fuse_open_out((struct fuse_open_out*)fresp->base); break; case FUSE_READ: pp_buf(fresp); break; case FUSE_WRITE: pp_fuse_write_out((struct fuse_write_out*)fresp->base); break; case FUSE_STATFS: pp_fuse_statfs_out((struct fuse_statfs_out*)fresp->base); break; case FUSE_FLUSH: //pp_buf(fresp); break; case FUSE_RELEASE: //pp_buf(fresp); break; case FUSE_FSYNC: //pp_buf(fresp); break; case FUSE_SETXATTR: KASSERT(0, ("FUSE_SETXATTR implementor has forgotten to define a response body format check")); break; case FUSE_GETXATTR: KASSERT(0, ("FUSE_GETXATTR implementor has forgotten to define a response body format check")); break; case FUSE_LISTXATTR: KASSERT(0, ("FUSE_LISTXATTR implementor has forgotten to define a response body format check")); break; case FUSE_REMOVEXATTR: KASSERT(0, ("FUSE_REMOVEXATTR implementor has forgotten to define a response body format check")); break; case FUSE_INIT: pp_fuse_init_out((struct fuse_init_out*)fresp->base); break; case FUSE_OPENDIR: pp_fuse_open_out((struct fuse_open_out*)fresp->base); break; case FUSE_READDIR: pp_buf(fresp); break; case FUSE_RELEASEDIR: //pp_buf(fresp); break; case FUSE_FSYNCDIR: //pp_buf(fresp); break; #if FUSE_HAS_ACCESS case FUSE_ACCESS: break; #endif #if FUSE_HAS_CREATE case FUSE_CREATE: pp_fuse_entry_out((struct fuse_entry_out*)fresp->base); pp_fuse_open_out((struct fuse_open_out*)( (struct fuse_entry_out*)fresp->base + 1 )); break; #endif #if FUSE_HAS_GETLK case FUSE_GETLK: panic("FUSE_GETLK implementor has forgotten to define a response body format check"); break; #endif #if FUSE_HAS_SETLK case FUSE_SETLK: panic("FUSE_SETLK implementor has forgotten to define a response body format check"); break; #endif #if FUSE_HAS_SETLKW case FUSE_SETLKW: panic("FUSE_SETLKW implementor has forgotten to define a response body format check"); break; #endif #if FUSE_HAS_INTERRUPT case FUSE_INTERRUPT: panic("FUSE_INTERRUPT implementor has forgotten to define a response body format check"); break; #endif default: KASSERT(0, ("fuse opcodes out of sync")); } } int prettyprint_handler(struct fuse_ticket *tick, struct uio *uio) { enum fuse_opcode opcode; int err = 0; opcode = fticket_opcode(tick); if (opcode == FUSE_FORGET || opcode == FUSE_SETXATTR || opcode == FUSE_GETXATTR || opcode == FUSE_LISTXATTR || opcode == FUSE_REMOVEXATTR || #if FUSE_HAS_GETLK opcode == FUSE_GETLK || #endif #if FUSE_HAS_SETLK opcode == FUSE_SETLK || #endif #if FUSE_HAS_SETLKW opcode == FUSE_SETLKW || #endif 0) { fuprintf("Hey, you've inserted a %s (#%d) request, don't do it in real life, it breaks an assertion!\n", fuse_opnames[opcode], opcode); goto out; } if ((err = __fuse_body_audit(tick, uio->uio_resid))) { fuprintf("body audit refused body\n"); goto out; } if ((err = __fticket_aw_pull_uio(tick, uio))) { fuprintf("uio pulling failed\n"); goto out; } fuse_response_prettyprint(opcode, fticket_resp(tick)); out: DEBUG("dropping ticket in prettyprint_handler\n"); fuse_ticket_drop(tick); return (err); } fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_subr.c0000644000175000017500000000644111151613006017737 0ustar rmhrmh/* * Planned for general subroutines which are useful but not defined in the * kernel. Currently contains only debug related stuff. */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" #include "fuse_session.h" #if _DEBUG || _DEBUG2G || _DEBUG3G || defined(INVARIANTS) || FUSELIB_CONFORM_BIOREAD int isbzero(void *buf, size_t len) { int i; for (i = 0; i < len; i++) { if (((char *)buf)[i]) return (0); } return (1); } #endif /* _DEBUG || _DEBUG2G || _DEBUG3G */ #if _DEBUG || _DEBUG2G || _DEBUG3G || FMASTER static char *pptable[] = { "\\000", "\\001", "\\002", "\\003", "\\004", "\\005", "\\006", "\\a", "\\010", "\\t", "\\n", "\\v", "\\f", "\\r", "\\016", "\\017", "\\020", "\\021", "\\022", "\\023", "\\024", "\\025", "\\026", "\\027", "\\030", "\\031", "\\032", "\\e", "\\034", "\\035", "\\036", "\\037", " ", "!", "\"", "#", "$", "%", "&", "'", "(", ")", "*", "+", ",", "-", ".", "/", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";", "<", "=", ">", "?", "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]", "^", "_", "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~", "\\177", "\\200", "\\201", "\\202", "\\203", "\\204", "\\205", "\\206", "\\207", "\\210", "\\211", "\\212", "\\213", "\\214", "\\215", "\\216", "\\217", "\\220", "\\221", "\\222", "\\223", "\\224", "\\225", "\\226", "\\227", "\\230", "\\231", "\\232", "\\233", "\\234", "\\235", "\\236", "\\237", "\\240", "\\241", "\\242", "\\243", "\\244", "\\245", "\\246", "\\247", "\\250", "\\251", "\\252", "\\253", "\\254", "\\255", "\\256", "\\257", "\\260", "\\261", "\\262", "\\263", "\\264", "\\265", "\\266", "\\267", "\\270", "\\271", "\\272", "\\273", "\\274", "\\275", "\\276", "\\277", "\\300", "\\301", "\\302", "\\303", "\\304", "\\305", "\\306", "\\307", "\\310", "\\311", "\\312", "\\313", "\\314", "\\315", "\\316", "\\317", "\\320", "\\321", "\\322", "\\323", "\\324", "\\325", "\\326", "\\327", "\\330", "\\331", "\\332", "\\333", "\\334", "\\335", "\\336", "\\337", "\\340", "\\341", "\\342", "\\343", "\\344", "\\345", "\\346", "\\347", "\\350", "\\351", "\\352", "\\353", "\\354", "\\355", "\\356", "\\357", "\\360", "\\361", "\\362", "\\363", "\\364", "\\365", "\\366", "\\367", "\\370", "\\371", "\\372", "\\373", "\\374", "\\375", "\\376", "\\377" }; void uprettyprint(char *buf, size_t len) { int i; uprintf("\""); for (i=0; i < len; i++) { uprintf("%s",pptable[((uint8_t *)buf)[i]]); } uprintf("\""); } void prettyprint(char *buf, size_t len) { int i; printf("\""); for (i=0; i < len; i++) { printf("%s",pptable[((uint8_t *)buf)[i]]); } printf("\""); } void fprettyprint(struct fuse_iov *fiov, size_t dlen) { int i; uprintf("\""); for (i=0; i < MIN(fiov->len, dlen); i++) { uprintf("%s",pptable[((uint8_t *)fiov->base)[i]]); } uprintf("\""); uprintf("%s\n", dlen < fiov->len ? "..." : ""); } #endif /* _DEBUG || _DEBUG2G || _DEBUG3G || FMASTER */ fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_msg.c0000644000175000017500000006075411151613006017561 0ustar rmhrmh/* * Messaging related routines. */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" #include "fuse_session.h" #include "fuse_vnode.h" static struct fuse_ticket *fticket_alloc(struct fuse_data *data); static void fticket_refresh(struct fuse_ticket *tick); static void fticket_destroy(struct fuse_ticket *tick); static int fticket_wait_answer(struct fuse_ticket *tick); static __inline int fticket_aw_pull_uio(struct fuse_ticket *tick, struct uio *uio); static __inline void fuse_push_freeticks(struct fuse_ticket *tick); static __inline struct fuse_ticket *fuse_pop_freeticks(struct fuse_data *data); static __inline void fuse_push_allticks(struct fuse_ticket *tick); static __inline void fuse_remove_allticks(struct fuse_ticket *tick); static struct fuse_ticket *fuse_pop_allticks(struct fuse_data *data); static int fuse_body_audit(struct fuse_ticket *tick, size_t blen); static __inline void fuse_setup_ihead(struct fuse_in_header *ihead, struct fuse_ticket *tick, uint64_t nid, enum fuse_opcode op, size_t blen, pid_t pid, struct ucred *cred); static fuse_handler_t fuse_standard_handler; SYSCTL_NODE(_vfs, OID_AUTO, fuse, CTLFLAG_RW, 0, "FUSE tunables"); SYSCTL_STRING(_vfs_fuse, OID_AUTO, fuse4bsd_version, CTLFLAG_RD, FUSE4BSD_VERSION, 0, "fuse4bsd version"); static int maxfreetickets = 1024; SYSCTL_INT(_vfs_fuse, OID_AUTO, maxfreetickets, CTLFLAG_RW, &maxfreetickets, 0, "limit for number of free tickets kept"); static long fuse_iov_permanent_bufsize = 1 << 19; SYSCTL_LONG(_vfs_fuse, OID_AUTO, iov_permanent_bufsize, CTLFLAG_RW, &fuse_iov_permanent_bufsize, 0, "limit for permanently stored buffer size for fuse_iovs"); static int fuse_iov_credit = 16; SYSCTL_INT(_vfs_fuse, OID_AUTO, iov_credit, CTLFLAG_RW, &fuse_iov_credit, 0, "how many times is an oversized fuse_iov tolerated"); static unsigned maxtickets = 0; SYSCTL_UINT(_vfs_fuse, OID_AUTO, maxtickets, CTLFLAG_RW, &maxtickets, 0, "limit how many tickets are tolerated"); MALLOC_DEFINE(M_FUSEMSG, "fuse_messaging", "buffer for fuse messaging related things"); /*************************************** * * >>> Interface ("methods") of messaging related objects * ***************************************/ /* fuse_iov methods ==> */ void fiov_init(struct fuse_iov *fiov, size_t size) { fiov->len = 0; fiov->base = malloc(FU_AT_LEAST(size), M_FUSEMSG, M_WAITOK | M_ZERO); fiov->allocated_size = FU_AT_LEAST(size); fiov->credit = fuse_iov_credit; } void fiov_teardown(struct fuse_iov *fiov) { free(fiov->base, M_FUSEMSG); } void fiov_adjust(struct fuse_iov *fiov, size_t size) { if (fiov->allocated_size < size || (fuse_iov_permanent_bufsize >= 0 && fiov->allocated_size - size > fuse_iov_permanent_bufsize && --fiov->credit < 0)) { fiov->base = realloc(fiov->base, FU_AT_LEAST(size), M_FUSEMSG, M_WAITOK | M_ZERO); fiov->allocated_size = FU_AT_LEAST(size); fiov->credit = fuse_iov_credit; } fiov->len = size; } void fiov_refresh(struct fuse_iov *fiov) { bzero(fiov->base, fiov->len); fiov_adjust(fiov, 0); } /* <== fuse_iov methods */ /* fuse_ticket methods ==> */ /* * Tickets are carriers of communication with a fuse daemon. * Tickets have a unique id, which should be kept unique * among synchronously used tickets. The everyday routine: * + Syscall handler gets one by fuse_ticket_fetch() * (then, behind the scenes, either a fresh one is allocated * or a cached old one is put into use again) * + Sets up data to be passed to the daemon * (there is a message node attached to the ticket) * + If she knows that answer will come, sets up the callback node * attached to the ticket, and enqueues it to the callback nodes' list * + enqueues the message and kicks fusedev_read() * + if daemon gives a proper answer, it will contain the unique id, by which * fusedev_write() can pick the pre-prepared callback node and run it. * There is the standard callback handler which just awakes the syscall * handler who then waits for the response, deal with it by herself. * Another option is to write a full-fledged callback handler which does all * data processing within fusedev_write()'s thread (although we never do * this). Or, if the answer is uninteresting, a NULL handler can be used. * + After answer has been consumed, the handler or anyone to whom the control * has been passed supposed to call ticket_drop() * (then, behind the scenes, either the ticket is destroyed, or put into * cache) */ static struct fuse_ticket * fticket_alloc(struct fuse_data *data) { struct fuse_ticket *tick; tick = malloc(sizeof(*tick), M_FUSEMSG, M_WAITOK | M_ZERO); tick->tk_data = data; fiov_init(&tick->tk_ms_fiov, sizeof(struct fuse_in_header)); tick->tk_ms_type = FT_M_FIOV; mtx_init(&tick->tk_aw_mtx, "fuse answer delivery mutex", NULL, MTX_DEF); fiov_init(&tick->tk_aw_fiov, 0); fiov_init(&tick->tk_aw_handler_parm, 0); tick->tk_aw_type = FT_A_FIOV; return (tick); } static __inline void fticket_refresh(struct fuse_ticket *tick) { fiov_refresh(&tick->tk_ms_fiov); tick->tk_ms_bufdata = NULL; tick->tk_ms_bufsize = 0; tick->tk_ms_type = FT_M_FIOV; bzero(&tick->tk_aw_ohead, sizeof(struct fuse_out_header)); fiov_refresh(&tick->tk_aw_fiov); fiov_adjust(&tick->tk_aw_handler_parm, 0); tick->tk_aw_errno = 0; tick->tk_aw_bufdata = NULL; tick->tk_aw_bufsize = 0; tick->tk_aw_type = FT_A_FIOV; tick->tk_flag = 0; tick->tk_age++; } static void fticket_destroy(struct fuse_ticket *tick) { fiov_teardown(&tick->tk_ms_fiov); mtx_destroy(&tick->tk_aw_mtx); fiov_teardown(&tick->tk_aw_fiov); fiov_teardown(&tick->tk_aw_handler_parm); free(tick, M_FUSEMSG); } static int fticket_wait_answer(struct fuse_ticket *tick) { int err = 0; mtx_lock(&tick->tk_aw_mtx); if (fticket_answered(tick)) goto out; if (fdata_kick_get(tick->tk_data)) { err = ENOTCONN; fticket_set_answered(tick); goto out; } err = msleep(tick, &tick->tk_aw_mtx, PCATCH, "fu_ans", 0); out: mtx_unlock(&tick->tk_aw_mtx); if (! (err || fticket_answered(tick))) { /* * Some deadlocky scenarios can get us here, like SIGKILLing * the fusexmp daemon after a fuse dir has been null mounted * over its original copy in the "normal" fs * * (I guess there is no need of kicking the daemon at this * point...) */ DEBUG2G("fuse requester was woken up but still no answer"); err = ENXIO; } return (err); } static __inline int fticket_aw_pull_uio(struct fuse_ticket *tick, struct uio *uio) { int err = 0; size_t len; len = uio->uio_resid; if (len) { switch (tick->tk_aw_type) { case FT_A_FIOV: fiov_adjust(fticket_resp(tick), len); err = uiomove(fticket_resp(tick)->base, len, uio); break; case FT_A_BUF: tick->tk_aw_bufsize = len; err = uiomove(tick->tk_aw_bufdata, len, uio); break; default: panic("unknown answer type for fuse_ticket %p", tick); } } DEBUG("uio pulled, error val: %d\n",err); return (err); } int fticket_pull(struct fuse_ticket *tick, struct uio *uio) { int err = 0; if (tick->tk_aw_ohead.error) return (0); err = fuse_body_audit(tick, uio->uio_resid); if (! err) err = fticket_aw_pull_uio(tick, uio); return (err); } /* <== fuse_ticket methods */ /* fuse_data methods ==> */ struct fuse_data * fdata_alloc(struct cdev *fdev, struct ucred *cred) { struct fuse_data *data; data = malloc(sizeof(struct fuse_data), M_FUSEMSG, M_WAITOK | M_ZERO); /* Setting up fields of mine */ data->mpri = FM_NOMOUNTED; data->fdev = fdev; mtx_init(&data->ms_mtx, "fuse message list mutex", NULL, MTX_DEF); STAILQ_INIT(&data->ms_head); mtx_init(&data->ticket_mtx, "fuse ticketer mutex", NULL, MTX_DEF); STAILQ_INIT(&data->freetickets_head); TAILQ_INIT(&data->alltickets_head); mtx_init(&data->aw_mtx, "fuse answer list mutex", NULL, MTX_DEF); TAILQ_INIT(&data->aw_head); data->daemoncred = crhold(cred); sx_init(&data->mhierlock, "fuse hierarchy of mounts lock"); LIST_INIT(&data->slaves_head); sx_init(&data->rename_lock, "fuse rename lock"); return (data); } void fdata_destroy(struct fuse_data *data) { struct fuse_ticket *tick; /* Driving off stage all that stuff thrown at device... */ mtx_destroy(&data->ms_mtx); mtx_destroy(&data->aw_mtx); mtx_destroy(&data->ticket_mtx); sx_destroy(&data->rename_lock); while ((tick = fuse_pop_allticks(data))) fticket_destroy(tick); crfree(data->daemoncred); sx_destroy(&data->mhierlock); free(data,M_FUSEMSG); } int fdata_kick_get(struct fuse_data *data) { DEBUG("0x%x\n", data->dataflag & FSESS_KICK); return (data->dataflag & FSESS_KICK); } void fdata_kick_set(struct fuse_data *data) { struct fuse_ticket *tick; DEBUG2G("banning daemon\n"); mtx_lock(&data->ms_mtx); data->dataflag |= FSESS_KICK; wakeup_one(data); selwakeuppri(&data->ks_rsel, PZERO + 1); mtx_unlock(&data->ms_mtx); mtx_lock(&data->ticket_mtx); wakeup(&data->ticketer); mtx_unlock(&data->ticket_mtx); mtx_lock(&data->aw_mtx); TAILQ_FOREACH(tick, &data->aw_head, tk_aw_link) wakeup_one(tick); mtx_unlock(&data->aw_mtx); } /* <== fuse_data methods */ /********************* * * >>> "Multi-dispatch" routines * *********************/ static __inline void fuse_push_freeticks(struct fuse_ticket *tick) { STAILQ_INSERT_TAIL(&tick->tk_data->freetickets_head, tick, tk_freetickets_link); tick->tk_data->freeticket_counter++; } static __inline struct fuse_ticket * fuse_pop_freeticks(struct fuse_data *data) { struct fuse_ticket *tick; if ((tick = STAILQ_FIRST(&data->freetickets_head))) { STAILQ_REMOVE_HEAD(&data->freetickets_head, tk_freetickets_link); data->freeticket_counter--; } return tick; } /**/ static __inline void fuse_push_allticks(struct fuse_ticket *tick) { tick->tk_unique = tick->tk_data->ticketer++; TAILQ_INSERT_TAIL(&tick->tk_data->alltickets_head, tick, tk_alltickets_link); } static __inline void fuse_remove_allticks(struct fuse_ticket *tick) { tick->tk_data->deadticket_counter++; TAILQ_REMOVE(&tick->tk_data->alltickets_head, tick, tk_alltickets_link); } static struct fuse_ticket * fuse_pop_allticks(struct fuse_data *data) { struct fuse_ticket *tick; if ((tick = TAILQ_FIRST(&data->alltickets_head))) { fuse_remove_allticks(tick); } return (tick); } struct fuse_ticket * fuse_ticket_fetch(struct fuse_data *data) { struct fuse_ticket *tick; int err = 0; DEBUG("fetching ticket\n"); if (data->freeticket_counter == 0) { tick = fticket_alloc(data); mtx_lock(&data->ticket_mtx); fuse_push_allticks(tick); } else { mtx_lock(&data->ticket_mtx); tick = fuse_pop_freeticks(data); KASSERT(tick, ("no free ticket available tho counter said there is")); } #if _DEBUG_UNIQUE tick->tk_unique = tick->tk_unique % 10000 + ++data->msgcou * 10000; #endif if (! (data->dataflag & FSESS_INITED) && data->ticketer > 1) err = msleep(&data->ticketer, &data->ticket_mtx, PCATCH | PDROP, "fu_ini", 0); else { if (maxtickets && data->ticketer - data->deadticket_counter > maxtickets) err = 1; mtx_unlock(&data->ticket_mtx); } if (err) fdata_kick_set(data); return (tick); } void fuse_ticket_drop(struct fuse_ticket *tick) { int die = 0; /* * Limit below should be tunable by a sysctl? * Probably not worth for the effort. */ if (maxfreetickets >= 0 && maxfreetickets <= tick->tk_data->freeticket_counter) { die = 1; DEBUG("ticket will die\n"); } else fticket_refresh(tick); mtx_lock(&tick->tk_data->ticket_mtx); if (die) { fuse_remove_allticks(tick); mtx_unlock(&tick->tk_data->ticket_mtx); fticket_destroy(tick); } else { fuse_push_freeticks(tick); mtx_unlock(&tick->tk_data->ticket_mtx); } DEBUG("ticket removed\n"); } void fuse_ticket_drop_notowned(struct fuse_ticket *tick) { if (tick->tk_flag & FT_NOTOWNED) fuse_ticket_drop(tick); } void fuse_insert_callback(struct fuse_ticket *tick, fuse_handler_t *handler) { /* * If our session is defunct, then neither go on nor make fuss. * Just return. (Making only fticket_wait_answer() fallible is good * enough.) */ if (fdata_kick_get(tick->tk_data)) return; tick->tk_aw_handler = handler; mtx_lock(&tick->tk_data->aw_mtx); fuse_aw_push(tick); mtx_unlock(&tick->tk_data->aw_mtx); } void fuse_insert_message(struct fuse_ticket *tick) { if (tick->tk_flag & FT_DIRTY) panic("ticket reused without being refreshed"); tick->tk_flag |= FT_DIRTY; if (fdata_kick_get(tick->tk_data)) { fuse_ticket_drop_notowned(tick); return; } mtx_lock(&tick->tk_data->ms_mtx); fuse_ms_push(tick); DEBUG("ring the bell\n"); wakeup_one(tick->tk_data); selwakeuppri(&tick->tk_data->ks_rsel, PZERO + 1); mtx_unlock(&tick->tk_data->ms_mtx); } static int fuse_body_audit(struct fuse_ticket *tick, size_t blen) { int err = 0; enum fuse_opcode opcode; opcode = fticket_opcode(tick); DEBUG("op %s (#%d) was sent to us with a body of size %d\n", (0 <= opcode && opcode <= fuse_opnames_entries) ? fuse_opnames[opcode] : "???", opcode, (int)blen); switch (opcode) { case FUSE_LOOKUP: err = blen == sizeof(struct fuse_entry_out) ? 0 : EINVAL; break; case FUSE_FORGET: panic("a handler has been intalled for FUSE_FORGET"); break; case FUSE_GETATTR: err = blen == sizeof(struct fuse_attr_out) ? 0 : EINVAL; break; case FUSE_SETATTR: err = blen == sizeof(struct fuse_attr_out) ? 0 : EINVAL; break; case FUSE_READLINK: /* * We use the same limit as Linux FUSE, except for that * don't reserve the last byte for a terminating zero... */ err = PAGE_SIZE >= blen ? 0 : EINVAL; break; case FUSE_SYMLINK: err = blen == sizeof(struct fuse_entry_out) ? 0 : EINVAL; break; case FUSE_MKNOD: err = blen == sizeof(struct fuse_entry_out) ? 0 : EINVAL; break; case FUSE_MKDIR: err = blen == sizeof(struct fuse_entry_out) ? 0 : EINVAL; break; case FUSE_UNLINK: err = blen == 0 ? 0 : EINVAL; break; case FUSE_RMDIR: err = blen == 0 ? 0 : EINVAL; break; case FUSE_RENAME: err = blen == 0 ? 0 : EINVAL; break; case FUSE_LINK: err = blen == sizeof(struct fuse_entry_out) ? 0 : EINVAL; break; case FUSE_OPEN: err = blen == sizeof(struct fuse_open_out) ? 0 : EINVAL; break; case FUSE_READ: /* * we do whatever crazyness is needed to read the original * request size, starting from the callback node, and then * check whether available data doesn't grow over that. */ err = ((struct fuse_read_in *)( (char *)tick->tk_ms_fiov.base + sizeof(struct fuse_in_header) ))->size >= blen ? 0 : EINVAL; break; case FUSE_WRITE: err = blen == sizeof(struct fuse_write_out) ? 0 : EINVAL; break; case FUSE_STATFS: #if FUSE_KERNELABI_GEQ(7, 4) if (fuse_libabi_geq(tick->tk_data, 7, 4)) err = blen == sizeof(struct fuse_statfs_out) ? 0 : EINVAL; else err = blen == FUSE_COMPAT_STATFS_SIZE ? 0 : EINVAL; #else err = blen == sizeof(struct fuse_statfs_out) ? 0 : EINVAL; #endif break; case FUSE_FLUSH: err = blen == 0 ? 0 : EINVAL; break; case FUSE_RELEASE: err = blen == 0 ? 0 : EINVAL; break; case FUSE_FSYNC: err = blen == 0 ? 0 : EINVAL; break; case FUSE_SETXATTR: panic("FUSE_SETXATTR implementor has forgotten to define a response body format check"); break; case FUSE_GETXATTR: panic("FUSE_GETXATTR implementor has forgotten to define a response body format check"); break; case FUSE_LISTXATTR: panic("FUSE_LISTXATTR implementor has forgotten to define a response body format check"); break; case FUSE_REMOVEXATTR: panic("FUSE_REMOVEXATTR implementor has forgotten to define a response body format check"); break; case FUSE_INIT: #if FUSE_KERNELABI_GEQ(7, 5) if (blen == sizeof(struct fuse_init_out) || blen == 8) err = 0; else err = EINVAL; #else err = blen == sizeof(struct fuse_init_in_out) ? 0 : EINVAL; #endif break; case FUSE_OPENDIR: err = blen == sizeof(struct fuse_open_out) ? 0 : EINVAL; break; case FUSE_READDIR: err = ((struct fuse_read_in *)( (char *)tick->tk_ms_fiov.base + sizeof(struct fuse_in_header) ))->size >= blen ? 0 : EINVAL; break; case FUSE_RELEASEDIR: err = blen == 0 ? 0 : EINVAL; break; case FUSE_FSYNCDIR: err = blen == 0 ? 0 : EINVAL; break; #if FUSE_HAS_ACCESS case FUSE_ACCESS: err = blen == 0 ? 0 : EINVAL; break; #endif #if FUSE_HAS_CREATE case FUSE_CREATE: err = blen == sizeof(struct fuse_entry_out) + sizeof(struct fuse_open_out) ? 0 : EINVAL; break; #endif #if FUSE_HAS_DESTROY case FUSE_DESTROY: err = blen == 0 ? 0 : EINVAL; break; #endif #if FUSE_HAS_GETLK case FUSE_GETLK: panic("FUSE_GETLK implementor has forgotten to define a response body format check"); break; #endif #if FUSE_HAS_SETLK case FUSE_SETLK: panic("FUSE_SETLK implementor has forgotten to define a response body format check"); break; #endif #if FUSE_HAS_SETLKW case FUSE_SETLKW: panic("FUSE_SETLKW implementor has forgotten to define a response body format check"); break; #endif #if FUSE_HAS_INTERRUPT case FUSE_INTERRUPT: panic("FUSE_INTERRUPT implementor has forgotten to define a response body format check"); break; #endif default: panic("fuse opcodes out of sync"); } if (err) { #if _DEBUG2G DEBUG2G("op %s (#%d) with body size %d: invalid body size\n", (0 <= opcode && opcode <= fuse_opnames_entries) ? fuse_opnames[opcode] : "???", opcode, (int)blen); #endif fdata_kick_set(tick->tk_data); } return (err); } static void fuse_setup_ihead(struct fuse_in_header *ihead, struct fuse_ticket *tick, uint64_t nid, enum fuse_opcode op, size_t blen, pid_t pid, struct ucred *cred) { ihead->len = sizeof(*ihead) + blen; /* actually not used by lib */ ihead->unique = tick->tk_unique; ihead->nodeid = nid; ihead->opcode = op; ihead->pid = pid; ihead->uid = cred->cr_uid; ihead->gid = cred->cr_rgid; DEBUG2G("in header -- opcode: %2d (\"%s\"), unique: %llu, nodeid: %llu\n", ihead->opcode, fuse_opnames[ihead->opcode], (unsigned long long)ihead->unique, (unsigned long long)ihead->nodeid); } /******************** * * >>> Callback handlers * ********************/ /* * fuse_standard_handler just pulls in data and wakes up pretender. * Doesn't try to interpret data, that's left for the pretender. * Though might do a basic size verification before the pull-in takes place */ static int fuse_standard_handler(struct fuse_ticket *tick, struct uio *uio) { int err = 0; int dropflag = 0; err = fticket_pull(tick, uio); mtx_lock(&tick->tk_aw_mtx); if (fticket_answered(tick)) /* The requester was interrupted and she set the "answered" flag * to notify us. In this case, we don't have to care about * anything, just drop the ticket and get out as fast as we can. */ dropflag = 1; else { fticket_set_answered(tick); tick->tk_aw_errno = err; wakeup(tick); } mtx_unlock(&tick->tk_aw_mtx); if (dropflag) fuse_ticket_drop(tick); return (err); } /*********************************************************************** * * >>> High-level interface to the messaging facilities of fuse devices * ***********************************************************************/ static __inline void __fdisp_make_pid(struct fuse_dispatcher *fdip, struct mount *mp, enum fuse_opcode op, uint64_t nid, pid_t pid, struct ucred *cred) { struct fuse_data *data = mp->mnt_data; KASSERT(data, ("no data for mp %p", mp)); KASSERT(data->mpri != FM_SECONDARY, ("fdisp_make() on secondary mount %p", mp)); #if _DEBUG2G if (data->mpri == FM_NOMOUNTED) DEBUG2G("fuse data %p is not mounted at fdisp_make time!\n", data); #endif if (fdip->tick) fticket_refresh(fdip->tick); else fdip->tick = fuse_ticket_fetch(data); FUSE_DIMALLOC(&fdip->tick->tk_ms_fiov, fdip->finh, fdip->indata, fdip->iosize); fuse_setup_ihead(fdip->finh, fdip->tick, nid, op, fdip->iosize, pid, cred); } void fdisp_make_pid(struct fuse_dispatcher *fdip, struct mount *mp, enum fuse_opcode op, uint64_t nid, pid_t pid, struct ucred *cred) { return (__fdisp_make_pid(fdip, mp, op, nid, pid, cred)); } void fdisp_make(struct fuse_dispatcher *fdip, struct mount *mp, enum fuse_opcode op, uint64_t nid, struct thread *td, struct ucred *cred) { RECTIFY_TDCR(td, cred); return (__fdisp_make_pid(fdip, mp, op, nid, td->td_proc->p_pid, cred)); } void fdisp_make_vp(struct fuse_dispatcher *fdip, enum fuse_opcode op, struct vnode *vp, struct thread *td, struct ucred *cred) { RECTIFY_TDCR(td, cred); return (__fdisp_make_pid(fdip, vp->v_mount, op, VTOI(vp), td->td_proc->p_pid, cred)); } int fdisp_wait_answ(struct fuse_dispatcher *fdip) { int err = 0; fdip->answ_stat = 0; fuse_insert_callback(fdip->tick, fuse_standard_handler); fuse_insert_message(fdip->tick); if ((err = fticket_wait_answer(fdip->tick))) { /* Uh-huh, we got interrupted... */ #ifndef DONT_TRY_HARD_PREVENT_IO_IN_VAIN struct fuse_ticket *tick; unsigned age; #endif mtx_lock(&fdip->tick->tk_aw_mtx); if (fticket_answered(fdip->tick)) { /* * Just between noticing the interrupt and getting here, * the standard handler has completed his job. * So we drop the ticket and exit as usual. */ mtx_unlock(&fdip->tick->tk_aw_mtx); goto out; } else { /* * So we were faster than the standard handler. * Then by setting the answered flag we get *him* * to drop the ticket. */ age = fdip->tick->tk_age; fticket_set_answered(fdip->tick); mtx_unlock(&fdip->tick->tk_aw_mtx); #ifndef DONT_TRY_HARD_PREVENT_IO_IN_VAIN /* * If we are willing to pay with one more locking, we * can save on I/O by getting the device write handler * to drop the ticket. That is, if we are fast enough, * the standard handler -- who does the uiomove -- * won't even be called. (No guarantee though for * being fast.) */ DEBUG2G("interrupted, now trying to prevent io in vain (I'll tell you if it succeeds...)\n"); mtx_lock(&fdip->tick->tk_data->aw_mtx); TAILQ_FOREACH(tick, &fdip->tick->tk_data->aw_head, tk_aw_link) { if (tick == fdip->tick) { if (fdip->tick->tk_age == age) { DEBUG2G("preventing io in vain succeeded\n"); fdip->tick->tk_aw_handler = NULL; } break; } } mtx_unlock(&fdip->tick->tk_data->aw_mtx); #endif return (err); } } if (fdip->tick->tk_aw_errno) { /* * Error with messaging, the VFS layer * won't be particularly interested about * its exact nature */ err = EIO; goto out; } if ((err = fdip->tick->tk_aw_ohead.error)) { /* * This means a "proper" fuse syscall error. * We record this value so the caller will * be able to know it's not a boring messaging * failure, if she wishes so (and if not, she can * just simply propagate the return value of this routine). * [XXX Maybe a bitflag would do the job too, * if other flags needed, this will be converted thusly.] */ fdip->answ_stat = err; goto out; } fdip->answ = fticket_resp(fdip->tick)->base; fdip->iosize = fticket_resp(fdip->tick)->len; return (0); out: fuse_ticket_drop(fdip->tick); return (err); } #ifdef FMASTER /* * Some functions need to be accessed from the fmaster code * which we'd like to keep static. As fmaster is optional, * we'll don't break this scheme for the sake of fmaster. * * As a compromise, we use globally visible wrappers for them. */ int __fticket_aw_pull_uio(struct fuse_ticket *tick, struct uio *uio); int __fuse_body_audit(struct fuse_ticket *tick, size_t blen); int __fticket_wait_answer(struct fuse_ticket *tick); fuse_handler_t __fuse_standard_handler; int __fticket_aw_pull_uio(struct fuse_ticket *tick, struct uio *uio) { return (fticket_aw_pull_uio(tick, uio)); } int __fuse_body_audit(struct fuse_ticket *tick, size_t blen) { return (fuse_body_audit(tick, blen)); } int __fticket_wait_answer(struct fuse_ticket *tick) { return (fticket_wait_answer(tick)); } int __fuse_standard_handler(struct fuse_ticket *tick, struct uio *uio) { return (fuse_standard_handler(tick, uio)); } #endif /* FMASTER */ fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_io.h0000644000175000017500000000560511151613006017401 0ustar rmhrmh/* * Fuse filehandle, for in-kernel bookkeping of daemon's filehandles * (which are presented to us as an opque 64 bit id, see the fh_id * member of the struct). * It serves as private data for in-kernel file structures, but can * as well occur standalone. */ struct fuse_filehandle { struct vnode *fh_vp; uint64_t fh_id; int mode; struct ucred *cred; pid_t pid; int useco; LIST_ENTRY(fuse_filehandle) fh_link; struct file *fp; int flags; enum fuse_opcode op; }; #define FTOFH(fp) ((struct fuse_filehandle *)(fp)->f_data) #define ASSERT_VOP_ELOCKED__FH(vp) ASSERT_VOP_ELOCKED((vp), "unsafe filehandle access") #define ASSERT_VOP_LOCKED__FH(vp) ASSERT_VOP_LOCKED((vp), "unsafe filehandle access") /* prototype for processing an input data buffer and an uio for reading related acivities */ typedef int fuse_buffeater_t(struct uio *uio, size_t reqsize, void *buf, size_t bufsize, void *param); /* data used through an I/O operation */ struct fuse_io_data { struct vnode *vp; struct fuse_filehandle *fufh; struct uio *uio; struct ucred *cred; struct thread *td; enum fuse_opcode opcode; fuse_buffeater_t *buffeater; void *param; }; int fuse_io_dispatch(struct vnode *vp, struct fuse_filehandle *fufh, struct uio *uio, struct ucred *cred, int flag, struct thread *td); int fuse_io_file(struct file *fp, struct uio *uio, struct ucred *cred, int flags, struct thread *td); int fuse_io_vnode(struct vnode *vp, struct ucred *cred, struct uio *uio, int ioflag); int fuse_strategy_i(struct vnode *vp, struct buf *bp, struct fuse_filehandle *fufh, enum fuse_opcode op); /* * XXX for blocking vnode usage, it seems that changing vnops to dead ones * is not enough: file ops don't look at the vnode... * so as an ad hoc solution we'll test against this macro to the top of file * specific ops. * Tell me if there is an "official" way to handle this. */ static __inline int _file_is_bad(struct file *fp) { return (fp->f_ops == &badfileops || fp->f_ops == &vnops || fp->f_vnode->v_type == VBAD || fp->f_vnode->v_op == &dead_vnodeops || fp->f_vnode->v_data == NULL || fp->f_data == NULL || FTOFH(fp)->fh_vp->v_type == VBAD); } /* * In kern_open() of vfs_syscalls.c, if the f_data slot is not set * up at open time, the vnode of the file will be put there. * So "f_data == f_vnode" means someting like "the file is not * initialized". I don't know how stable this convention is, so relying * on it might be somewhat bogus; yet this saves us from on more locking * for nothing (when allocating a dummy data field). * As a compromise, the respective test is wrapped into a macro, to provide * some abstraction... */ static __inline int _file_is_fat(struct file *fp) { return (fp->f_vnode && fp->f_data != fp->f_vnode); } fuse4bsd-0.3.9~pre1.20080208/fuse_module/fuse_main.c0000644000175000017500000001100211151613006017675 0ustar rmhrmh/* * Module load/unload stuff. */ #include "config.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse.h" static void fuse_bringdown(eventhandler_tag eh_tag); static int fuse_loader(struct module *m, int what, void *arg); int fuse_useco = 0; #if USE_FUSE_LOCK struct mtx fuse_mtx; #endif #ifdef USE_OLD_CLONEHANDLER_API extern void fusedev_clone(void *arg, char *name, int namelen, struct cdev **dev); #else extern void fusedev_clone(void *arg, struct ucred *cred, char *name, int namelen, struct cdev **dev); #endif extern struct vfsops fuse_vfsops; extern struct cdevsw fuse_cdevsw; extern struct vop_vector fuse_vnops; extern struct fileops fuse_fileops; extern struct clonedevs *fuseclones; #if FMASTER extern struct cdevsw fmaster_cdevsw[5]; static struct cdev *fmaster_dev[5]; #endif extern int fuse_pbuf_freecnt; #if FUSE_HAS_CREATE extern struct vop_vector fuse_germ_vnops; extern vop_access_t fuse_germ_access; #endif static struct vfsconf fuse_vfsconf = { .vfc_version = VFS_VERSION, .vfc_name = "fusefs", .vfc_vfsops = &fuse_vfsops, .vfc_typenum = -1, .vfc_flags = VFCF_SYNTHETIC }; SYSCTL_INT(_vfs_fuse, OID_AUTO, kernelabi_major, CTLFLAG_RD, 0, FUSE_KERNEL_VERSION, "FUSE kernel abi major version"); SYSCTL_INT(_vfs_fuse, OID_AUTO, kernelabi_minor, CTLFLAG_RD, 0, FUSE_KERNEL_MINOR_VERSION, "FUSE kernel abi minor version"); /****************************** * * >>> Module management stuff * ******************************/ static void fuse_bringdown(eventhandler_tag eh_tag) { #if FMASTER int i; #endif EVENTHANDLER_DEREGISTER(dev_clone, eh_tag); clone_cleanup(&fuseclones); #if USE_FUSE_LOCK mtx_destroy(&fuse_mtx); #endif #if FMASTER for (i = 0; i < 5; i++) { DEBUG("destroying fmaster%d\n", i); destroy_dev(fmaster_dev[i]); } #endif } static int fuse_loader(struct module *m, int what, void *arg) { static eventhandler_tag eh_tag = NULL; int err = 0; #if FMASTER int i; char *fmaster_name = "fmasterx"; #endif GIANT_REQUIRED; switch (what) { case MOD_LOAD: /* kldload */ fuse_fileops.fo_ioctl = vnops.fo_ioctl; fuse_fileops.fo_poll = vnops.fo_poll; fuse_fileops.fo_kqfilter = vnops.fo_kqfilter; fuse_fileops.fo_stat = vnops.fo_stat; fuse_pbuf_freecnt = nswbuf / 2 + 1; #if FUSE_HAS_CREATE memcpy(&fuse_germ_vnops, &dead_vnodeops, sizeof(struct vop_vector)); fuse_germ_vnops.vop_access = fuse_germ_access; fuse_germ_vnops.vop_open = fuse_vnops.vop_open; #endif clone_setup(&fuseclones); #ifdef USE_FUSE_LOCK mtx_init(&fuse_mtx, "fuse_mtx", NULL, MTX_DEF); #endif eh_tag = EVENTHANDLER_REGISTER(dev_clone, fusedev_clone, 0, 1000); if (eh_tag == NULL) { clone_cleanup(&fuseclones); #if USE_FUSE_LOCK mtx_destroy(&fuse_mtx); #endif return (ENOMEM); } #if FMASTER for (i=0; i<5; i++) { fmaster_name[7] = i + '0'; fmaster_dev[i] = make_dev(&fmaster_cdevsw[i], 0, UID_ROOT, GID_WHEEL, S_IWUSR, fmaster_name); } #endif /* Duh, it's static... */ /* vfs_register(&fuse_vfsconf); */ /* vfs_modevent ignores its first arg */ if ((err = vfs_modevent(NULL, what, &fuse_vfsconf))) fuse_bringdown(eh_tag); else printf("fuse4bsd: version %s, FUSE ABI %d.%d\n" #ifdef KERNCONFDIR "fuse4bsd: compiled against kernel config " KERNCONFDIR "\n" #endif , FUSE4BSD_VERSION, FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION); break; case MOD_UNLOAD: KASSERT(fuse_useco >= 0, ("fuse_useco is negative: %d", fuse_useco)); if (fuse_useco > 0) { DEBUG2G("fuse_useco %d\n", fuse_useco); return (EBUSY); } if ((err = vfs_modevent(NULL, what, &fuse_vfsconf))) return (err); /* * at this point the counter falls below zero thus new init * attempts will know that no brownie for them */ fuse_useco--; fuse_bringdown(eh_tag); /* vfs_unregister(&fuse_vfsconf); */ break; default: return (EINVAL); } return (err); } /* Registering the module */ static moduledata_t fuse_moddata = { "fuse", fuse_loader, &fuse_vfsconf }; DECLARE_MODULE(fuse, fuse_moddata, SI_SUB_VFS, SI_ORDER_MIDDLE); MODULE_VERSION(fuse, 1); fuse4bsd-0.3.9~pre1.20080208/fuse_module/config.h0000644000175000017500000000006211151613006017205 0ustar rmhrmh#ifdef KERNCONFDIR #include #endif fuse4bsd-0.3.9~pre1.20080208/tools/0000755000175000017500000000000011573172317014437 5ustar rmhrmhfuse4bsd-0.3.9~pre1.20080208/tools/fuse-structs.yml0000644000175000017500000000714411151613006017622 0ustar rmhrmh--- :opcodes: FUSE_MKNOD: 8 FUSE_OPEN: 14 FUSE_SETLKW: 33 FUSE_LISTXATTR: 23 FUSE_RELEASE: 18 FUSE_READ: 15 FUSE_LINK: 13 FUSE_SETLK: 32 FUSE_FSYNC: 20 FUSE_SYMLINK: 6 FUSE_READLINK: 5 FUSE_RELEASEDIR: 29 FUSE_FORGET: 2 FUSE_GETLK: 31 FUSE_OPENDIR: 27 FUSE_WRITE: 16 FUSE_GETXATTR: 22 FUSE_LOOKUP: 1 FUSE_READDIR: 28 FUSE_INIT: 26 FUSE_REMOVEXATTR: 24 FUSE_SETXATTR: 21 FUSE_STATFS: 17 FUSE_RMDIR: 11 FUSE_GETATTR: 3 FUSE_FSYNCDIR: 30 FUSE_FLUSH: 25 FUSE_RENAME: 12 FUSE_UNLINK: 10 FUSE_MKDIR: 9 FUSE_SETATTR: 4 :typemap: FUSE_MKNOD: - fuse_mknod_in - char * FUSE_OPEN: fuse_open_in FUSE_SETLKW: fuse_lk_in_out FUSE_LISTXATTR: fuse_getxattr_in FUSE_READ: fuse_read_in FUSE_RELEASE: fuse_release_in FUSE_LINK: - fuse_link_in - char * FUSE_SETLK: fuse_lk_in_out FUSE_FSYNC: fuse_fsync_in FUSE_SYMLINK: char * FUSE_READLINK: FUSE_RELEASEDIR: fuse_release_in FUSE_FORGET: fuse_forget_in FUSE_GETLK: fuse_lk_in_out FUSE_OPENDIR: fuse_open_in FUSE_WRITE: - fuse_write_in - char * FUSE_GETXATTR: - fuse_getxattr_in - char * FUSE_LOOKUP: char * FUSE_READDIR: fuse_read_in FUSE_INIT: fuse_init_in_out FUSE_REMOVEXATTR: char * FUSE_SETXATTR: - fuse_setxattr_in - char * FUSE_STATFS: FUSE_RMDIR: char * FUSE_GETATTR: FUSE_FSYNCDIR: fuse_fsync_in FUSE_FLUSH: fuse_flush_in FUSE_RENAME: - fuse_rename_in - char * FUSE_UNLINK: char * FUSE_MKDIR: - fuse_mkdir_in - char * FUSE_SETATTR: fuse_setattr_in :structs_raw: fuse_getxattr_in: - "\t__u32\tsize;\n" - "\t__u32\tpadding;\n" fuse_flush_in: - "\t__u64\tfh;\n" - "\t__u32\tflush_flags;\n" - "\t__u32\tpadding;\n" fuse_rename_in: - "\t__u64\tnewdir;\n" fuse_write_in: - "\t__u64\tfh;\n" - "\t__u64\toffset;\n" - "\t__u32\tsize;\n" - "\t__u32\twrite_flags;\n" fuse_forget_in: - "\t__u64\tnlookup;\n" fuse_lk_in_out: - "\tstruct fuse_file_lock lk;\n" fuse_setattr_in: - "\t__u32\tvalid;\n" - "\t__u32\tpadding;\n" - "\tstruct fuse_attr attr;\n" fuse_fsync_in: - "\t__u64\tfh;\n" - "\t__u32\tfsync_flags;\n" - "\t__u32\tpadding;\n" fuse_link_in: - "\t__u64\toldnodeid;\n" fuse_file_lock: - "\t__u64\tstart;\n" - "\t__u64\tend;\n" - "\t__u64\towner;\n" - "\t__u32\tpid;\n" - "\t__u32\ttype;\n" fuse_open_in: - "\t__u32\tflags;\n" - "\t__u32\tpadding;\n" fuse_mknod_in: - "\t__u32\tmode;\n" - "\t__u32\trdev;\n" fuse_init_in_out: - "\t__u32\tmajor;\n" - "\t__u32\tminor;\n" fuse_mkdir_in: - "\t__u32\tmode;\n" - "\t__u32\tpadding;\n" fuse_attr: - "\t__u64\tino;\n" - "\t__u64\tsize;\n" - "\t__u64\tblocks;\n" - "\t__u64\tatime;\n" - "\t__u64\tmtime;\n" - "\t__u64\tctime;\n" - "\t__u32\tatimensec;\n" - "\t__u32\tmtimensec;\n" - "\t__u32\tctimensec;\n" - "\t__u32\tmode;\n" - "\t__u32\tnlink;\n" - "\t__u32\tuid;\n" - "\t__u32\tgid;\n" - "\t__u32\trdev;\n" fuse_in_header: - "\t__u32\tlen;\n" - "\t__u32\topcode;\n" - "\t__u64\tunique;\n" - "\t__u64\tnodeid;\n" - "\t__u32\tuid;\n" - "\t__u32\tgid;\n" - "\t__u32\tpid;\n" - "\t__u32\tpadding;\n" fuse_setxattr_in: - "\t__u32\tsize;\n" - "\t__u32\tflags;\n" fuse_read_in: - "\t__u64\tfh;\n" - "\t__u64\toffset;\n" - "\t__u32\tsize;\n" - "\t__u32\tpadding;\n" fuse_release_in: - "\t__u64\tfh;\n" - "\t__u32\tflags;\n" - "\t__u32\tpadding;\n" :zipcodes: false: L char *: a* :u32: L :s32: l :u64: q fuse4bsd-0.3.9~pre1.20080208/tools/fuse_vfsemu.rb0000644000175000017500000001534311151613006017304 0ustar rmhrmh#!/usr/bin/env ruby require 'yaml' require 'pp' require 'stringio' class Array # def almostflatten # now we use getprimmap indeed # a = [] # each { |x| # if (! x.is_a? Array) or (! x.find { |y| y.is_a? Array }) # a << x # next # end # a.concat x.almostflatten # } # a # end # def recrange # now we use getprimmap indeed # map { |x,y| # if y # y.is_a?(Array) ? y.recrange : y # else # x # end # }.flatten # end # extract "atomic" [a, b] pairs from ary def getprimmap a=[] each {|e| e.is_a? Array or (a << e; next) case e.size when 0,1 e.is_a?(Array) ? a.concat(e.getprimmap) : a << e when 2 e[0].is_a? Array and (a.concat(e.getprimmap); next) e[1].is_a?(Array) ? a.concat(e[1].getprimmap) : a << e else a.concat e.getprimmap end } a end def intersect oa ia = [] each { |x| oa.include? x and ia << x } ia end end class Object def deepcopy Marshal.load Marshal.dump(self) end alias _cl class end ####### class Fuse # To be run on header files def self.parse_raw raw, pat="" struct = nil h = {} raw.each { |l| if (block_given? ? yield(l) : (l =~ /^struct#{pat}/)) struct and raise "nested toplevel structs? bad, bad indentation" struct = l.split[1] h[struct] = [] next end l =~ /^\}/ and struct = nil struct or next (ll=l.dup).sub! /;.*/, ";" and h[struct] << ll # outrageous assumption: given line is prog code iff it contains a ";" } h end def initialize data, *args data.is_a? Hash and @data = data @data ||= if File.exist? data open(data) { |f| YAML.load f } else YAML.load data end ocs,ios = args.partition { |x| x.respond_to? :new } @opclass = case ocs.size when 0; FuseOp when 1; ocs[0] else raise ArgumentError, "ambiguous opclass" end io = case ios.size when 0; StringIO.new when 1; ios[0] else raise ArgumentError, "ambiguous io" end @file = case io when String @fname = io open(io,"w") when IO, StringIO; io end parse @data[:opcodes].each_key { |k| install k } @file end attr_accessor :file, :fname attr_reader :structs, :data def parse sdata1={} @data[:structs_raw].each{ |k,v| w=[] v.each{ |l| t,n = l.sub(/;.*/,"").split[-2..-1] w << [n.to_sym, (ty=t[2..-1].to_sym; @data[:zipcodes].key?(ty) ? ty : t)] } sdata1[k] = w } sdata2 = sdata1.deepcopy shitlist1,shitlist2 = [], [] sdata2.each{ |k,v| v.each{ |a| if (u=a[-1]).is_a?(String) shitlist1 << v shitlist2 << u a[-1]=sdata1[u] end } } @structs = { :types => sdata1 } (bada=(shitlist2.intersect shitlist1)).empty? or raise "You are SOL: a deep hierarchy of structs is used and that's not supported: #{bada.inspect} can't be resolved" @structs[:map] = sdata2 end def install opn me = self op = @opclass.new opn, self class << self self end.send(:define_method,opn) { op } end def write *arg @file.syswrite *arg end def teardown @file.close end def reset teardown rescue NoMethodError end def renew #unq=false @fname or raise "can't renew in lack of knowing the filename" begin teardown rescue IOError, SystemCallError end @file = open(@fname,"w") #unq and self::FuseOp.init_unq #self::FuseOp.unique end end class FuseOp # def self.init_unq # @unique = 1 # end # init_unq # # class << self # attr_accessor :unique # end def initialize name, be @name = name @backend = be end attr_reader :name def map @backend.data[:typemap][@name] end def get_type a = [@backend.structs[:map]["fuse_in_header"].deepcopy] a[0].each{ |b| if b[0] == :opcode b[1]=@backend.data[:opcodes][@name] break end } mapt = map.is_a?(Array) ? map : [map] mapt.each { |t| case t when /^fuse/ a << @backend.structs[:map][t] when nil else a << t end } a end def get_type_flat get_type.getprimmap.map { |x| if x.is_a? Array x[0] == :padding and next false # "next nil" would be more appropriate, but that's hosed by yaml bug next x[-1] end x } end def show out=$> PP::pp get_type, out end def pack *a aa=a.dup pa=[] ps = "" get_type_flat.each { |x| x ||= 0 #padding pa << case x when Symbol, String pc = @backend.data[:zipcodes][x] or raise ArgumentError, "unkown input type: #{x.inspect}" dat = aa.shift or raise ArgumentError, "not enough input data" (x.is_a? Symbol and dat.is_a? Integer) or (x.is_a? String and dat.is_a? String) or raise ArgumentError, "malformed input: #{dat.inspect} given as #{x.inspect}" dat else pc = @backend.data[:zipcodes][:u32] x end ps << pc } aa.empty? or raise ArgumentError, "too much input data" return pa, ps end def show_pack # I code around my own code, like it was damn braindead 3rdparty protocol get_type_flat.each_with_index { |x,i| begin return pack(*([0]*i)) rescue ArgumentError end } end def send_raw *a u,v = pack *a @backend.write u.pack(v) end def headgen nid, nvals={} vals = { :len => 0, # [:opcode, 15], # [:unique, :u64], # [:nodeid, :u64], :uid => 0, :gid => 0, :pid => 1 # [:padding, :u32]] } vals.merge! nvals slots = @backend.structs[:types]["fuse_in_header"].transpose[0] - [:opcode,:padding] ra = [] slots.each { |s| v = vals[s] case s when :unique #v ? _cl.unique = v : v = (_cl.unique += 1) v ||= 0 # as of now, kernel module ignores this value and fills the field # properly when :nodeid v = nid else v or raise "The known header format is too old: no value for #{s.inspect}" end ra << v } ra end def send nid, *a # unq = _cl.unique ha, na = a.partition { |x| x.is_a? Hash } send_raw *(headgen(nid,*ha) + na) # rescue # _cl.unique = unq # raise end def method_missing *a x = a[0] if y = @backend.data[x] a.size == 1 or raise ArgumentError, "wrong number of arguments" return y[@name] end raise NoMethodError, x.to_s end end class FuseAnswer < FuseOp def get_type case map when /^fuse/ @backend.structs[:map][map] when nil else map end end end fuse4bsd-0.3.9~pre1.20080208/tools/genopnames.awk0000644000175000017500000000211511151613006017261 0ustar rmhrmh#!/usr/bin/awk -f # rewritten from ruby version with the kind help of Soren Dossing BEGIN{ inside = -1; if (! (outf = ENVIRON["OUTF"])) { print "output file unspecified"; exit 1; } while (getline) { if (inside == -1) { if ($0 ~ /^[[:space:]]*enum[[:space:]]+fuse_opcode[[:space:]]*\{/) inside = 0; continue; } if ($0 ~ /^[[:space:]]*\}/) break; if (! ($0 ~ /^[[:space:]]*[A-Z_]+[[:space:]]*(,|=[[:space:]]*[[:digit:]]+)/)) continue; sub(/,.*/,""); sub(/=/,""); $2 ? (inside = $2) : (inside += 1); if (ops[inside]) { print "colliding values for fuse opcodes:", inside, "<-", ops[inside], "vs.", $1 > "/dev/stderr"; exit 1; } ops[inside] = $1; } inside += 5 print "/* Generated by an awk script from fuse_kernel.h, don't hand hack it! */" >> outf; print "" >> outf; print "char *fuse_opnames[] = {" >> outf; for (o=0; o <= inside; o++) { print ops[o] ? "\t\""ops[o]"\"," : "\t\"N/A (your fuse_opnames.c is out of date?...)\"," >> outf; }; print "};" >> outf;; print "" >> outf; print "int fuse_opnames_entries = "inside";" >> outf; } fuse4bsd-0.3.9~pre1.20080208/mount_fusefs/0000755000175000017500000000000011573172317016014 5ustar rmhrmhfuse4bsd-0.3.9~pre1.20080208/mount_fusefs/mount_fusefs.c0000644000175000017500000003045711151613006020671 0ustar rmhrmh/*- * Copyright (c) 2005 Jean-Sébastien Pédron * Copyright (c) 2005 Csaba Henk * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "fuse4bsd.h" #include "mntopts.h" void __usage_short(void); void usage(void); void helpmsg(void); void showversion(void); struct mntopt mopts[] = { #define ALTF_PRIVATE 0x01 { "private", 0, ALTF_PRIVATE, 1 }, { "neglect_shares", 0, 0x02, 1 }, { "push_symlinks_in", 0, 0x04, 1 }, { "allow_other", 0, 0x08, 1 }, { "default_permissions", 0, 0x10, 1 }, #define ALTF_MAXREAD 0x20 { "max_read=", 0, ALTF_MAXREAD, 1 }, #define ALTF_SUBTYPE 0x40 { "subtype=", 0, ALTF_SUBTYPE, 1 }, #define ALTF_SYNC_UNMOUNT 0x80 { "sync_unmount", 0, ALTF_SYNC_UNMOUNT, 1 }, /* Linux specific options, we silently ignore them */ { "fsname=", 0, 0x00, 1 }, { "fd=", 0, 0x00, 1 }, { "rootmode=", 0, 0x00, 1 }, { "user_id=", 0, 0x00, 1 }, { "group_id=", 0, 0x00, 1 }, { "large_read", 0, 0x00, 1 }, /* "nonempty", just the first two chars are stripped off during parsing */ { "nempty", 0, 0x00, 1 }, MOPT_STDOPTS, MOPT_END }; struct mntval { int mv_flag; void *mv_value; int mv_len; }; struct mntval mvals[] = { { ALTF_MAXREAD, NULL, 0 }, { ALTF_SUBTYPE, NULL, 0 }, { 0, NULL, 0 } }; char *progname; #define DEFAULT_MOUNT_FLAGS ALTF_PRIVATE | ALTF_SYNC_UNMOUNT int main(int argc, char *argv[]) { struct iovec *iov; char ch = '\0'; int mntflags, iovlen, verbose = 0; char *dev = NULL, *dir = NULL, mntpath[MAXPATHLEN]; char *devo = NULL, *diro = NULL; char ndev[128]; int i, done = 0, reject_allow_other = 0, safe_level = 0; int altflags = DEFAULT_MOUNT_FLAGS; int __altflags = DEFAULT_MOUNT_FLAGS; struct mntopt *mo; struct mntval *mv; static struct option longopts[] = { {"reject-allow_other", no_argument, NULL, 'A'}, {"safe", no_argument, NULL, 'S'}, {"daemon", required_argument, NULL, 'D'}, {"daemon_opts", required_argument, NULL, 'O'}, {"special", required_argument, NULL, 's'}, {"mountpath", required_argument, NULL, 'm'}, {"version", no_argument, NULL, 'V'}, {"help", no_argument, NULL, 'h'}, {0,0,0,0} }; int pid = 0; int fd = -1, fdx; char *ep; char *daemon = NULL, *daemon_opts = NULL; progname = argv[0]; /* * We want a parsing routine which is not sensitive to * the position of args/opts; it should extract the * first two args and stop at the beginning of the rest. * (This makes it easier to call mount_fusefs from external * utils than it is with a strict "util flags args" syntax.) */ iov = NULL; iovlen = 0; mntflags = 0; /* All in all, I feel it more robust this way... */ unsetenv("POSIXLY_CORRECT"); if (getenv("MOUNT_FUSEFS_IGNORE_UNKNOWN")) getmnt_silent = 1; if (getenv("MOUNT_FUSEFS_VERBOSE")) verbose = 1; do { char *inner_opt; int optlen; for (i = 0; i < 3; i++) { if (optind < argc && argv[optind][0] != '-') { if (dir) { done = 1; break; } if (dev) dir = argv[optind]; else dev = argv[optind]; optind++; } } switch(ch) { case 'A': reject_allow_other = 1; break; case 'S': safe_level = 1; break; case 'D': if (daemon) errx(1, "daemon specified inconsistently"); daemon = optarg; break; case 'O': if (daemon_opts) errx(1, "daemon opts specified inconsistently"); daemon_opts = optarg; break; case 'o': getmntopts(optarg, mopts, &mntflags, &altflags); for (mv = mvals; mv->mv_flag; ++mv) { if (! (altflags & mv->mv_flag)) continue; for (mo = mopts; mo->m_flag; ++mo) { char *p, *q; if (mo->m_flag != mv->mv_flag) continue; p = strstr(optarg, mo->m_option); if (p) { p += strlen(mo->m_option); q = p; while (*q != '\0' && *q != ',') q++; mv->mv_len = q - p + 1; mv->mv_value = malloc(mv->mv_len); memcpy(mv->mv_value, p, mv->mv_len - 1); ((char *)mv->mv_value)[mv->mv_len - 1] = '\0'; break; } } } break; case 's': if (devo) errx(1, "special specified inconsistently"); devo = optarg; break; case 'm': if (diro) errx(1, "mount path specified inconsistently"); diro = optarg; break; case 'v': verbose = 1; break; case 'h': helpmsg(); break; case 'V': showversion(); break; case '\0': break; case '?': default: usage(); } if (done) break; } while ((ch = getopt_long(argc, argv, "AvVho:SD:O:s:m:", longopts, NULL)) != -1); argc -= optind; argv += optind; if (devo) { if (dev) errx(1, "special specified inconsistently"); dev = devo; } else if (diro) errx(1, "if mountpoint is given via an option, special should also be given via an option"); if (diro) { if (dir) errx(1, "mount path specified inconsistently"); dir = diro; } if ((! dev) && argc > 0) { dev = *argv++; argc--; } if ((! dir) && argc > 0) { dir = *argv++; argc--; } if (! (dev && dir)) errx(1, "missing special and/or mountpoint"); for (mo = mopts; mo->m_flag; ++mo) { if (altflags & mo->m_flag) { char *val; int iov_done = 0; if (reject_allow_other && strcmp(mo->m_option, "allow_other") == 0) /* * reject_allow_other is stronger than a * negative of allow_other: if this is set, * allow_other is blocked, period. */ errx(1, "\"allow_other\" usage is banned by respective option"); for (mv = mvals; mv->mv_flag; ++mv) { if (mo->m_flag != mv->mv_flag) continue; if (mv->mv_value) { build_iovec(&iov, &iovlen, mo->m_option, mv->mv_value, mv->mv_len); iov_done = 1; break; } } if (! iov_done) build_iovec(&iov, &iovlen, mo->m_option, "", -1); } if (__altflags & mo->m_flag) { char *uscore_opt; if (asprintf(&uscore_opt, "__%s", mo->m_option) == -1) err(1, "failed to allocate memory"); build_iovec(&iov, &iovlen, uscore_opt, "", -1); free(uscore_opt); } } if (getenv("MOUNT_FUSEFS_SAFE")) safe_level = 1; if (safe_level > 0 && (argc > 0 || daemon || daemon_opts)) errx(1, "safe mode, spawning daemon not allowed"); if ((argc > 0 && (daemon || daemon_opts)) || (daemon_opts && ! daemon)) errx(1, "daemon specified inconsistently"); /* * Resolve the mountpoint with realpath(3) and remove unnecessary * slashes from the devicename if there are any. */ (void)checkpath(dir, mntpath); (void)rmslashes(dev, dev); if (strcmp(dev, "auto") == 0) dev = "/dev/fuse"; if (strcmp(dev, "/dev/fuse") == 0) { if (! (argc > 0 || daemon)) { fprintf(stderr, "Please also specify the fuse daemon to run when mounting via the multiplexer!\n"); usage(); } if ((fd = open(dev, O_RDWR)) < 0) err(1, "failed to open fuse device"); } else { fdx = strtol(dev, &ep, 10); if (*ep == '\0') fd = fdx; } /* Identifying device */ if (fd >= 0) { struct stat sbuf; char *ndevbas, *ep; if (fstat(fd, &sbuf) == -1) err(1, "cannot stat device file descriptor"); strcpy(ndev, _PATH_DEV); ndevbas = ndev + strlen(_PATH_DEV); devname_r(sbuf.st_rdev, S_IFCHR, ndevbas, sizeof(ndev) - strlen(_PATH_DEV)); if (strncmp(ndevbas, "fuse", 4)) errx(1, "mounting inappropriate device"); strtol(ndevbas + 4, &ep, 10); if (*ep != '\0') errx(1, "mounting inappropriate device"); dev = ndev; } if (argc > 0 || daemon) { char *fds; if (fd < 0 && (fd = open(dev, O_RDWR)) < 0) err(1, "failed to open fuse device"); if (asprintf(&fds, "%d", fd) == -1) err(1, "failed to allocate memory"); setenv("FUSE_DEV_FD", fds, 1); free(fds); setenv("FUSE_NO_MOUNT", "1", 1); if (daemon) { char *bgdaemon; int len; if (! daemon_opts) daemon_opts = ""; len = strlen(daemon) + 1 + strlen(daemon_opts) + 2 + 1; bgdaemon = calloc(1, len); if (! bgdaemon) err(1, "failed to allocate memory"); strlcpy(bgdaemon, daemon, len); strlcat(bgdaemon, " ", len); strlcat(bgdaemon, daemon_opts, len); strlcat(bgdaemon, " &", len); if (system(bgdaemon)) err(1, "failed to call fuse daemon"); } else { if ((pid = fork()) < 0) err(1, "failed to fork for fuse daemon"); if (pid == 0) { execvp(argv[0], argv); err(1, "failed to exec fuse daemon"); } } } if (fd >= 0 && ! init_backgrounded() && close(fd) < 0) { if (pid) kill(pid, SIGKILL); err(1, "failed to close fuse device"); } /* Prepare the options vector for nmount(). build_iovec() is declared * in mntopts.h. */ build_iovec(&iov, &iovlen, "fstype", "fusefs", -1); build_iovec(&iov, &iovlen, "fspath", mntpath, -1); build_iovec(&iov, &iovlen, "from", dev, -1); if (verbose) fprintf(stderr, "mounting fuse daemon on device %s\n", dev); if (nmount(iov, iovlen, mntflags) < 0) err(EX_OSERR, "%s on %s", dev, mntpath); exit(0); } void __usage_short(void) { fprintf(stderr, "usage:\n%s [-A|-S|-v|-V|-h|-D daemon|-O args|-s special|-m node|-o option...] special node [daemon args...]\n\n", basename(progname)); } void usage(void) { struct mntopt *mo; __usage_short(); fprintf(stderr, "known options:\n"); for (mo = mopts; mo->m_flag; ++mo) fprintf(stderr, "\t%s\n", mo->m_option); fprintf(stderr, "\n(use -h for a detailed description of these options)\n"); exit(EX_USAGE); } void helpmsg(void) { if (! getenv("MOUNT_FUSEFS_CALL_BY_LIB")) { __usage_short(); fprintf(stderr, "description of options:\n"); } /* * The main use case of this function is giving info embedded in general * FUSE lib help output. Therefore the style and the content of the output * tries to fit there as much as possible. */ fprintf(stderr, " -o allow_other allow access to other users\n" /* " -o nonempty allow mounts over non-empty file/dir\n" */ " -o default_permissions enable permission checking by kernel\n" /* " -o fsname=NAME set filesystem name\n" " -o large_read issue large read requests (2.4 only)\n" */ " -o subtype=NAME set filesystem type\n" " -o max_read=N set maximum size of read requests\n" " -o noprivate allow secondary mounting of the filesystem\n" " -o neglect_shares don't report EBUSY when unmount attempted\n" " in presence of secondary mounts\n" " -o push_symlinks_in prefix absolute symlinks with mountpoint\n" " -o sync_unmount do unmount synchronously\n" ); exit(EX_USAGE); } void showversion(void) { puts("mount_fusefs [fuse4bsd] version: " FUSE4BSD_VERSION); exit(EX_USAGE); } int init_backgrounded(void) { int ibg; size_t len; len = sizeof(ibg); if (sysctlbyname("vfs.fuse.init_backgrounded", &ibg, &len, NULL, 0)) return (0); return (ibg); } fuse4bsd-0.3.9~pre1.20080208/mount_fusefs/Makefile0000644000175000017500000000047611151613006017446 0ustar rmhrmh# $FreeBSD$ .include "../Makefile.common" PROG = mount_fusefs SRCS = mount_fusefs.c getmntopts.c MAN8 = mount_fusefs.8 NO_MANCOMPRESS?= yes # mount_fusefs needs mntopts.h and getmntopts.c from src/sbin/mount/ MOUNT ?= /usr/src/sbin/mount CFLAGS += -I${MOUNT} -I../include .PATH: ${MOUNT} .include fuse4bsd-0.3.9~pre1.20080208/mount_fusefs/mount_fusefs.80000644000175000017500000002631511151613006020614 0ustar rmhrmh.\" Copyright (c) 1980, 1989, 1991, 1993 .\" The Regents of the University of California. .\" Copyright (c) 2005, 2006 Csaba Henk .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" 4. Neither the name of the University nor the names of its contributors .\" may be used to endorse or promote products derived from this software .\" without specific prior written permission. .\" .\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" .Dd January 13, 2006 .Dt MOUNT_FUSEFS 8 .Os .Sh NAME .Nm mount_fusefs .Nd mount a Fuse file system daemon .Sh SYNOPSIS .Nm .Op Fl A .Op Fl S .Op Fl v .Op Fl D Ar fuse_daemon .Op Fl O Ar daemon_opts .Op Fl s Ar special .Op Fl m Ar node .Op Fl h .Op Fl V .Op Fl o Ar option ... .Ar special node .Op Ar fuse_daemon ... .Sh DESCRIPTION The most basic way of usage is as follows: before calling .Nm , one starts a fuse daemon on the given .Ar special (in practice, the daemon gets one automatically, which can then be indentified via .Xr fstat 1 ) , and that special file can then be mounted by .Nm . .Pp However, the procedure of spawning a daemon can be automated so that it's also performed by .Nm . If the command invoking a given .Ar fuse_daemon is appended to the list of arguments, .Nm will call then .Ar fuse_daemon via that command, in a way that .Ar fuse_daemon will be instructed to attach itself to .Ar special . From that on mounting goes as in the simple case. (See also .Sx DAEMON MOUNTS . ) .Pp The .Ar special argument can be utilized by .Nm in the following ways: .Bl -bullet -offset indent .It Basicly, it will be treated as the path of the special file to mount. .It However, if .Pa auto is passed as .Ar special , then .Nm will look for a suitable free fuse device by itself. .It Moreover, if .Ar special is an integer, then it will be interpreted as the number of the file descriptor of an already open fuse device (used when the Fuse library invokes .Nm , cf. .Sx DAEMON MOUNTS ) . .El .Pp The options are as follows: .Bl -tag -width indent .It Fl A , Ic --reject-allow_other Prohibit the .Cm allow_other mount flag. Intended for to be used in scripts and the .Xr sudoers 5 file. .It Fl S , Ic --safe Run in safe mode, that is, reject invoking a filesystem daemon. .It Fl v Be verbose. .It Fl D, Ic --daemon Ar daemon Call the specified .Ar daemon . .It Fl O, Ic --daemon_opts Ar opts Add .Ar opts to the daemon's command line. .It Fl s, Ic --special Ar special Use .Ar special as special. .It Fl m, Ic --mountpath Ar node Mount on .Ar node . .It Fl h, Ic --help Show help. .It Fl V, Ic --version Show version information. .It Fl o Mount options are specified via .Fl o . The following options are available (and also their negated versions, by prefixing them with .Dq no ) : .Bl -tag -width indent .It Cm default_permissions Enable traditional (file mode based) permission checking in kernel. .It Cm allow_other Do not apply .Sx STRICT ACCESS POLICY . Only root can use this option. .It Cm max_read Ns = Ns Ar n Limit size of read requests with .Ar n . .It Cm private Refuse shared mounting of the daemon. This is the default behaviour, to allow sharing, use expicitly .Fl o Cm noprivate . .It Cm neglect_shares Don't refuse unmounting if there are secondary mounts. .It Cm push_symlinks_in Prefix absolute symlinks with mountpoint. .El .Pp .El .Pp Besides the above mount options, there is a set of pseudo-mount options which are supported by the Fuse library. One can list these by passing .Fl h to a Fuse daemon. Most of these options have effect only on the behaviour of the daemon (that is, their scope is limited to userspace). However, there are some which do require in-kernel support. Currently the following ones are supported by the kernel: .Bl -tag -width indent .It Cm direct_io Bypass the buffer cache system. .It Cm kernel_cache By default, cached buffers of a given file are flushed at each .Xr open 2 . This option disables this behaviour. .El .Sh DAEMON MOUNTS Usually users don't need to use .Nm directly, as the Fuse library enables Fuse daemons to invoke .Nm by themselves. That is, .Pp .Dl fuse_daemon mountpoint .Pp has the same effect as .Pp .Dl mount_fusefs auto mountpoint fuse_daemon .Pp This is the recommended way of usage, unless you want to go beyond basic usage (eg, run daemon on a low privilege level, but mount it as root). .Sh STRICT ACCESS POLICY The strict access policy for Fuse filesystems lets one to use the filesystem only if the filesystem daemon has the same credentials (uid, real uid, gid, real gid) as the user. .Pp This is applied for Fuse mounts by default, and only root can mount without the strict access policy (cf. the .Cm allow_other mount option). .Pp The reason is to shield users from the daemon .Dq spying on their I/O activities. .Pp Users might opt for willingly relax strict access policy (as far they are concerned) by doing their own secondary mount (cf. .Sx SHARED MOUNTS ) . .Sh SHARED MOUNTS A Fuse daemon can be shared, ie. mounted multiple times. When doing the first (primary) mount, the spawner and the mounter of the daemon must have the same uid, or the mounter should be the superuser. .Pp After the primary mount is in place, secondary mounts can be done by anyone (unless this feature is disabled by .Cm private ) . The behaviour of a secondary mount is analogous to that of symbolic links: they redirect all filesystem operations to the primary mount. .Pp Doing a secondary mount is like signing an agreement: by this action, the mounter agrees that the Fuse daemon can trace her I/O activities. From that on, she is not banned from using the filesystem (either via her own mount or via the primary mount), regardless whether .Cm allow_other is used or not. .Pp The device name of a secondary mount is the device name of the corresponding primary mount, followed by a '#' character and the index of the secondary mount, like .Pa /dev/fuse0#3 . .Sh SECURITY System administratos might want to use a custom mount policy (ie., one going beyond the .Va vfs.usermount sysctl). The primary tool for such purposes is .Xr sudo 8 . However, given that .Nm is capable of invoking an arbitrary program, one must be careful about this. .Nm is designed in a way such that it makes that easy. For this purpose, there are options which disable certain risky features (cf. .Fl S and .Fl A ) , and command line parsing is done in a flexible way: mixing options and non-options allowed, but processing them stops at the third non-option argument (after the first two has been utilized as device and mountpoint). The rest of the command line specifies the daemon and its arguments. (Alternatively, the daemon, the special and the mount path can be specified using the respective options.) Note that .Nm ignores the environment variable .Ev POSIXLY_CORRECT and always behaves as described. .Pp In general, to be as scripting / .Xr sudoers 5 friendly as possible, no information has a fixed position in the command line, but once a given piece of information is provided, subsequent arguments/options cannot override it (maybe with the exception of some non-critical ones). .Sh ENVIRONMENT .Bl -tag -width ".Ev MOUNT_FUSEFS_SAFE" .It Ev MOUNT_FUSEFS_SAFE Setting this has the same effect as the .Fl S option. .It Ev MOUNT_FUSEFS_VERBOSE Setting this has the same effect as the .Fl v option. .It Ev MOUNT_FUSEFS_IGNORE_UNKNOWN If this is set, .Nm will ignore uknown mount options. .It Ev MOUNT_FUSEFS_CALL_BY_LIB Adjust behaviour to the needs of the FUSE library. Currently it has effect on help output. .El .Pp Although the following variables don't have effect on .Nm itself, they affect the behaviour of fuse daemons: .Bl -tag -width ".Ev FUSE_DEV_NAME" .It Ev FUSE_DEV_NAME Device to get attached to. If not set, the multiplexer path .Ar /dev/fuse is used. .It Ev FUSE_DEV_FD File desciptor of an opened Fuse device to use. Overrides .Ev FUSE_DEV_NAME . .It Ev FUSE_NO_MOUNT If this is set, the library won't attempt to mount the filesystem, even if a mountpoint argument is supplied. .El .Sh FILES .Bl -tag -width /dev/fuseN .It Pa /dev/fuseN Fuse devices by which the kernel and Fuse daemons can communicate. .It Pa /dev/fuse The multiplexer path. An .Xr open 2 performed on it automatically gets passed to a free Fuse device by the kernel (which might be just created for this puprose). .El .Sh EXAMPLES Mounting the example filesystem of the Fuse distribution (from its directory): either .Pp .Dl ./fusexmp /mnt/fuse .Pp or .Pp .Dl mount_fusefs auto /mnt/fuse ./fusexmp .Pp Doing the same in two steps, using .Pa /dev/fuse0 : .Pp .Dl FUSE_DEV_NAME=/dev/fuse0 ./fusexmp && .Dl mount_fusefs /dev/fuse0 /mnt/fuse .Pp A script wrapper for fusexmp which ensures that .Nm doesn't call any external utility and also provides a hacky (non race-free) automatic device selection: .Pp .Dl #!/bin/sh -e .Pp .Dl n=`ls /dev/fuse* | awk 'END{ print FNR }'` .Dl FUSE_DEV_NAME=/dev/fuse$n fusexmp .Dl mount_fusefs -S /dev/fuse$n /mnt/fuse \(lq$@\(rq .Pp A better (race-free) script wrapper: .Pp .Dl #!/bin/sh -e .Pp .Dl exec 3<>/dev/fuse .Dl FUSE_DEV_FD=3 fusexmp .Dl mount_fusefs -S 3 /mnt/fuse \(lq$@\(rq .Sh SEE ALSO .Xr fstat 1 , .Xr mount 8 , .Xr umount 8 , .Xr sudo 8 .Sh CAVEATS Secondary mounts are to be unmounted via their device name. If they attempted to be unmounted via their filesystem root path, the unmount request will be forwarded to the primary mount path. In general, unmounting by device name is less error-prone than by mount path (although the latter will also work under normal circumstances). .Pp If the daemon is specified via the .Fl D and .Fl O options, it will be invoked via .Xr system 3 , and the daemon's command line will be also appended a .Dq & sygill, so that we don't have to wait for its termination. That is, you'd better use a simple command line when invoking the daemon via these options. .Sh HISTORY .Nm appears as the part of the FreeBSD implementation of the Fuse userspace filesystem framework (see http://fuse.sourceforge.net). This user interface is FreeBSD specific. .Sh BUGS .Ar special is treated as a multiplexer if and only if it's literally the same as .Pa auto or .Pa /dev/fuse . Other paths which are equivalent with .Pa /dev/fuse (eg., .Pa /../dev/fuse ) are not. fuse4bsd-0.3.9~pre1.20080208/README0000644000175000017500000000055711151613006014151 0ustar rmhrmhMost users will want to use the related ports: - sysutils/fusefs-kmod - sysutils/fusefs-libs - sysutils/fusefs-sshfs and get started using the information spat out at installation time, the mount_fusefs(8) man page and the commandline help of the installed programs. If you want to go beyond this, see the doc directory (and first of all, the doc/README file). fuse4bsd-0.3.9~pre1.20080208/include/0000755000175000017500000000000011573172317014722 5ustar rmhrmhfuse4bsd-0.3.9~pre1.20080208/include/fuse4bsd.h0000644000175000017500000000010611151613006016572 0ustar rmhrmh#ifndef FUSE4BSD_VERSION #define FUSE4BSD_VERSION "0.3.9-pre1" #endif fuse4bsd-0.3.9~pre1.20080208/doc/0000755000175000017500000000000011573172317014044 5ustar rmhrmhfuse4bsd-0.3.9~pre1.20080208/doc/CREDITS0000644000175000017500000000030411151613006015044 0ustar rmhrmh - The original version of the css files and the Makefile were make by Thomas Link and various Deplate contributors - Some images are taken from the QBullet set (http://www.matterform.com/). fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/0000755000175000017500000000000011573172303015660 5ustar rmhrmhfuse4bsd-0.3.9~pre1.20080208/doc/html_aux/home-grey.png0000644000175000017500000000123311151613006020251 0ustar rmhrmh‰PNG  IHDRJ~ősbKGD˙‡Ěż pHYs  šœtIMEÔ '!҆,IDATxÚĽ”żkAĹ?3w$ŢfwϐČýJŽK›ʙĆÂ6(Řhe%ţ16‚Šsýő‚ĹĺÁ`Ą’€˜ěFhqٙOdżˇˇ— ŠSLńfßď|ß{˙¸Ô9DŸCâ?EFNaGäwOűޤRTDö¨Ó"ę×ÉŚ×]f˜ÓźÚ´ç  űUăĹ.›|ĞŹ ™WOň ĺrĹ[RE‚BhČśŮÝ=|#OiC&i,ύŃ{ľůĺÜ]ľ@M‘Ę\UłĂą/Ůď;ěÓí|nꇕkËšŰL3Œĺ 4“x\bšÝvňrŔgş@s…Gţ­ëţU@chňœ„Œ3Ɇś†Â‰nŽw|í=ÚŐłˇ¤Ę("šŹŇÄpŔ"e–TŰ3ĹŘLIťp°ŹłJ“!˘ (q(ŕ&’f‚h„€5Ö{óK(#”¨ Óqfú)Ŕ"T€‹` °'ÎSç ‰ţ%VXĄ„Nąţ~Ş%I´W¸Ěî˙É閈-!U@ců“AĄŃŔ!6qm`㠜kä+ĘĄBČk`ĐTqŘŁ!Ą‰lP7Ţöâ–_ă1Çč$8ŒŇbۘuâž5~p ßşóń‹zŒË˜dŠ)Śđéđ–úĎ÷;ÇĎxIÔoIˆŘěl´Ô§Ô­=8uë›DČÉĽy(xnšKhL+^äa K›0ś‡Ć”P}ŸIÜeúŻ~_¸ ŮÔ}%’IENDŽB`‚fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/deplate-mini.png0000644000175000017500000001377211151613006020740 0ustar rmhrmh‰PNG  IHDRXcČ ŕbKGD˙˙˙ ˝§“ pHYs  šœtIMEÔ ;g”.tEXtCommentCreated with The GIMPďd%n^IDATx^՚Y°\Çyß˝œ3űÝ\,÷â nIp•(Ҳl™˛ěX´,‰e%]Iär•-ĹIIŠ8ńC\Š8ŠJ\eťĘ);‰-—˘2c™‘ɐb,R$EQ˘H\‚@lpq÷ýÎĚYútwúĚ\0ńC^ňó4sfúëoůK_‹Wž˙'>ŠšTëc˜lç RĹ(]AI‘' Ŕ;‹÷!:n੠!5ÎŹÍŃşF\ÁäẎ5 Ćtą6Gˆâ&‰-ç,B ˛tƒjmksźwHĄĐşŠu9qeç ŕńށ÷ $ŕ1Y­ŤĽą&EE5„(U%O×R!U„-R”Žâ˝ď@¤Ôŕ˝Ă;‹ÉťŚK7ĐqŔÚ )4RGxçJůsźđĕ!˛d%čH*¤Œ°ś‹˝‰ÉŸFިŻ@|)ˆ dȃAď›÷ŽOT>°Kš`ëw!Č°Ö;<žÜ'ŹR!JĽyďB…Ďř°§÷%mö…’Wú4!Dšžr(Ů”HĄ˙”rôřěÉbkßž,[ďń!UŠ# <8oŔŹM™šüçJК%qGĘk„=ľÉ-„DŠŢť-ĺ¤ČRq „,•!‡˛4™čď)GˆđŽŻQÚË` ďqޓ& ÝnÂĆf›……††9tčú°¤ä˝Ż8!Ę˝{ ńl=}ázßJÂă˝ďqYţ(éFÇ!ź)K2)"´|ŘTU*…RĹ=Ă÷öZqŻá¤$X"§ÇĽ@ŕ…çKĘżžDsOń %â„,z â żĆGžÎăO<ĹÚę:ó œ?řžČĄC×o¨ô˜’hšĎ5 (7tô<Ť†rÇ>ˆ(eÚR.€F¨ZWŃRW†(ÝđÎá˝eë)˛‡žšú+ŔťđéZ´x|iŹRœž+÷ŢôQĺpÎ#KDŸ}Ţ{¤č9Ź( ´h6ę<ú衘››'Š"öďŸęďĺqDWĘ%JĽ űĐ{z(=­Îđ}T÷ôďKďö}^ œ-đŢRŘ wxkńÂâń!™š˘´‚/ˇ˙[źń8gˍĘ‹F’˛ÔŁë[RőĎ‚ł%-oBŕ|ö# œ+đ˝&8‹Šƒ§xä‹óÚkG™››g||;ăăc8—Óó&ďRJlQzeő×:ŁďŠŃ#|ŕ+˜¤Ňl%ĆřžÚ›JWđŽ 0i WĆď3§Ď¤ƒM&'éśgűJuŢâŠŐpIAĎ3@ôgň.:ŞŃŤ4”Şđ—ßzšo=ö<Ë+<ýäPU˜ž!zá OYĂ Ňd•8nbźĹä›xoŃÖ&$íŤ(ŁTĽ<‘UńxLąˇEpó˛D1y—Îâ4fuŁŻ`5^ĂdŤŘ"'Ďd'Ţ÷CBÖÝ IPĘ~ vÖWÉ3Kž­Ąu•?˙ơyüÉW¨Vcî8<@ŤÚEéŠ"˛Ä‚ˇx ruzĺá›o ZŐě›ha‹.iŢŔ(R”Š1ů‰ˇ!6*]ÁšS¤Dş†ł]źłHŠą:âŮç^ářŰçŘ75N$Ű$ípAŐđ2ƘÎNˆY˛†Ň1`˘‹ómň…ɉâ!y˛˛B!˝Ćt7ŃQĄ…ĎHçqŠ ˙‰4j{îć,Ţ;˘¸Fa2źuH"L2MaRtTCh‰ˆ#˘J)#LžIž­‚•ÄqüÄYŽÎ,sďÝÁ%,-/RXB˜ń­V ŠYY#[gyóř{ Ulvévfą&AB’v—B˛Ň5şÝ„,ˇäYBŻÎÇŘh fuľÍÚz‡ Ż0ąg˜KOŃjĹÔë ˘¨N’oལp‚vťK–ć8_Đl4lálBČ%g3´5 :xgČŇ ˘JđřÂaçť,>őë/ŸĂśSj×í`ۧoŁsaśŢx{‹‚.6KŃQĂú/Đ95ƒíd¨f…ĆÍť}đ0­ŰöUäŚM–ŽĄU•™ŤË,,ŽŁayôąW9öć%ŚŻŽăœgĎî!~ůswň“ Ńaem#cf&„ŞŻßŽ4Î&X›!6ĂYC'ńź{ę Żž~ĹĽ6i’qę˝y–WڌŽ4ůëżř2 ‹óüţ=ËĺŤ+L_]AJÁÂÂ*żűžŕá_<Ě˝w߈ÁáŹav~W^ťČ{gç9{a‘ó¸űÎüŁ/>Ŕ ‡ĆéU0Îh_"ľ°iřQŒ5)é{‹,}ó8Ó3”áŠîŠŽÎ­˘‡ë}ëm ŒoŁŠŕĘÝKsŹ>ušľçŢçű˙łë)/_ {fžżöďž[„ĆJ!2NŸ™fqi%++ ś`ďž&ë ‹Î_\â˙ô%ƆďçŽ#SŠy˙Ň&… YüŚw*˘44lň.ŕYZ…o?ńO?{ŠmçKżňQ&v6ř˙úi7Ů?5B­ŽŘ;9Ęďýîgřćű!˙ńżźBŁóĺ_˝—álCŠ˜$YFŤ*Wf6ř“ŻżJť“ňŐŻ<ˆ÷šŻ|íżň˝N"püűópY™„šXkc˛ ’8ŽcM×5Ź<ö6S3Ľă |x?^y6^ş@zayKÁ# źąřÔąřčtŽÍ€óÄťiŢťU­˛ţƒsäÓëËÖţć ­CSĐĚÍwxáG—xćšÓŹo¤ ´*|öĄ[¸çČ0•ę(O?ó.đÇ/°ş–đŢšn˝y„¸2Ŕ;§.âœG+ÉÁcdÉ yŢĄRi!„`mĂň§ßx•g_8ĂĄƒcüú—~‚űFx˙âű\şźĺŢťଡ0]˛Ź`úęšąLľŽSŠ´čv–ŠV‡XY/řłoăŘůÚoţ4;ˇKjŐPüřľslŽ_ĄÖíç,Y˜ĽctTĹ{Kľ6JňúíwBPÍ cfŰĂGyč&Fź…kŸxűşVC*Íć.Ň96ƒ/,zŹÁŕ/dŰg0řŠ}4v˛ż&9żHűŇ4ĆäźüÚeNœœ#Š$Îy†ŤÜ|hcŰv28Xçc=Đ_ç˝'Ďs”ŽĽmÎ]XĆ9ĎömMZu‹ł9QŮŽ”Ró×OžĂ3ϟFřüC‡ŮłłBaΜß`łŃlÄÜtĂNl‘b‹”ÍÍ63ó›lŤ18Ó;LĺŚŕÉ˙ů6/źxšýSc9źĽłłkt“Źä¤T(]GŠPJĘJmĽŤý~g{î k?:‹ĎĂ)ŽqË8ĂÜHÜ 6¸ĘÁžŔ˘˘P#1QľJ+l<_„uŃžľëÇ ÷¸ÄњœčŻ+6RŠNB˝1Â/üÜí|őË÷amX72Ň`d(ԗśČ¨V‹ţş8VlßžjmˆvW2żS“CT*ç,JW(LĆŠłë<öÄqňÜräÖ=|ěţëŃZ“‚×ߚĽÝɘœfŰhcR6ŰÓ3{vŇjĐEqƒš…„Ç“ÜÜ~x#ò4ĺťß;ÎňJ!ŕĂwOĹ ňd…,YÁYƒö>n!#Š"%›['˝˛ŢŞyçnP“ˇ)LB>ťÖ˙MÖ4Ńh“u(ÎľÉ6űż%G¸|ôořŰĄ$Jk˛d…8‚(Šy˙RHV÷PŤ5ú˙mwśÖ T9°o€Â¤ŹŹY––ŰLMŇl4¨7F)Š„n ţŐQÖ7RâHńéO݌Öá˜<}uƒˇŢŢy`ß-UÖěŠőő”ššMâHłß(Ţe…CJÍ÷_:ÉâŇ&qŹ8rŰ^Ö8úć ?ő.ŕ9rënůÂ]ý“Š-r¤ŠĐśČBŃoş$ÝěF‚]OűBŐ&ˇ#e…¤ł€ˇŽäěÖ NT5žŽ›ů ś›óó襪UďQşĘŮsIʲď†ë†Č˛M˘¸‰ľ9gÎ.ö׺nŒŠ‰ŹÍ™_ÜdyšM+öNnŁŮ&Ş €€“ďœçőˇŽ°oßA7pśŕŐ×Osyz•8RLěŽQ­LÖĆ{ÇĹËŤäĆŇlT˜ŘÝ@Š¸ĽÔźővČGÎyŽž~‘§ŸŮŕäťóŒ5řřOäłÝĂމ&&k#¤!(Š-D8DX—”çvѲ…*Ă$¨ÍˆäâV‚“ľZ‚(näěVďv䑛‘Rép€qž@…łٌ‘c1RŤÉ*§KŁ Œ†ĎR‚‹xőŘ%jUͧ?u#Őj„1†Ë—č&†ąŃ;ǐJa‹„<ëđڛ3ŹŽ%<0ĆđP [dL_]âŰOĂ9O­ąjü+]áě…7ˆcÉäî€p:­ 0;ˇŢçąŐŒăŽŰw°wr7ŒWśHqŢR‰šH‡:XGĄäy›¸ŇÄŞĄŢ%›ĺ6ńDBˇŘ|ű"ůĚVĐC|ĹĹMDŹZâMPróČŃśqĽB”Í‹ľ†(n`˛6…é"„äĚŮ`´mŁ †cęçĎ_˜çäŠE¤|ň§Żçđ-;ƒĐ(ÎżBJłłcÇ›m.Mˇ™ŘsôőË}GFęTbĹĘĘ*ßxô‹K!ćÔŞű&w°´œňÖÉi~ęýźWzK˝Śaee$óě›ƕ%g¤Ÿ˙̤(ĘÙ#I ?üţYnűĐ­fŒ@`Ë^ŽÎ’UŇt(ŞQ˜„h¤…Ťcfƒ"ţň(ŁQŽ]ËXúÖq|ş•tęSc4šŰO41ˆŞcC\\úł7h~r’ᱝ”äň"ćü*Ź§ŒüĆG°EFĽ6ÄŇŇ Ó3!ŽOěiQo"„$Msž{ńWŽnpבIţţ/ßC˝š?ëk󜻰@–.]šĺń'—™[Xĺ+żö—§Wú<^™^ăýË+üŐăoĺžJU“‹óžKÓŤü÷˙q’‰ÝC|ô#ˇ0=Ž˙nÁ‹?<Çăß9ÁˇO°wr;{v réĘ*ÖzÎżżÎM7ěÄقN'ĺ?}ýEV××M)j•!⊠-S@ÇՁňœ JWQă1Cwěgńéŕ<ÝÓKtűšp†oU@Šţ"o ŁZPց!wîdý{çńĆŃ=ž@÷ř ăÚgřž˝äy;t TÄĚ|ĘÚZŘżV­âQtşŻ˝>Çwžy›o硿úqF†ă~GŞ*WKOšoó[żó]nžq'˙üŸ~‚áA­‘—aÎóƒ—/rß=SüĆŻŢËó?8 ŔÂb›ßúWOsד|éWîec˝‹)+ Őľ„ßůwßĺž{§řÜ/ފ-2~ęc9ö沟ŕ÷˙č9žđš#dšăŮçß%Š4_űÍOҨvŃşúÁ„ƐöeŤMGu„MémżpłÖaóí+ŘÍՈŠÝ°˝­ÎúłçĘF:ÄĂXkRá% üÜ~Ź/ČN­`ć;řŹ@(‰ŹEčĄ:z{Ú=ť‘RS­ ăĺýKóll†:ňôŮEžxęÖ:ŽżłŔ§~ć>óóˇ08PZ§ě‘hąc{‹é™uĆF›Ü~x÷sˇ˛wwçŕg?qO}÷ŇÄ06ÖäŽŰöđ÷>3ťĆÜpp'OÍłm´Îý÷ŕ‘/|˜&işĆĐ@•ŔOŢŸ˙Ľ#4›!\Ýß!NœœçŝĺÄ;łœ˝đ SĂ|řž˝|ćç?Ęś$Aވ4YCŠĐô?~ö×}ŻÝŚt­EB23Ovq ŸXTŁBmjÎ9’S3e#ÚP˝sݨQ­ “v—C—Ş›aŚ7đk.ËAJdUc#ƒ”4wďRĹcřĎ_‘?˙‹7Žó3?Čöą­f…ëěbrO•jĽî%ČU(LJn ÇOŽpůę:;ś5řĐM;Ů6śUŸĎέrô+tş†ńMŽÜśV#ôĽß<~‰Óď-˛s{“{F]`L—˘0|˙Ľ ŹŹĽěÝ3ČG ¤AëJE&a~ąÍ‰“ł,ŻĽ4jšŽg˙ž1˘Ha‹ gs@bmN\m…vŇą˙™ˇE†ľgĎłţłáH"ŠœrŇ`mRş×žŕ“fQža„ŇŮŕĂÜM–wzł­vař“Ů^Ţěrc˝Â?Ţ5ĘX’„ďM6aš zÓä­+˘¤ ˝{ ~‹wř[>_űn‹ďބďűô˙=]ŔÖo[đŢłëß>ˆjŐúĺ€6ŚK\i‰Ýü š­>ď˙ëgŮZŽtCx,<ŃrBGlŐŕ˙ż=B†QT/żh)Ăď-Ńî:Ł„łż2ŒX¤(ë×0°ÖE5Ź5)Ëáa˜wőFLĄ$+oűˆ­`@†ÄŚ0\\Ü`öľ`Đćx‹ć-ÄŇŁDďn(ÇJ•­y˜łX›…ă}Ÿ÷p+ǕƒJž%JބaĆčĘQ}‰`_N§Ăx Ą˝Irď*Co>ŘAő<Óű˘¸şRa"˘ă…i‡°ŚŁjŸpýž)÷(3Ą!MVˆâśČÂčGĹEF­>Bo8i‹Ź<íDýŇ$L2*(NkÖć(ă ÎĚŽńҋgxîýyŠŇőŢ5†ď Hú;bp “Ĺu¤ŠÂ܎^ŹĚRQ­ô š&ŤÄ•ŔŁŁEŢĽ(RZƒ“ ÎLžYN*ĕł9Ţ9âęYşŽ”:Č"ÂěMéA˜>§ÉZČS*.‘§ąŇĹٜ,Y<2ŽŃ…IĐQ ď&ďĹ Š˛l3y—¸Ň (t]­Ušx.WDq)u™¤k}:[1ȓgAé˝8gMĘćĆ:+Ťîźm7žkÎäyŽ) íŽă[ÔŁaB’t–JžRœ3DŃP*¤˘Z ˙tľDŤ ‚‹€Ň´ťD–nňľ6ďâ\A\i• 4ďqB˘Ł*Î(cňĐm´E Ş“wpŢŤO(ɜ͡ôŚÂ¤dŮF8*„•(Ězr(Žc CŇ]ĄZāÖU˘JľL ’,YĂš˘_žé¨V*•~MéJi8ÁŢ˝c|é‘íXŰAŤŢ%ş˜<Ďđv­ký¤â˝%\\ńHŠeĹÓŰ çąe8 hrč¨J7Ź ÷;tTE…Ž*a}™‹" 73‹ ď]@p9֗JĄCçŹ!ËŰÄQď,YşA­>Š1 xß/s­5adVN—˙Œb[í/ž-čIENDŽB`‚fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/remote.png0000644000175000017500000000064411151613006017655 0ustar rmhrmh‰PNG  IHDR žr‡ŔPLTE˙˙˙5œœŢ˙Z˜¸1Rcîů˙:TŠŃĚĚÔŇŇÎî˙ČĂÁČÂŔÇŔźÇŔť˝şş˝š¸ź¸ˇťˇľŇđ…’’|…{€…y{{yzyyyxwvrvtoZœ1Tc"Op"Gb9H,))*((%#%"$ -?%+((!% )  $1 # )   + #ú ˙tRNS@ćŘfbKGD?>c0u pHYsHHFÉk>pIDATxÚ-Íé‚0ŕŮíśĹ[ńźŔ[9äýÍŇ8żžL&ÝYrżŽpž^DşŢŽ{ fuśX|ţ6KTşCě]"ÓžvžáŠýFŠÍŤ˜=ĺ2…=†Lʈ¤0Ú7"ňŢMÚłŢ ŸdĘbÁމ2’=Ú´ŮÄa‡&‚25ѲT14c•¤IĐŕÓb›WcŇ,ĚČŇtlHlą&“ŞÜäb,g:iłˆ B[ô)s6áq‚ 'ĘAbR˘Ę2Ç鍜 :ąc"*Žgˆ/sRŘä'TRxŃÖ AŘőÜFÎ.EŽGĹéĐО ť4űř?Ň'*™s8\a‘/x¤ź§ú!ěWă;=ýuPݝ7ä yN’‰DxËsę?7ß|{Ŕüѓ4>íÝőŚŘ™ś­ë´ńŃÉM˃RÍ°ç!ö! …}Ľţ˜¸˙Ęô_ýżózĚĐđű0ÍIENDŽB`‚fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/article.css0000644000175000017500000001503711151613006020013 0ustar rmhrmh/* Layout and decoration */ /* @Author: Thomas Link (samul AT web.de) */ /* @Created: 13-Apr-2004. */ /* @Last Change: 09-Aug-2005. */ /* @Revision: 0.787 */ @page { size:portrait; margin-top:3cm; margin-bottom:3cm; margin-left:3cm; margin-right:3cm } body { color: #000000; background-color: #ffffff; text-align: left; } a { color : black; } a:link { color : #0071f0; } a:visited { color : #30306f; } a:hover { color: #0071f0; } a:link.ref { } a:visited.ref { } p { padding: 5pt; } big { } hr { } hr.pagebreak { color: #000000; } h1, h2, h3, h4, h5, h6 { padding-left: 20pt; text-align: left; page-break-after: avoid; } h1 { margin-top: 40pt; margin-bottom: 20pt; padding-top: 10pt; padding-bottom: 10pt; } h2 { margin-top: 30pt; margin-bottom: 10pt; } h3 { margin-top: 20pt; margin-bottom: 10pt; } h4 { margin-top: 10pt; margin-bottom: 10pt; } h5 { margin-top: 10pt; margin-bottom: 5pt; } h6 { margin-top: 10pt; } em { } div.table { padding: 20pt; /* text-align: center; */ } table, tr, th, td { border-spacing: 1pt; color : black; } table { border: 1pt solid #000000; } tr, th, td { padding: 2pt; } tr { } tr.head { } thead { } th { } td { } blockquote { margin: 20pt 60pt 20pt 60pt; } blockquote.quote { } blockquote.longquote { } blockquote.abstract { } ul { } ol { } dl { } dt { margin-left: 10pt; padding-left: 10pt; padding-top: 2pt; padding-bottom: 2pt; } dd { margin-bottom: 10pt; } li { padding: 2pt; margin-right: 20pt; } p.itempara { border-left: 0; border-right: 0; padding: 0; } pre { border: 1pt solid #efefef; margin-left: 40pt; margin-right: 40pt; padding: 5pt; } /* htmlnavigation: Usage note */ .htmlnavigationnote { padding: 0; color: #888888; } p.htmlnavigationnote { } ul.htmlnavigationnote { } li.htmlnavigationnote { } hr.htmlnavigationnote { border:0; } /* Navigation bar */ a:link.navbarUrl, a:visited.navbarUrl { color : #7f607f; } a:link.navbarUrl { } a:visited.navbarUrl { } .navbar, .navmenu, .navgo { background: #ffffff; vertical-align: middle; } table.navbar { width: 100%; margin: 20pt 0 20pt 0; } td.navbar { width: 5%; text-align: center; } td.navmenu { width: 100%; text-align: left; } select.navmenu { width:250px; border:0 hidden #ffffff; } p.navgo { border: 0; padding: 0; margin: 0; } button.navgo { border: 0; } /* Figure */ div.figure { text-align: center; padding: 20pt; } /* Caption */ caption { } p.caption { } /* Title */ div.title { text-align: left; padding: 20pt; margin: 20pt 0 20pt 0; } p.title, p.author, p.authornote, p.date { margin: 0; border: 0; } p.title { } p.author { } p.authornote { } p.date { } hr.title { color: #f1f08f; background-color: #e4f8fc; padding: 1pt; margin: 0 45% 0 45%; } /* Table of Contents etc. */ div.toc { } p.toc { } ul.toc, li.toc { list-style-type : none; } ul.toc { } a.toc:after { content: leader('.') target-counter(attr(href), page); } li.toc { padding: 0; } div.lot { } p.lot { } ul.lot, li.lot { list-style-type : none; } ul.lot { } li.lot { padding: 0; } div.lof { } p.lof { } ul.lof, li.lof { list-style-type : none; } ul.lof { } li.lof { padding: 0; } hr.list { color:#f1f08f; padding: 1pt; margin: 0 45% 0 45%; } /* Mini Table of Contents */ #Contents { position: absolute; top:50px; left:0px; padding:0px; visibility:hidden; margin:0px; } #ContentsBlock { position: absolute; top:30px; left:0px; padding:0px; } div.minitoc { max-height: 500px; background: #f1f1f1; } h1.minitoc { margin: 0; padding: 5pt; border: 0; } ul.minitoc { } li.minitoc { } /* Footnotes */ a:link.footnote, a:visited.footnote { vertical-align: top; } a:link.footnote { } a:visited.footnote { } p.footnotes { padding-top: 10pt; margin: 40pt 40% 0 0; } ol.footnotes { } li.footnotes { } /* OpenOffice compatible footnotes */ .sdfootnoteanc { vertical-align: top; color: #30306f; } .sdfootnotesym { background-color: #e4f8fc; vertical-align: top; color: #30306f; } p.sdfootnote { margin-left: 5%; margin-right: 5%; } /* Bibliography */ .bib, .bibLef, .bibRight { background-color:#ffffff; } table.bib { width: 100%; } td.bibLeft { } td.bib { } td.bibRight { } h1.bib { } p.bib { margin-left: 20pt; text-indent: -20pt; } /* Index */ h2.index { } p.indextoc { } dl.index { } dt.index { } dd.index { } /* Marker */ div.note, div.warning, div.caution, div.important { /* position: absolute; */ /* left: 720pt; */ /* width: 100pt; */ background-color: #eaeaea; } p.note, p.warning, p.caution, p.important { padding: 5pt; border-right: 0; } p.note { border-left: 10pt solid #ffff00; } p.warning { border-left: 10pt solid #cf0000; } p.caution { border-left: 10pt solid #ef4f00; } p.important { border-left: 10pt solid #009f9f; } em.marker { color : #910000; background-color:#ffff00; } span.marker { position: absolute; left: 700pt; width: 60pt; } /* Header, Footer */ .header, .footer { background-color:#eaeaea; border: 0; } div.header, div.footer { } table.header, table.footer { width: 100%; } thead.header, thead.footer { } tr.header, tr.footer { } th.header, th.footer { } td.header, td.footer { } p.header, p.footer { } /* Validate HTML */ #pageicons { visibility: hidden; } div.pageicons { } .validhtml { background-color:#ffffff; } table.validhtml { } tr.validhtml { } td.validhtml { } /* TabBar */ #tabBar { visibility: hidden; max-height:0; } div.tabBarLeft { visibility: hidden; } div.bodyRight { /* position: relative; */ /* left: 250pt; */ } a.tabBarEntry { } .tabBar, .tabBody { } div.tabBar { visibility: hidden; } div.tabBody { background-color: #ffffff; vertical-align: top; } div.tabBodyText { } table.tabBar, table.tabBarTop, table.tabBarTopLeft, table.tabBarTopRight, table.tabBarTopBottom { visibility:hidden; } tr.tabBar { } td.tabBar { padding: 4pt; } td.tabBody { } .tabBarLeft { visibility:hidden; } table.tabBarLeft { } tr.tabBarLeft { } td.tabBarLeft { } .tabBarLeftActive { } tr.tabBarLeftActive { } td.tabBarLeftActive { } .tabBarLeftInactive { } tr.tabBarLeftInactive { } td.tabBarLeftInactive { } .tabBarLeftButtons { } tr.tabBarLeftButtons { } td.tabBarLeftButtons { } .buttonRow { } table.buttonRow { } tr.buttonRow { } td.buttonRow { } fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/deplate.css0000644000175000017500000002352211151613006020004 0ustar rmhrmh/* Layout and decoration */ /* @Author: Thomas Link (samul AT web.de) */ /* @Created: 13-Apr-2004. */ /* @Last Change: 19-Okt-2005. */ /* @Revision: 0.1119 */ body { padding: 1px; color: #000000; background-color: #ffffff; text-align: left; } a { color : black; } a:link { color : #0071f0; } a:visited { color : #30306f; } a:hover { color: #0071f0; } a:link.ref { } a:visited.ref { } p { /* border-left: 10px solid #ffffff; */ /* border-right: 10px solid #ffffff; */ margin: 0 10px 0 10px; padding: 5px; /* text-indent: 20px; */ } big { } hr { } hr.pagebreak { color: #000000; } img { } img.latex { vertical-align: middle; } img.inline { } h1, h2, h3, h4, h5, h6 { padding-left: 20px; text-align: left; } h1 { margin-top: 30px; margin-bottom: 20px; padding-top: 10px; padding-bottom: 10px; border-left:10px solid #ffe590; background-color: #fff3d0; } h2 { margin-top: 30px; margin-bottom: 10px; border-left:10px solid #ffe590; } h3 { border-left:10px solid #ffe590; margin-top: 20px; margin-bottom: 10px; } h4 { border-left:10px solid #ffe590; margin-top: 10px; margin-bottom: 10px; } h5 { border-left:10px solid #ffe590; margin-top: 10px; margin-bottom: 5px; } h6 { border-left:10px solid #ffe590; margin-top: 10px; } em { } blockquote { margin: 20px 60px 20px 60px; } blockquote.quote { } blockquote.longquote { } blockquote.abstract { } ul { } ol { } dl { } dt { margin-left: 10px; padding-left: 10px; padding-top: 2px; padding-bottom: 2px; } dd { margin-bottom: 10px; } li { padding: 2px; margin-right: 20px; } br.itempara { } p.itempara { border-left: 0; border-right: 0; padding: 0; } pre { margin-left: 40px; margin-right: 40px; padding: 5px; } pre.verbatim { background-color: #eaeaea; border-left: 5px solid #efefef; } div.code { background-color: #ffffff; } /* Tables */ div.table { /* text-align: center; */ padding: 20px; } div.tableNote { /* text-align: center; */ } table, tr, th, td { border-style: none; background-color:#eaeaea; border-spacing: 0; color : black; } table { /* border-left: 10px solid #ffffff; */ /* border-right: 10px solid #ffffff; */ /* margin: 0 10px 0 10px; */ margin: 0; } thead { } tfoot { } tr, th, td { padding: 2px; border: 1px solid #ffffff; } tr { } tr.head { } tr.foot { } tr.high { } th { } td { } td.head { } td.foot { } td.high { } /* Styled Tables */ .small { } .scriptsize { } .footnotesize { } .grid { background-color:#ffffff; border-collapse: collapse; } div.grid { border: 0; } th.grid, td.grid { border: 1px solid #000000; padding: 2px; } .formal { background-color:#ffffff; } div.formal { border: 0; } table.formal { border-top: 2px solid #000000; border-bottom: 2px solid #000000; border-left: 0; border-right: 0; } thead.formal { } tfoot.formal { } tr.formal[class~="head"] { } tr.formal[class~="foot"] { } td.formal, th.formal { border: 0; padding: 2px; } th.formal[class~="head"] { border-bottom: 1px solid #000000; } td.formal[class~="foot"] { border-top: 1px solid #000000; } .box { background-color:#ffffff; } div.box { border: 0; } table.box { border: 1px solid #000000; } thead.box, tfoot.box { border: 1px solid #000000; } td.box, th.box { border: 0; padding: 2px; } th.box[class~="head"] { border-bottom: 1px solid #000000; } td.box[class~="foot"] { border-top: 1px solid #000000; } td.box[class~="high"] { border-left: 1px solid #000000; border-right: 1px solid #000000; } .overlay { background-color:#ffffff; } div.overlay { border: 0; } table.overlay { border: 1px solid #000000; } thead.overlay { background-color: #e0e0e0; border: 1px solid #000000; } tfoot.overlay { background-color: #eaeaea; border: 1px solid #000000; } tr.overlay[class~="head"] { } td.overlay, th.overlay { border: 0; padding: 2px; } th.overlay[class~="head"] { background-color: #e0e0e0; border-bottom: 1px solid #000000; } td.overlay[class~="foot"] { background-color: #eaeaea; border-top: 1px solid #000000; } td.overlay[class~="high"] { border-left: 1px solid #000000; border-right: 1px solid #000000; background-color: #eaeaea; } /* htmlnavigation: Usage note */ .htmlnavigationnote { color: #888888; } p.htmlnavigationnote { } ul.htmlnavigationnote { } li.htmlnavigationnote { } hr.htmlnavigationnote { margin-top: 20px; /* border: 1px; */ } /* Navigation bar */ a:link.navbarUrl, a:visited.navbarUrl { color : #7f607f; } a:link.navbarUrl { } a:visited.navbarUrl { } .navbar, .navmenu, .navgo { background: #ffffff; vertical-align: middle; } table.navbar { width: 100%; margin: 20px 0 20px 0; } td.navbar { text-align: center; } td.navmenu { width: 80%; text-align: left; } select.navmenu { width:250px; border:0; } p.navgo { border: 0; padding: 0; margin: 0; } button.navgo { border: 0; } /* Figure */ div.figure { text-align: center; padding: 20px; } /* Caption */ caption { } p.caption { } /* Title */ div.title { text-align: left; padding: 20px; margin: 20px 0 20px 0; border-top: 1px solid #ffe590; border-right: 10px solid #ffe590; border-left: 1px solid #ffe590; border-bottom: 5px solid #ffe590; background-color: #fff3d0; } p.title, p.author, p.authornote, p.date { margin: 0; border: 0; } p.title { } p.author { } p.authornote { } p.date { } hr.title { color: #f1f08f; background-color: #e4f8fc; border: 1px solid #f1f08f; padding: 1px; margin: 0 45% 0 45%; } /* Table of Contents etc. */ div.toc, div.lot, div.lof { } ul.toc, ul.lot, ul.lof { } li.toc, li.lot, li.lof { list-style-type : none; padding: 1px; } div.toc { } p.toc { } ul.toc, li.toc { } ul.toc { } li.toc { } div.lot { } p.lot { } ul.lot, li.lot { } ul.lot { } li.lot { } div.lof { } p.lof { } ul.lof, li.lof { } ul.lof { } li.lof { } hr.list { color:#f1f08f; background-color: #e4f8fc; border:1px solid #f1f08f; padding: 1px; margin: 0 45% 0 45%; } /* Mini Table of Contents */ #Contents { position: absolute; top:50px; left:0px; padding:0px; visibility:hidden; margin:0px; } #ContentsBlock { position: absolute; top:30px; left:0px; padding:0px; } div.minitoc { max-height: 500px; background: #f1f1f1; border-top: 1px solid #e0e0e0; border-bottom: 1px solid #e0e0e0; border-right: 1px solid #e0e0e0; } h1.minitoc { margin: 0; padding: 5px; border: 0; } ul.minitoc { } li.minitoc { } /* Footnotes */ a:link.footnote, a:visited.footnote { vertical-align: top; } a:link.footnote { } a:visited.footnote { } div.footnotes { border-top: 1px dashed #888888; margin-top: 30px; padding-top: 10px; } p.footnotes { border-top: 1px solid #ffe590; padding-top: 10px; margin: 40px 40% 0 0; } ol.footnotes { } li.footnotes { } /* OpenOffice compatible footnotes */ .sdfootnoteanc { vertical-align: top; color: #30306f; } .sdfootnotesym { background-color: #e4f8fc; vertical-align: top; color: #30306f; } p.sdfootnote { margin-left: 5%; margin-right: 5%; } /* Bibliography */ .bib, .bibLef, .bibRight { background-color:#ffffff; } table.bib { width: 100%; } td.bibLeft { } td.bib { } td.bibRight { } h1.bib { } p.bib { margin-left: 20px; text-indent: -20px; } /* Index */ h2.index { } p.indextoc { } dl.index { } dt.index { } dd.index { } /* Marker */ div.note, div.warning, div.caution, div.important { /* position: absolute; */ /* left: 720px; */ /* width: 100px; */ /* background-color: #eaeaea; */ /* background-color: #ffe590; */ background-color: #fff3d0; /* background-color: #ffff00; */ } p.note, p.warning, p.caution, p.important { padding: 5px; margin: 0; } p.note { border-left: 10px solid #ffff00; border-right: 10px solid #ffff00; } p.warning { border-left: 10px solid #cf0000; border-right: 10px solid #cf0000; } p.caution { border-left: 10px solid #ef4f00; border-right: 10px solid #ef4f00; } p.important { border-left: 10px solid #009f9f; border-right: 10px solid #009f9f; } em.marker { color : #910000; background-color: #ffff00; } span.marker { position: absolute; left: -25px; width: 60px; text-align: right; } /* Header, Footer */ .header, .footer { background-color:#eaeaea; border: 0; } div.header, div.footer { } table.header, table.footer { width: 100%; } thead.header, thead.footer { } tr.header, tr.footer { } th.header, th.footer { } td.header, td.footer { } p.header, p.footer { } /* Validate HTML */ div.pageicons { text-align: right; margin: 10px; } .validhtml { background-color:#ffffff; } table.validhtml { } tr.validhtml { } td.validhtml { } /* ProgressBar */ .progressBar { max-width: 150px; } div.progressBar { background-color: #dfdfff; text-align: center; vertical-align: middle; padding-top: 10px; padding-bottom: 10px; } table.progressBar { table-layout: fixed; min-width: 130px; border: 1px solid #30306f; padding: 0; margin: 2px 4px 2px 4px; } td.progressBarDone, tr.progressBarDone { border: 0; background-color: #ffe590; } td.progressBarToBeDone, tr.progressBarToBeDone { border: 0; background-color: #dfdfff; } span.progress { color: #30306f; } li.todo[class~="plus"] { list-style-type: none; } li.todo[class~="plus"]:before { font-weight: bold; content: "[TODO]"; color: #ff0000; background-color: #ffff00; } li.todo[class~="dash"] { list-style-type: none; text-decoration:line-through; color: #555555; } li.todo[class~="dash"]:before { font-weight: bold; content: "[DONE]"; } iframe { border: 0; } fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/heading-navbar.css0000644000175000017500000000114311151613006021227 0ustar rmhrmh/* Layout and decoration */ /* @Author: Thomas Link (samul AT web.de) */ /* @Created: 13-Apr-2004. */ /* @Last Change: 22-Mär-2005. */ /* @Revision: 0.1064 */ table.navbar { border-top: 0; border-bottom: 0; border-left: 10px solid #ffffff; border-right: 0; border-spacing: 0; border-collapse: collapse; /* background-color: #fff0c0; */ margin: 10px 0 0 0; padding: 0; } td.navbar, td.navmenu { /* background-color: #fff0c0; */ margin: 0; padding: 0; border: 0; vertical-align: middle; } h1, h2 { margin-top: 0; /* padding: 5px; */ } fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/prev-grey.png0000644000175000017500000000120011151613006020267 0ustar rmhrmh‰PNG  IHDRJ~ősbKGD˙‡Ěż pHYs  šœtIMEÔ 'pu÷fIDATxÚĽ”;oA…żŻ9Ţ]#BöĆ $ۛ @q* Z‹–T”Pđch¨(-JţMˆD$¤`›G۲@Ğ5Äf(ěŹÄ4ŁšssĎ=gŕ—˜8Ëß<ôáäŘ}—& ó§‰K‘›b™nđ˜2ak°ŰœĹ—KN1í8€ŔŠ‚r´M•mÂŃ ’9q7u9›Í9%á Œ†&+捪×Ű/Ě=*ý* pń]Zđ—,ŸŮ¨ Mž‚¨šËţşůâĐĆ@ pY”ˇro'Ž“&D]śQxœ#)+Ó­”iń‘МçŽ{íŞ{CxčâĎyŔKňœ^ǃ™^‚->a,Ŕ–^Ć)‰,MHƒO¨ąƒOI–’¨8ĘÓö%i“a97üÄI2ŘŃH­°!ĎxD…!zlčrd\ÖŰĎŹąÎöG;H6ÁžĂ Y 3A(3–ŔmŠ¤ÇzňĎL萀y昼ĄC]ˆľęf௤ b‰­b“DSgĹJ7űlŠaŘŁócĆ:›JG"˜â¸B†ŹŞ`Í5žÓ2_{sť'“X ÎqŚh˛ÁňţŤˇßîó”ÎÁ“ Şť›eńţ0śnRĽÓď\ĄĽĘzyT Šč°­:G(î?4ý—żĆ/™x×^˘KxIENDŽB`‚fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/mailto.png0000644000175000017500000000026411151613006017645 0ustar rmhrmh‰PNG  IHDR v÷rôPLTE˙˙˙úűżęë—ÄĹ Ł¤}~IJƒűWď pHYsHHFÉk>BIDATxÚcHƒ†0gHRRRRugHPŇA@Z)HIU Dť*…€hĽP%'w†D' źŠ;C˛ ¸3¤—ƒ—ĚáXińIENDŽB`‚fuse4bsd-0.3.9~pre1.20080208/doc/html_aux/serif.css0000644000175000017500000000551211151613006017475 0ustar rmhrmh/* Text style: sans-serif */ /* @Author: Thomas Link (samul AT web.de) */ /* @Created: 13-Apr-2004. */ /* @Last Change: 26-Mai-2005. */ /* @Revision: 0.623 */ body, table, div { /* font-family: Georgia, Bookman, Times, Serif; */ font-family: Georgia, Minion Web, Palatino, Book Antiqua, Utopia, Times New Roman, serif; /* font-size-adjust: .5; */ font-size: 14px; } big { font-weight: bolder; } h1, h2, h3, h4, h5, h6 { /* font-family : Georgia, Bookman, Times, Serif; */ /* font-family : Verdana, Monaco, Sans-Serif; */ font-family: Verdana, Myriad Web, Syntax, sans-serif; font-weight: bold; } h1 { font-size: 28px; } h2 { font-size: 24px; } h3 { font-size: 20px; } h4 { font-size: 18px; } h5 { font-size: 16px; } h6 { font-size: 16px; } tr.head, tr.foot, tr.high, th, td.foot, td.high { font-weight: bold; } td[class~="head"], td[class~="foot"] { font-weight: bold; } div.tableNote { font-size: 12px; font-style: italic; } .small { font-size: 11px; } .scriptsize { font-size: 10px; } .footnotesize { font-size: 9px; } blockquote { font-family: Sans-Serif; } blockquote.quote { } blockquote.longquote { } blockquote.abstract { font-style: italic; } dt { font-weight: bold; } code, pre { font-family: 'Monotype.com', Courier New, Courier, Monospace; font-size-adjust: -.5; } /* pre { */ /* font-size: 12px; */ /* } */ /* htmlnavigation: Usage note */ /* Navigation bar */ a:link.navbar, a:visited.navbar { text-decoration: none; font-size: 12px; } select.navmenu { font-size:9px; } p.navgo { font-size:9px; } /* Figure */ /* Caption */ caption, p.caption { font-weight: bold; } /* Title */ p.title, p.author, p.authornote, p.date { font-family: Verdana, Myriad Web, Syntax, sans-serif; font-weight: bold; } p.title { font-size: 28px; } p.author { font-size: 24px; } p.authornote { font-size: 18px; } p.date { font-size: 18px; } /* Table of Contents etc. */ /* Mini Table of Contents */ /* Footnotes */ a:link.footnote, a:visited.footnote { font-size: 9px; text-decoration: none; } p.footnotes, ol.footnotes, li.footnotes { font-size: 12px; } p.footnotes { font-weight: bold; } /* OpenOffice compatible footnotes */ .sdfootnoteanc { font-size: 9px; } .sdfootnotesym, .sdfootnote { font-size: 12px; } /* Bibliography */ /* Index */ /* Marker */ div.note, div.warning, div.caution, div.important { font-family: Verdana, Myriad Web, Syntax, sans-serif; font-size: 12px; } /* Header, Footer */ /* Validate HTML */ /* TabBar */ .tabBarLeft, .tabBarRight, .tabBarTop, .tabBarBottom { font-size: 10px; } a.tabBarEntry { text-decoration: none; font-family: Verdana, Myriad Web, Syntax, sans-serif; } /* ProgressBar */ span.progress { font-size: 10px; } fuse4bsd-0.3.9~pre1.20080208/doc/implementation.dpl0000644000175000017500000007737211151613006017575 0ustar rmhrmh* Implementation notes about Fuse for FreeBSD, with special emphasis on comparing it to Linux Fuse #OPT: id=Implementation Here I summarize the differences between the original Fuse implementation for Linux, and Fuse for FreeBSD, with references to the differences of OSes themselves, where it's necessary. First let's see what's implemented by the FreeBSD Fuse module. Perhaps the most platform-independent way of expressing the functionality is to list the utilized Fuse operations and say: the OS functionality provided is what these operations can be used for. So, we (__Fuse for FreeBSD__) utilize these: - ''FUSE_LOOKUP'' - ''FUSE_FORGET'' - ''FUSE_GETATTR'' - ''FUSE_SETATTR'' - ''FUSE_READLINK'' - ''FUSE_SYMLINK'' - ''FUSE_MKNOD'' - ''FUSE_MKDIR'' - ''FUSE_UNLINK'' - ''FUSE_RMDIR'' - ''FUSE_RENAME'' - ''FUSE_LINK'' - ''FUSE_OPEN'' - ''FUSE_READ'' - ''FUSE_WRITE'' - ''FUSE_STATFS'' - ''FUSE_RELEASE'' - ''FUSE_FSYNC'' - ''FUSE_INIT'' - ''FUSE_OPENDIR'' - ''FUSE_READDIR'' - ''FUSE_RELEASEDIR'' - ''FUSE_FSYNCDIR'' - ''FUSE_ACCESS'' - ''FUSE_CREATE'' Ie., we don't use the following ones: - ''FUSE_SETXATTR'' - ''FUSE_GETXATTR'' - ''FUSE_LISTXATTR'' - ''FUSE_REMOVEXATTR'' - ''FUSE_FLUSH'' However, some nuances are left hidden by this rudimentary description. We do provide mmap, and give kernel level support to the allow_other, direct_io, kernel_cache options. We don't support attribute and name caching ("d_cache" in Linux). We neither have specific large file support. Support for all the above mentioned goodies can be added in due time, maybe except for (the functionality behind) ''FUSE_FLUSH'' (more on this later). That is, these differences are related to the level of maturity of the two implementations, and as such, these are the less interesting ones. Let's see those differences of the modules which stem from the differences of the two OS and/or preferences of the implementors. ** VFS API This is the one of the greatest impact. Linux VFS operations are inherently (struct) file based, BSD VFS operations are inherently vnode based (BSD vnodes correspond to Linux inodes). That is, all file-related VFS operations take a (struct) file parameter in Linux. In BSD, in some cases you can put your hands on (struct) files, in some cases not. The API encourages and helps you to not use files (if the nature of the fs permits, these can be completely avoided), and a consequently file based design is simply impossible (as I could experience when I tried to make a "naive" port). You are given a subtle system of structures and op vectors which let you do many things with files if you insist on to do so, but which gently shields you from seeing those ugly files in your everyday life. (The vnode centered nature is common to all BSD flavours; how comprehensive is that optional acces to files is flavour dependent, but as I said, never complete.) This becomes manifest in different ways. The most visible of these is ** Mounting *** interface There are many factors which result in a different user interface for the two OS. In Linux, there is one Fuse device, and when a Fuse daemon is started, it calls a helper utility which opens the Fuse device for the daemon and performs the mount syscall "atomically". Hence all mount parameters, including mount point, has to be passed to the daemon. In FreeBSD, there are several Fuse devices. When a Fuse daemon is started, it attaches itself to one -- either completely on its own or using an already existing file descriptor, but it doesn't call any helper program and doesn't do anything mount related. Mounting is done by an external utility. This means that there must exist a global namespace in which the mounter can specify the daemon to mount. As one Fuse device can serve no more than one daemon, it's easy: the device name is used to specify the subject of the mount (what a novelty). In Linux, this couldn't work out this way (given the design chosen by Linux Fuse): there is one Fuse device only, and a fail-safe identification of the subject of the mount is possible only within the scope of one process. In FreeBSD, altering from the Linux way of atomic mounting is not a design choice, it's a must. Unlike Linux, BSDs use a different type of op vector devices and for regular files (the device access and vnode API is not unified). The device access API is not only different but almost completely (struct) file unaware. So we can't distinguish between different openers of a given device. The traditional solution would be working with a static set of fuse devices (nnpfs, the multiplatform userspace vfs framework of Arla has chosen this solution in its BSD implementations). However, FreeBSD has a peculiarity which lets us implement Fuse as dynamically as it's in Linux: a wisely designed in-kernel device filesystem. FreeBSD devfs provides a mechanism to register event handlers for certain device name patterns, by which new devices can be spawned on the fly and system call handling can be delegated. We rely on this mechanism for providing a dedicated Fuse device to each Fuse daemon. At this point, one could spot one definite advantage of the Linux way of doing the mount: it's comfortable. That the state of Fuse daemons is explicitly reflected in the devfs namespace might seem to be an elegant concept, yet performing the device squatting and the mount syscall via separate commands will get tedious pretty fast. To get over this, the mount utility serves as an umbrella frontend to all these mechanisms, and running ''mount_fusefs auto mp daemon args'' will open a Fuse device, start the daemon with the given args and makes it chew on the device, and finally mount the daemon on mp. A more recent enhancement of Fuse on FreeBSD is adding support also for the Linux style interface. That is, you can mount Fuse daemons with the ''daemon args mp'' syntax as well, in which case the daemon will invoke ''mount_fusefs'' by herself. (Note: this of course won't work if you want to do mounting on a different privilege level than that of the daemon). It's also a comfortable thing in Linux that when you run ''mount(8)'' to see the list of mounted filesystems, what you will find in the "mounted device" (first) column for Fuse filesystems, is a compact custom description of the filesystem. Under FreeBSD you will see simply the device name as is, which might feel crude related to the Linux listing. Yet I don't plan implementing an "fs-summary-as-device" hack under FreeBSD: that would mean loss of information. Even if showing the device name is not so friendly, that is the exact unique identifier of the mount. What I might happen to do is to write (or to wait for one being written) a nifty shell script which gathers Fuse mount related informations and presents it in a human-loveable way -- you can find out everything you want via ''mount(8)'', ''ps(1)'' and ''fstat(1)''. *** security Fuse is a dedicatedly Promethean filesystem: it aims to the bring the power of interaction via a custom filesystem interface to ordinary users. Practically, this boils down to doing customized non-privileged mounts. In Linux, ordinary users are usually allowed to do mounts via the ''user(s)'' option of fstab. This is a fairly static mechanism, so to be able to do the customized non-privileged mounts as it's required, Linux Fuse rolls his own: the above mentioned device opener/mounter utility is written in a way so that it can safely bear the suid bit, and then the appropriate permission handling logic is stuffed into this utility, too. In FreeBSD no heroic action is needed. No setuid mounting is needed -- unlike Linux, there are no ''user(s)'' option in fstab, and ''mount(8)'' itself is not setuid. Non-privileged mounts are handled via a system-wide policy: if the ''vfs.usermount'' sysctl is 1, users can mount over mount points owned by them, if it's 0, only root is allowed to mount. Unlike as it's with the ''user(s)'' fstab options, Fuse mounts fit into this frame nicely, so there is no need to implement special methods for non-privileged mounts. Yet there might be administrators who find this control too much rudimentary... What do such people do? Most likely, they set ''vfs.usermount'' to 0, and use their homebrew privilege delegation policies; by all chance, they implement it via ''sudo(8)''. However, ''mount_fusefs'' can run an arbitrary other command, so can't be called from ''sudoers'' without care. Nevertheless, the commandline interface is designed in a way such that it is easy to ban daemon spawning (eg., ''mount_fusefs -S'' will not be willing to start a daemon). Moreover, besides the already mentioned above mentioned ''vfs.usermount'' sysctl, FreeBSD has an other access control mechanism for mounting. This comes into play if the filesystem is backed by a device. In that case, only those can mount the filesystem who have read/write access to the device to be mounted (or read access for a read only mount). This latter mechanism can be used with Fuse, too: despite its somewhat synthetic charater, Fuse is a device backed filesystem. There is though one subtle difference between Fuse and traditonal device (disk) backed filesystems in this respect: with traditional filesystems, permissions of the device are used also for providing access control for the device file as such, which is a valid entity on its own and can be used for performing raw I/O on the appropriate hardware. On the contrary, Fuse devices has no use without being mounted (the kernel is not willing to interact with a reader/writer of the device file until the VFS layer pushes messages onto it). Hence permission settings of Fuse devices are to be directly interpreted as permissions for mounting Fuse filesystems. So this is the tool by which a fine-grained control on mounting Fuse filesystems can be set up. By default, Fuse devices can be used by members of the operator group (that's used for controlling access to, eg., usb devices). One can set permissions of fuse devives directly, by chmod, or generally, via ''devfs(8)'' rules. Let's elaborate a bit more on this "naturally useable" BSD mount access control. This also makes Fuse more exposed to attacks under FreeBSD than it is under Linux: in Linux, non privileged mountability of Fuse based filesystems don't open up further privileged tasks. In FreeBSD, mounting and unmounting will be available more generally if the respective permissive move ("''sysctl vfs.usermount=1''") has been done. (With the help of sudo, one can setup an access control scheme which is similar to that of Linux, yet we are to give full support for the system provided facilities.) As we said, device permissions can fall into the role of mount permissions, thus there are limits to the freedom provided by ''vfs.usermount=1'', but this happens only with device based filesystems. The null filesystem (providing functionality similar to "bind mounting" in Linux) is one example for a deviceless filesystem. A user can create a deadlock by null mounting a directory of a Fuse filesystem over another directory, if the Fuse filesystem requires this other directory during its operation. And users can freely unmount their filesystems, including forced unmounts, which can easily lead to panics. (Note that while Linux tends to stay on the safe side and refuse forced umounts too, if the filesystem is busy, FreeBSD tends to go forward and perform the forced unmount and occasionally panic.) So in FreeBSD, we will have to cope with these, too, if we want to claim that mounting of untrusted daemons is safe. Careful code review slowly leads us toward a state in which this claim can be maintained. To add, Linux Fuse doesn't seem to rely on its more protected situation: Linux Fuse was immune to those crashing schemes that were used to be possible to summon by non-privileged users in FreeBSD (in Linux, these were attempted as root, of course). *** dealing with the "allow other" misery This is related to security, too, but deserves an dedicated subchapter. The problem is that the Fuse daemon sees I/O activity of the users of the filesystem driven by her. As usually no privileges are needed for using Fuse, we can't guarantee that the daemon belongs to a trusted user account. Moreover, mounts are transparent for normal filesystem related activities, so the user of a filesystem might be unaware of the fact that a given path belongs to a Fuse mount. How is this handled in Linux? By default a user is denied from usage of a Fuse mount unless the daemon is "more privileged" than the user (that is, the daemon's credentials allow her trace the user's processes). There is a mount option, ''allow_other'', which removes this limitation. Of course, if anyone could use this option, that would pretty much defeat the very purpose of its existence. So by default, only root can use this. However, the final decision is made by the setuid dispatcher; and his decision is based upon settings in the respective config file ''/etc/fuse.conf''. The problem with this approach is that it's pretty hard for the root to make sure that no user of the system would mind an "everyone can allow_other" policy. And in FreeBSD, we couldn't even follow this approach, as we don't have a setuid dispatcher for deciding about the fate of ''allow_other'' attempts. So, what do we do about it in FreeBSD? The basic setup is the same as in Linux: there is an ''allow_other'' mount option, useable only by root. But we don't make exceptions: ''allow_other'' can be used only by root, period. Yet we have our own ways of being not too draconian. We have an explicit global unique userspace identifier of daemons in work. This allows the introduction of shared daemons. When the first (primary) mount of a daemon has been completed, other users can do secondary mounts of the same daemon. A secondary mount works like a symlink -- it forwards all requests to the primary mount. So it is a very lightweight mechanism. And what's most important, doing a secondary mount can be viewed as signing an __agreement of traceability__. The secondary mounter can be expected to have the necessary knowledge about the primary mount to which she or he joins. Hence while she or he posessess the secondary mount, s/he will be allowed to use the filesystem -- either via its primary or secondary mounts. *** anything else Not specific to Fuse, but it's a great revelation that one doesn't need to fight with the dreaded ''/etc/mtab'' file under FreeBSD. Even under Linux, traditional file system authors don't get involved with such activities, but due to its alternative mounting mechanisms, Linux Fuse does have to take special care about mtab maintenance. ** [vi]node operations The design of the Fuse "rpc" system shows the traits of the file centric nature of the Linux VFS. In Linux, upon each open system call, a FUSE_OPEN message is sent to the daemon, who then performs whatever opening means to her, and sends back a file handle identifier to the kernel, which then gets attached to the file structure open is done for. In the sequel, when this file structure is used for I/O, the kernel will use the file handle identifier as a reference by which the daemon can find the file's userspace counterpart. So, not only inodes and the daemon's file (node) structures are kept in sync, but entities representing open files, too. (Though this is somewhat relaxed by the fact that the daemon can use the same file handle to serve I/O request for multiple (struct) files.) Keeping vnodes and daemon's file (node) structures in sync happens in FreeBSD, too -- it's a central concept of Fuse, this could be hardly avoided. But concerning files... It's not possible to maintain such a close correspondence between in-kernel file structures and the daemon's file handles in FreeBSD. Luckily for us, this is neither necessary (even if the rpc system suggests having this correspondence). This is so because fuse filehandles are not stateful, unlike file descriptors/streams/structures. That is, if we are in the userspace, and we open a file (node) three times, then it's pretty much makes a difference which file descriptor/stream is used in a given read operation (assuming other parameters of the read call are fixed): each of them stores a file offset during its lifetime, and the read performed on one is understood to start from that given offset (which is then advanced according to the number of bytes read). There is no offset kept with Fuse filehandles: the ''FUSE_READ'' operation requires an explicit offset parameter and the filehandle should serve data according to it, regardless of its exact identity. As process id and credentials are also given with a ''FUSE_READ'', these parameters might better match, but apart from that, it should be the indifferent which filehandle is used. ("Highly synthetic" filesystem daemons might opt to serve data in a filehandle specific manner, but that's an extremity.) So far, it's been explained why is it possible to alter from the "strict correspondence between file structures and daemon's filehandles" model. Now let's see: why is this necessary? There is the so-called "strategy" vnode method, which is used to transfer data between the "storage" (the daemon in our case) and the vmio buffers; this is the engine of buffered I/O in BSD. It takes only two parameters: the vnode we operate on, and the buffer object we read into from or write to the storage (to read or to write: this info is kept with the buffer). With Fuse, what are we to say to the daemon, when the strategy is invoked? We need a "key", a suitable filehandle identifier to perform the I/O request -- where to get one? The situation is easy when reading or writing regular files: these operations can easily be arranged in a way that they will be file aware. When they arrive to the point where the strategy needs to be called, they simply don't call the "official" strategy... but an internal version, which happens to take a filehandle parameter. On the contrary, the readdir operation is not (struct) file aware (file awareness can be forced by a dirty hack, but we better refrain from going that way). Even "worse", when doing an internal mmap, which happens eg. when executing a file, there is no file structure involved at all, and strategy is invoked by the vmio system, with no chance to smuggle in a file parameter. In these cases, the ''FUSE_OPEN'' message is sent by the strategy itself, and thus it gets its vehicle for the I/O. But what to do with the filehandle when the strategy has done its job? Releasing it immediately (that is, strategy releases it before return) is pretty unefficient: the file should be re-opened at each turn of a lengthy read-in. Just simply forgetting about it and polluting the daemon with worn-out filehandles is neither a good idea. Some kind of resource management should be used for these "unbound" filehandles. As the first step of that, a list of filehandles is maintained by each vnode, and when strategy needs one, first looks for a suitable one in the list of existing ones, and asks for a new one only if it finds none. This still doesn't seem to considerably lower the frequency of requests for new filehandles: the criterion for "suitable" is to have the same credentials, mode and pid recorded with the filehandle, thus new processes need to get new filehandles. And filehandles are still kept around ad infinitum. Some kind of garbage collection is needed. The question then: what event should trigger gc and on what thread should gc run? There is a neat built-in gc mechanism: it's invoked when vnodes become unused. The intended effect of this method is disassociating the vnode from its file (node), and putting it back to the pool of free vnodes. We don't do that, as then we would lose the number of lookups (which is needed for Fuse to operate correctly). Yet it's a pretty fine time to gc unbound filehandles. But if a file is kept open for a longer while, that will block this mechanism: the respective vnode remains in use during this time. Then the filehandles created by subsequent internal (fileless) opens will persist. (Imagine that one opens ''/mnt/fuse/bin/ls'' as a regular file, and keeps it open. In this case each execution of this file will create a new unbound filehandle which won't go away upon the termination of the process.) So one more gc entry point is needed. Using the open handler for this purpose is good enough. This will stop the proliferation of unbound filehandles in the above scenario, yet won't occur with an unbearable frequency. ** Syncing As far as I'm concerned, both the Linux and FreeBSD modules pass over written data to the daemon immediately, so all writes are synchronous in the traditional (vmio buffers vs. storage) sense. Yet it doesn't mean that syncing type operations wouldn't make sense with Fuse: there might be a second layer of cached data, maintained by the daemon in the userspace (who might have its own background storage, too). So these operations do make sense, but they should be passed on to the daemon. The Fuse rpc kit does have those operations which are devoted to these purposes: ''FUSE_FSYNC'' and ''FUSE_FLUSH'', and they correspond to the respective Linux syscall handlers. According to Linux semantics, their functionality differs in the way of relating to file data and meta data (I never remember exactly how). In FreeBSD, there is just one syscall of this type, fsync. It is both for synchronizing file data and meta data. For both type of data, two kind of operation mode is available: the one where the caller waits for completing the operation, and the one where operation is backgrounded. The actual combination of these modes is determined by the mount flags of the filesystem. So, to summarize, both OS' syncing methods can relate to file data and meta data in various subtle ways, but in rather different ways. Making up our mind in respect of flush is easy: we don't have such a syscall under FreeBSD, hence we just never use ''FUSE_FLUSH''. An alternative is merging the use of the library's flush and fsync functionality in FreeBSD Fuse's fsync handling. This could be considered upon seeing a Fuse filesystem which implements the flush and fsync userspace callbacks in an essentially different (yet BSD [POSIX] compatible) way, but this moment of enlightenment is yet to come. When trying to implement fsync for Fuse, once again we bump into the basic difference: Linux fsync (flush) is file based, FreeBSD fsync is vnode based. Here I can imagine that file basedness has a significance to the userspace: eg., it is possible that sshfs runs different sftp connection threads for different filehandles, and syncing the data stuffed into one connection doesn't imply syncing the data of the other (I don't know whether it goes this way or not actually, but it's enough to see that this is a realistic scenario). So what we do during the fsync vnode op is that we walk over the list of filehandles and send a ''FUSE_FSYNC'' for each. Unlike Linux Fuse (and regardless of the mount flags) we don't wait for the answer: sending the ''FUSE_FSYNC'' messages and waiting for the answer one after the other would be too much pain (and we can't [yet] send/wait for many messages once, in a batch). ** Messaging Here I give a brief comparison of the ways of implementing messaging between kernel and userspace in Linux and in FreeBSD. Before anything else: I don't claim superiority of either solutions over the other. I implemented my solution from scratch, without understanding the respective parts of the Linux code, and without having a clear vision how this will be used by the VFS. (This latter implies that I tried to make the design as general as possible. On one hand, this is good; on the other hand, it means it doesn't contain any Fuse-specific tuning.) Now, __post festam__ I took the effort of peeking at Linux Fuse's messaging code, and I feel able to make this comparison. Nothing is carved into stone, I might make up my mind and bend my code closer to that of Linux Fuse. Or I might make it even more different. Terminology: __up__ will mean __from kernel to userspace__, __down__ will mean... you can guess. ("In" and "out" are too relativistic to my taste.) The basic vehicle of messaging is called a __request__ in Linux, a __ticket__ in FreeBSD. The basic mode of operation is similar. * There is a pool of requests/tickets. * Syscall handler wants to get data from daemon. Takes a request/ticket from the pool, fills in its fields, and inserts into upgoing queue. If buffered I/O is being done, the backing pages/buffers are attached to the request/ticket, too. Handler alerts device's read method and falls asleep, waiting for answer. * The device's read method pushes up the message to the daemon. * The daemon does whatever she should do with it, and sends back an answer. The device's write method grabs the answer and finds out its requester and wakes that up. If buffered read is being done, appropriate parts of the answer are handled differently, and copied into attached page/buffer. * Syscall handler woken up, processes answer, drops requests/ticket, returns. Differences: * In Linux, one Fuse mount works with a fixed number of preallocated requests (with some exceptions, when new ones are created), in FreeBSD, tickets are created on demand. * Unlike Linux, messaging facilites are unconditionally avaliable in FreeBSD. That is, there are no forced delays depending on the intensity of filesystem usage. (This is not because of a __forced-delays-are-evil__ policy; it's rather due to a __better-to-do-nothing-than-to-do-something-without-understanding-it__ standpoint.) * In Linux, the buffers hosting the fields of a request are allocated on the stack (that is, these fields are pointers to structures held in variables of syscall handlers), in FreeBSD, they are allocated dynamically (they are not freed when the ticket gets dropped, they are kept, reused, and reallocated on demand). * In Linux, the unique field of the request is filled with a really unique value upon being taken out of the pool (ie., number of take-out). In FreeBSD, unique values are owned by the ticket itself (it's not changed during the ticket's lifetime), so unique values give information about the number of messaging sessions going in parallell (there is a secondary field for each ticket which stores the number of take-outs that ticket went through, but that's rarely used). * Messaging API: in Linux, the fields of requests are Fuse specific (eg., there are fields named ''inode'', and ''inode2'', as file operations take one or two inode). This means that syscall handlers usually can fill these fields in a straightforward way (''req->inode = inode;''). In FreeBSD, there are just raw message and answer buffers attached to a given ticket. Syscall handlers use variables of pointers of the required structs, and frontend methods for tickets set them to an appropriate value (to the appropriate point in the ticket's appropriate buffer). In some of the more complex cases this means a bit of manual pointer arithmetic; for those of the complex patterns which occur repeatedly (mknod/creat/link), further, specific frontend methods are used (to note, in Linux, too). In general, I didn't feel that this approach yields too much tedious repetition when setting up a ticket. Interrupt handling: in Linux, when a syscall is interrupted, the corresponding request is "backgrounded". It's put into another queue, and when the daemon (unaware of the interrupt) sends its reply, then its get dropped silently. And by-and-large, the same happens in FreeBSD -- just as the special case of a more general mechanism. Tickets have a callback field, which can hold an arbitrary function (of the given type), or can be ''NULL''. When the device write method finds the ticket to which a given answer should be passed, then invokes the callback on the incoming data (so that's what "passing" means), provided it's not ''NULL''. If the callback is not ''NULL'', then the device write method expects the handler doing the necessary resource management by the handler; but if it's ''NULL'', the device write method takes up this role and does what it can do -- drops the ticket, etc. In most cases we use the so-called standard one, which does what's described above: fetch the answer and wake up syscall handler, but we also use ''NULL'' and custom cleanup functions for backgrounded requests. ''NULL'' is used when we don't want to wait for the answer (in case of doing a ''RELEASE'', and in FreeBSD, for ''FSYNC'' too), and to handle interruption. If the syscall is interrupted (that is, if it returns from sleep with an error), then it locks the answer queue and replaces the callback with ''NULL'', and thus the device write routine will aptly discard the answer. Well, there is no guarantee of a race win: it's possible that the device write routine has already taken out the ticket from the answer queue. In that case, it will be passed to the standard handler. That's not a problem, we can make him notice the interruption, and then he will drop the answer rather than waking up anyone. {fn: sex} The only difference is I/O: the standard handler copies in data nevertheless, while this is skipped if the device write routine finds a ''NULL'' callback. #Fn: sex <<-- Daemons are treated as female, for the sake of correctness. Let the standard handler be male. -- ** Miscellaneous Now you can ask: what do I think, which VFS design is the better? Vnode centric BSD or file centric Linux? Frankly: I don't know. While it sounds reasonable to not to keep something always on the surface if it's rarely used directly, I have never tried to get something useful out of the Linux VFS, so I don't know how does it feel to make a filesystem under Linux. What I do have an opinion about is the FreeBSD VFS. Concerning the, so to say, "OO design" it features, the hiearchy of objects and their method kit: I can say it's a carefully crafted masterpiece. There are subsystems which remain completely hidden by default, but they are there for your disposal if you need ever need to tweak it. This yields an interface which is both high-level and highly flexible. On the other hand, when we come to implement the functionality required by a given method (syscall handler), we can see that having a broad range of supported filesystems give Linux an edge. In FreeBSD, one has the feeling that the way syscall handlers are utilized by the OS has too deep ties with UFS, and that when NFS entered the scene, it was bastardized and hacked on until it worked, but the need of doing low-level legwork and re-implement general functionality again and again by each users of the API has not been thoroughly and conceptionally eliminated. Some entries from my factbook: * In Linux, you have a nifty generic_file_read() function which you can just plug in as the read handler, and which does data transfer between user space and the buffer cache in a generic way. In BSD you have to implement read completely by yourself. (For some VFS functionality there are useable defaults in BSD, too: these include syncing, getting/putting pages from/to the storage, and advisory file locking.) * In BSD, you have to take care about many small details by yourself, eg.: "__shouldn't we bail out here because we are mounted read only?__"; check whether a directory is tried to be moved into a subdirectory of itself when doing a rename; check whether vnodes are from the same filesystem when creating hard links, and so on. Sometimes it's trivial to do these (just shouldn't be forgotten about), sometimes not so much... * The BSD codebase encourages "code reuse by means of copy and paste", which is not a particularly good thing. Just run through UFS code, and grep all the other fs code for comments seen there... This is a sign of not properly abstracted generic functionality. * In BSD, some of the arguments of the readdir handler are there only for the sake of NFS: you have to process them appropriately if you want your filesystem to be NFS exportable. You can ignore them if that's not a concern. fuse4bsd-0.3.9~pre1.20080208/doc/faq.dpl0000644000175000017500000002164311151613006015305 0ustar rmhrmh* FAQ #OPT: id=Faq #Faq <<== I see a new ''/dev/fuseN'' device is created upon each mount of a Fuse based filesytstem. However, I'd like to see the existing one getting reused. == The development version supports device reusal. If you'd like to stay away from the bleeding edge, you can force reusing an existing device by explicitly specifying it, eg. #Verb <<-- mount_fusefs /dev/fuse0 /mnt/fuse foofs -- or #Verb <<-- FUSE_DEV_NAME=/dev/fuse0 foofs /mnt/fuse -- #Faq <<== The filesystem daemon has died for some reason. Can I start a new copy of it as a drop-in replacement? == No. The filesystem hierarchy is stored in the daemon process' memory and it's neither serialized nor appears on a permanent storage. If the daemon dies, the filesystem goes away. No use of keeping it around. #Faq <<== But what if I use a daemon which is "displaying" a stateless filesystem or organizes serialization and permanent storage by itself? == Well, if really that's the case, the daemon should fork a "gatekeeper co-daemon" which keeps the fuse device open and spawns the new daemons on demand. As long as the device is open, the filesystem won't be considered as "doomed". Bug the authors of permanency-capable filesystems if you have such needs or implement it by yourself. #Faq <<== What filesystems? As far as I know, [[http://www.freshports.org/sysutils/fusefs-sshfs/][sshfs]] is the only useable Fuse based "real" filesystem under FreeBSD... == This is just the humble present. Other filesystems should be easy to port to FreeBSD (just a matter of a compilation with proper flags and includes). If a binding for an interpreted languages gets ported, probably a whole bunch of filesystems will be available immediately. Feel free to contribute. See also [[http://fuse.sourceforge.net/wiki/index.php/FileSystemsOnFreeBSD]]. #Faq <<== The daemon has died. Now I can't get rid of the Fuse mount: when I try to unmount the filesystem, the ''umount'' command hangs. == Try unmounting by device name. That is, if you mounted the filesystem as #Verb <<-- mount_fusefs /dev/fuse0 /mnt/fuse foofs -- then do #Verb <<-- umount /dev/fuse0 -- (instead of ''umount /mnt/fuse'') -- this works without asking for assistence from the daemon. If you refused with __Device busy__, then try a forced unmount (add the ''-f'' flag). If unmount still hangs, that means that there is a process which is using the filesystem and is also hanging. Search & destroy such processes and try again. #Faq <<== But do I not need to fear of a forced unmount? Won't my system panic upon doing so? == It definitely should not. However, if it still does, that's a bug. Please drop then a mail to the [[https://creo.hu/mailman/listinfo/fuse4bsd-devel][fuse4bsd-devel]] mailing list with the appropriate description of the case. #Faq <<== How can I find out the name of the Fuse device used by my filesystem and the pid of the daemon? {label: identify} == If you mount with an explicit device name like #Verb <<-- mount_fusefs /dev/fuse0 /mnt/fuse foofs -- then of course you will know the device name (although your mount attempt will be refused if ''/dev/fuse0'' is already in use). In case of "auto" mounts you'll be informed about the device if you mount with ''-v'' like: #Verb <<-- mount_fusefs -v auto /mnt/fuse foofs -- or #Verb <<-- MOUNT_FUSEFS_VERBOSE=1 foofs /mnt/fuse -- When the mount is in place, the [[http://fuse4bsd.creo.hu/localcgi/man-cgi.cgi?mount+8][mount(8)]] utility will give you information how devices correspond to mount paths. If you know the device of your mount, do an #Verb <<-- fstat /dev/fuse* -- to see the users of the fuse devices. See also [[http://fuse4bsd.creo.hu/localcgi/man-cgi.cgi?fstat+1][fstat(1)]]. #Faq <<== Now the contrary. I unmounted a Fuse based filesystem, and the umount has completed cleanly. However, the daemon is still kicking and is occupying the respective Fuse device, and I have to ''kill -9'' it. == You either use an old version of the Fuse library / fuse4bsd or the filesytem in question doesn't make use of the respective standard library routine. Try upgrading to Fuse >= 2.5.0-pre2 and fuse4bsd >= 0.3.0-pre1. #Faq <<== Yet another weirdness upon unmount. The daemon did exit, but uhh... It wasn't a nice death. It dumped core or displayed a strange message like ''Thread 8090600 has exited with leftover thread-specific data after 4 destructor iterations''... == You use an old version of the Fuse library. Try upgrading to Fuse >= 2.5.0-pre2. #Faq <<== So what is this hype about Fuse and non-privileged mounts? == Fuse is designed so that anyone can use it without risking the consistency of the system. That is, a Fuse daemon process is not needed to be trusted. Whatever the daemon is doing, no worse outcome should this have (beyond the daemon's privileges) than a non-functional mount. #Faq <<== How can I enable non-privileged mounts? {label: nonpriv} == Use the standard FreeBSD toolset for this purpose. That is, set the ''vfs.usermount'' sysctl to ''1''. Then find out whom should be able to mount Fuse based filesystems and set the [[http://fuse4bsd.creo.hu/localcgi/man-cgi.cgi?devfs+8][devfs(8)]] rules for ''/dev/fuse*'' appropriately. Eg., letting all users to mount Fuse devices would look like #Verb <<-- devfs ruleset 10 devfs rule add path 'fuse*' mode 666 -- (of course, you can chmod/chown individual Fuse devices, too). According to the default permissions, members of the ''operator'' group are those who can set up Fuse based filesystems. (Ie., only they can do __primary mounts__. Others still can use an already mounted Fuse filesystem via __secondary mounts__, if the filesystem doesn't prohibit this. See {ref: secondary_mount}.) #Faq <<== Does this support of non-privileged mounts mean that I should let everyone mount Fuse filesystems? == No. Your mileage may vary. Noone will say you are a fool if you find non-privileged mounting inconsistent with your system policy. And regarding Fuse, there might be bugs in it, as in any software. Allowing a user to mount Fuse based filesystems will make those bugs exploitable for that user. However, it looks not too much dangerous to allow non privileged mounting of Fuse filesystems. #Faq <<== I do want to make it possible for some users on my system to mount Fuse filesystems, yet I don't want to allow them to mount without restrictions. Is there any way to achieve this? == Yes. Keep the ''vfs.usermount'' sysctl on ''0'', and set the appropriate access policy on the usage of ''mount_fusefs'' as root by [[http://fuse4bsd.creo.hu/localcgi/man-cgi.cgi?sudo+8][sudo(8)]]. Note that you __should not__ put ''mount_fusefs'' into your "sudoers" file as is, as that command is capable of executing an arbitrary command. There are various ways of disabling this feature. Eg., passing a ''-S'' flag to ''mount_fusefs'' will cause it to reject spawning daemons, or specifying a certain daemon (by an absolute pathname) will make it run that specific daemon and nothing else. In general, you are suggested to wrap ''mount_fusefs'' in a script. The command line parsing routine of ''mount_fusefs'' desinged so that it makes scripting easy. #Faq <<== I run mounted a Fuse daemon using my own unprivileged account, and now my wife is in tears because she is prohibited from using the filesystem (which works finely for me). What's happening here? {label: secondary_mount} == If your wife used the filesystem, all her I/O activity directed at the filesystem would be seen and controlled by your daemon process. This shouldn't happen without your wife's agreement, so to stay on the safe side, she will be bluntly refused from using your filesystem. The "agreement" above is not just a metaphor. She can effectively "sign" such an agreement by doing a so-called __secondary mount__ of your filesytem. First she has to find out or be told about device your filesystem is using, say it's ''/dev/fuse0''. Then she can do the secondary mount like #Verb <<-- mount_fusefs /dev/fuse0 /home/kate/lesliefs -- From that on, she will be able to use the filesystem (either via her private mount point or via the original) while the secondary mount is in place. The secondary mount will appear with ''/dev/fuse0#1'' as device name and it should be unmounted via device name like #Verb <<-- umount /dev/fuse0#1 -- (''umount /home/kate/lesliefs'' would be redirected to the primary mount like any query on the secondary mount!) #Faq <<== I want to mount a Fuse daemon such that the mount would be systemwide useable, but I want the daemon running on a low privilege level (like as user ''nobody''). Will then all of my users have to do their own secondary mount before they can use the filesystem? == Not necessarily. Just use the ''allow_other'' mount option (available only for root). fuse4bsd-0.3.9~pre1.20080208/doc/quickstart.dpl0000644000175000017500000002337211151613006016731 0ustar rmhrmh* A quickstart for DIY types #OPT: id=Quickstart Here we will describe how to install manually and try [[http://fuse4bsd.creo.hu][Fuse under FreeBSD]]. There are a lot of Fuse based filesystems -- see http://fuse.sourceforge.net/wiki/index.php/FileSystems. While many of them can be expected to work under FreeBSD as-is or with minor tweaks, here we will concentrate on one specific filesystem, sshfs. See also [[http://fuse.sourceforge.net/wiki/index.php/FileSystemsOnFreeBSD]]. For most users, it is recommended to use the ports instead of using these instructions. Follow these instructions if you want to use a development snapshot or you want to tweak something (eg., port another Fuse based filesystem to FreeBSD), and you are looking for a starting point. Otherwise just install the ''sysutils/fusefs-sshfs'' port. First of all, note that currently you will be able to perform a fully functional installation only on FreeBSD systems from the RELENG_6 or newer branch. (Userspace components can be compiled also on RELENG_5 systems.) ** Get the sources Here we will describe the case when you get all code from their respective SCM repositories. You should use snapshots from not earlier than 17th Nov, 2005. The first Fuse release with FreeBSD support is 2.5.0-pre2, released ad 9th Jan, 2006. - Get fuse and sshfs sources. First login into the Fuse Anoncvs service: #Verb <<-- cvs -d:pserver:anonymous@fuse.cvs.sourceforge.net:/cvsroot/fuse login -- (when you asked for a password, hit enter), then fetch the sources: #Verb <<-- cvs -z3 -d:pserver:anonymous@fuse.cvs.sourceforge.net:/cvsroot/fuse co -P fuse cvs -z3 -d:pserver:anonymous@fuse.cvs.sourceforge.net:/cvsroot/fuse co -P sshfs -- - You have to have the FreeBSD module. - If you read this document as a part of a snapshot of the module, you already have it. - Else if you read it online, you can expect these instructions to work with the latest committed code. Go to http://fuse4bsd.creo.hu and check out the code from your preferred SCM. - Alternatively, you can download a release tarball from http://fuse4bsd.creo.hu and use the version of this document which is bundled with the release. ** Dependencies - sshfs depends on [[http://www.freshports.org/devel/glib20][glib20]] and [[http://www.freshports.org/devel/pkgconfig][pkgconfig]]. - To compile Fuse and sshfs from CVS, you will need to have an up to date installation of the [[http://www.freshports.org/devel/gnu-autoconf][gnu-autoconf]], [[http://www.freshports.org/devel/gnu-automake][gnu-automake]], [[http://www.freshports.org/devel/libtool15][libtool15]] and [[http://www.freshports.org/devel/gettext][gettext]] ports. ** Compilation Each of the subsections below will assume that you are at the top of the respective source tree. The instructions below will assume you use a Bourne compatible shell. We will do a non-privileged installation (I'd say that's easier than set up a jail). Choose your installation path and set the ''FPREFIX'' variable to this value (be it an absolute path). We will assume that you have put all three source trees in the same directory, and their top directories are named ''fuse'', ''sshfs'', and ''fuse4bsd'', respectively. *** Library (Fuse) - As CVS snapshots don't ship with pre-generated instances of autotools related files, you have to generate them. Do it with #Verb <<-- ln -sf /usr/local/share/aclocal/libtool.m4 . && ln -sfv `pkg_info -L 'gettext*' | grep /usr/local/share/aclocal/` . && (export PATH=/usr/local/gnu-autotools/bin:$PATH && libtoolize && aclocal -I . && autoheader && autoconf && automake -a) -- - Install fuse with #Verb <<-- ln -sf ../kernel/fuse_kernel.h include/ && ./configure --prefix=$FPREFIX --with-pkgconfigdir=$FPREFIX/libdata/pkgconfig && make && make install -- (The pkgconfigdir setting is not necessary, it's just for making the installation more "BSDish".) *** \SshFs - Generate autotools files with #Verb <<-- ln -sf /usr/local/share/aclocal/pkg.m4 . && (export PATH=/usr/local/gnu-autotools/bin:$PATH && aclocal -I . && autoheader && autoconf && automake -a) -- - Type #Verb <<-- PKG_CONFIG_PATH=$FPREFIX/libdata/pkgconfig/ ./configure && make -- *** Kernel module - Copy (or link) the ''kernel/fuse_kernel.h'' file of the Fuse source tree into the ''fuse_module'' directory. - Type ''make''. If you want normal quantity of debug output (currently in the form of kernel messages), add ''DEBUG2G=1'' to ''make'''s environment, if you want tons of debug output, add''DEBUG=1'' to the environment. You might want / need to make the module make use of the features enabled in your kernel config (like support for diagnostic tools like ''INVARIANTS'', ''WITNESS''). (You do need it, eg., if you enabled ''DEBUG_LOCKS'' which affects binary compatibility.) To make this happen, the simplest solution is adding a ''KERNCONF='' parameter to your ''make'' arguments. This will work only if you used standard locations when you compiled the kernel. If that's not the case, you can use the ''KERNCONFDIR'' parameter to explicitly specify the location of the config headers. For the currently running kernel this should be the path seen in the output of ''uname -v''. Congratulations, you have all components prepared! ** Using the Fuse based ssh filesystem Here we will show how to setup Fuse so that non-privileged users can use it, too (although it's up to you if you want this). As the superuser, do #Verb <<-- kldload fuse_module/fuse.ko sysctl vfs.usermount=1 -- You'll have to act as a user belonging to the ''operator'' group, or set device permissions appropriately (cf. {ref: nonpriv}). Pick your favourite ssh accessible account, say, it's ''foo@bar.baz''. Go to sshfs' directory. First prepare the mount: #Verb <<-- mkdir -p ~/fuse && export LD_LIBRARY_PATH=$FPREFIX/lib/ export PATH=$FPREFIX/bin:$PATH -- Now you can activate the filesystem with: #Verb <<-- ./sshfs foo@bar.baz: ~/fuse -- This will start up the filesystem daemon, who will mount the home directory of the "foo" account at ''bar.baz'' on ''~/fuse'' (using ''mount_fusefs''). You can get it done vice versa, so that ''mount_fusefs'' will spawn the daemon: #Verb <<-- mount_fusefs auto ~/fuse ./sshfs foo@bar.baz: -- Here is also a more customized example: #Verb <<-- MOUNT_FUSEFS_VERBOSE=1 \ ./sshfs -o push_symlinks_in,idmap=user,reconnect -C foo@bar.baz:/ ~/fuse -- If it failed to work for some reason, you can perform the steps of mounting the filesystem manually by yourself. Eg., first type #Verb <<-- FUSE_DEV_NAME=/dev/fuse0 ./sshfs foo@bar.baz: -d -- and then on another terminal: #Verb <<-- mount_fusefs /dev/fuse0 ~/fuse -- (This will work only if the device ''/dev/fuse0'' is not yet in use.) When you have finished using the filesystem, there are several ways of taking it down. For example, you can simply #Verb <<-- umount ~/fuse -- However, for this to work, you need the filesystem daemon operating properly. Unmounting by device doesn't rely on the daemon, so the following is more robust (assuming you mounted the device ''/dev/fuse0''): #Verb <<-- umount /dev/fuse0 -- Or you can kill the daemon (cf. [[http://fuse4bsd.creo.hu/localcgi/man-cgi.cgi?kill+1][kill(1)]]). Just before she exits, she will unmount the filesystem. For finding out these parameters of a Fuse mount, see {ref: identify}. For more details on mounting, see [[http://fuse4bsd.creo.hu/localcgi/man-cgi.cgi?mount_fusefs+8][mount_fusefs(8)]]. ** Note on other filesystems The above instructions will help you to try using other Fuse based filesystems on FreeBSD, but there is one issue you should be aware of. The Fuse library API has went through several revisions. Currently the library maintains backward compatibility on Linux, but Fuse author Miklós Szeredi decided to support FreeBSD only starting with API revision 25 (not without reason: this is the first API revision which utilizes only POSIX/SUSV3 compatible interfaces, therefore alleviates platform dependecy issues filesystem authors have to face with). For more information about the backward compatibility issue and the way of updating filesystems see the mailing list subthread starting from http://thread.gmane.org/gmane.comp.file-systems.fuse.devel/2310 and subsequent posts. To cut the story short, your statfs method will have to be converted from using ''struct statfs'' to using ''struct statvfs'' (and take care about filling its ''f_frsize'' field). In most cases (ie., if your filesystem was using API 22) this will be enough, although it might be worth to take a look at the new feaures of API 25. (Note that API 23 and 24 just brought in extensions, so API 22 is a strict subset of these, with no compatibility issues.) An overview of the API revisions of the Fuse library can be found at [[http://fuse.sourceforge.net/wiki/index.php/ApiChangelog]]. Also see the following posts, with concrete examples of patches for (quick'n'dirty) API upgrade: - Updating Fuse Perl bindings (from API 21): http://creo.hu/pipermail/fuse4bsd-devel/2006-January/000117.html - Updating Fuse Python bindings (from API 21): http://sourceforge.net/mailarchive/message.php?msg_id=15029223 - Updating Tdfs (from API 22): http://creo.hu/pipermail/fuse4bsd-devel/2006-January/000116.html A more carefully coded example is provided by [[http://fuse.sourceforge.net/wiki/index.php/FusePython][Fuse Python bindings]] (after its resurrection in May-Jun 2006). Currently it supports all APIs from 22 to 26. It's the suggested reference for getting around API compatibility problems. ** Bugs See the respective section of [[http://fuse4bsd.creo.hu/localcgi/man-cgi.cgi?mount_fusefs+8][mount_fusefs(8)]]. fuse4bsd-0.3.9~pre1.20080208/doc/doc.dpl0000644000175000017500000000565311151613006015306 0ustar rmhrmh%#VAR: css=tabbar-top.css|screen article.css|print +serif.css %#VAR: headings=plain autoFileNames! %#VAR: urlIcon=remote.png mailtoIcon=mailto.png %#VAR: baseUrl=http://fuse4bsd.creo.hu/ baseUrlStripDir=1 %#VAR: tabBarPos=top tabEqualWidths! noTabBarButtons! tabBarHomeName=About #VAR: obfuscatedNoscriptAt=" V O N " #VAR: obfuscatedNoscriptDot=" P U N K T " #Ruby <<--- class Deplate::Formatter def format_faq *a a[0].elt = format_emphasize a[0], a[0].elt format_paragraph *a end end class Deplate::Regions::FaqEntry < Deplate::Region register_as 'FaqEntry' register_as 'Faq' set_formatter :format_faq set_line_cont false @cou = 0 class << self attr_accessor :cou end def setup *a super self.class.cou += 1 @faqlabel = args["label"] @faqlabel ||= "faq#{self.class.cou}" #@noindent = true @auto = 1 end def process rv = super @deplate.add_label(self, @faqlabel, @level_as_string, :container => @container) @elt = [@deplate.formatter.format_particle(:format_label, self, :string, [@faqlabel]), @elt].join(" ") return rv end end --- #TITLE: "Fuse for FreeBSD" documentation %#AUTHOR: %#AUTHORNOTE: #DATE: today %#VAR: keywords=Converter, Text, LaTeX, HTML, Docbook, Wiki, \ %Presentation, Web Publishing %#VAR: noObfuscatedNoscript! #VAR: floatCaptionAbove! #VAR fmt=latex: codeStyle=typical #VAR fmt=~html: codeStyle=tomacs #VAR fmt=~htmls: nextKey=0 baseUrl=http://deplate.sourceforge.net/ baseUrlStripDir=1 % Use QBullets [[http://www.matterform.com/]] % #VAR: urlIcon=remote.gif mailtoIcon=mailto.gif % #IF: pdf! % #VAR: urlIcon=remote.pdf mailtoIcon=mailto.pdf % #ELSE #VAR: urlIcon=remote.png mailtoIcon=mailto.png % #ENDIF #Var if=sgml id=dbkEntities: %ISOgrk3; #End #IF: manual #VAR: css=deplate.css|screen article.css|print +serif.css +heading-navbar.css #ELSE #VAR: css=tabbar-right.css|screen article.css|print +serif.css #ENDIF % #VAR: useBooktabs! %#VAR: autoindex! buttonsColour=grey #VAR: buttonsColour=grey #VAR: refentry=deplate copyrightYear=2004 #IF: fmt==latex #VAR: encoding=latin9 #ELSE #VAR: encoding=latin-1 #ENDIF % #VAR: noCssValid! %#AUTOIDX: deplate %#IF: manPage!=1 #Native fmt=html if=sfNet type=post slot=html_pageicons <<--- deplate Logo --- #MAKETITLE #LIST: contents %#LIST: tables %#LIST: figures #IF: fmt=~htmls #XARG: navigation_note() % #XARG: navigation_note(nextKey=shift) % #XARG: tabBarNote() #ENDIF %#ENDIF: no manPage % If we compile a man page, we include this chapter only %#IF: manPage!=1 #INCLUDE: quickstart.dpl #INCLUDE: faq.dpl #INCLUDE: implementation.dpl %#MAKEBIB id=TheBibliography shortcaption=Bibliography: cbib-apa-1 %#LIST id=TheIndex shortcaption=Index: index %#ENDIF: no manPage fuse4bsd-0.3.9~pre1.20080208/doc/Makefile0000644000175000017500000000530611151613006015473 0ustar rmhrmhBASE=doc FILE=doc.dpl #OTHER= #CSS=--copy-css deplate --copy-css article --copy-css serif \ # --copy-css heading-navbar --copy-css tabbar-right DEPLATEDIR=. DEPLATE=env RUBYLIB=${DEPLATEDIR}/lib RUBYPATH=${DEPLATEDIR}/lib ruby -S deplate.rb DFLAGS=-x #DFLAGS_DBK= DFLAGS_REF=-X -m symbols-plain -D manPage=1 #DFLAGS_HTML_SINGLE=${CSS} -X -D manual -m html-headings-navbar -m code-gvim \ # -D headingsNavbarMaxLevel=2 -m mark-external-urls DFLAGS_HTML_SINGLE=${CSS} -X -D manual -m mark-external-urls DFLAGS_HTML_CHUNKED=${CSS} -X -t html-tabbar-right.html -m mark-external-urls \ -m navbar-png -m validate-html -m html-obfuscate-email \ -m code-gvim -D noSwallow=1 -D sfNet=1 #DFLAGS_PHP= DFLAGS_TEX=--pdf -m latex-emph-table-head -m latex-verbatim-small -X DFLAGS_TEXT=-D manual #FMT_DBK=dbk-article FMT_HTML_SINGLE=html FMT_HTML_CHUNKED=htmlsite FMT_LATEX=latex #FMT_PHP=phpsite FMT_PLAIN=plain #FMT_REF=dbk-ref DESTDIR= . REALDESTDIR!= realpath ${DESTDIR} #PHONY: html #dvi: ${BASE}.dvi #html: ${BASE}.html #pdf: ${BASE}.pdf #php: ${BASE}.php #tex: ${BASE}.tex #text: ${BASE}.asc #man: ${BASE}.1 default: @echo "No default target. Available targets:" @echo "html_chunked html_single plaintext pdf all" all: html_chunked html_single plaintext pdf html_chunked: mkdir -p ${DESTDIR}/html_chunked_out cp html_aux/* ${DESTDIR}/html_chunked_out ${DEPLATE} ${DFLAGS} ${DFLAGS_HTML_CHUNKED} -f ${FMT_HTML_CHUNKED} -d ${REALDESTDIR}/html_chunked_out ${FILE} ${OTHER} html_single: mkdir -p ${DESTDIR}/html_single_out cp html_aux/* ${DESTDIR}/html_single_out ${DEPLATE} ${DFLAGS} ${DFLAGS_HTML_SINGLE} -f ${FMT_HTML_SINGLE} -d ${REALDESTDIR}/html_single_out ${FILE} ${OTHER} plaintext: mkdir -p ${DESTDIR}/plaintext_out ${DEPLATE} ${DFLAGS} ${DFLAGS_TEXT} -f ${FMT_PLAIN} -d ${REALDESTDIR}/plaintext_out ${FILE} ${OTHER} pdf: mkdir -p ${DESTDIR}/pdf_out ${DEPLATE} ${DFLAGS} ${DFLAGS_TEX} -f ${FMT_LATEX} -d ${REALDESTDIR}/pdf_out ${FILE} ${OTHER} sh -xc "cd ${DESTDIR}/pdf_out && pdflatex ${BASE}.tex && pdflatex ${BASE}.tex" #%.html: %.txt # ${DEPLATE} ${DFLAGS} ${DFLAGS_HTML} -f ${FMT_HTML} $< ${OTHER} # #%.asc: %.txt # ${DEPLATE} ${DFLAGS} ${DFLAGS_TEXT} -f ${FMT_PLAIN} -o $@ $< ${OTHER} # #%.php: %.txt # ${DEPLATE} ${DFLAGS} ${DFLAGS_TEXT} -f ${FMT_PHP} $< ${OTHER} # #%.dbk: %.txt # ${DEPLATE} ${DFLAGS} ${DFLAGS_DBK} -f ${FMT_DBK} $< ${OTHER} # #%.tex: %.txt # ${DEPLATE} ${DFLAGS} ${DFLAGS_TEX} -f ${FMT_LATEX} $< ${OTHER} # #%.ref: %.txt # ${DEPLATE} ${DFLAGS} ${DFLAGS_REF} -f ${FMT_REF} -o $@ $< ${OTHER} # #%.dvi: %.tex # latex $< # bibtex $* # latex $< # latex $< # #%.pdf: %.tex # pdflatex $< # bibtex $* # pdflatex $< # pdflatex $< # #%.1: %.ref # xmlto man $< clean: rm -rf ${DESTDIR}/*_out/ fuse4bsd-0.3.9~pre1.20080208/doc/README0000644000175000017500000000163111151613006014710 0ustar rmhrmhThe documentation is written in the Deplate markup language (http://deplate.sourceforge.net). This is a non-obstrusive format, so you can read the deplate files right away as they are: - quickstart.dpl - faq.dpl - implementation.dpl (doc.dpl is the master file, used only for rendering the documentation into various formats). The documentation can be rendered using the deplate tool. If you want to do this by youself, you need the Ruby interpreter, and the CVS version of Deplate, see http://deplate.sourceforge.net/Development.php You can then compile the docs by make DEPLATEDIR= [DESTIR=whatever] where target can be one of the following: - html_chunked - html_single - plaintext - pdf - all The documentation rendered into a given format can be found then in the _out subdirectories. Look for them in hope of pre-rendered documentation. fuse4bsd-0.3.9~pre1.20080208/COPYRIGHT0000644000175000017500000000236611151613006014564 0ustar rmhrmhCopyright (C) 2005 Csaba Henk. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.