13 our @ISA = qw(Exporter DynaLoader);
15 # Items to export into callers namespace by default. Note: do not export
16 # names by default without a very good reason. Use EXPORT_OK instead.
17 # Do not simply export all your public functions/methods/constants.
19 # This allows declaration use Fuse ':all';
20 # If you do not need this, moving things directly into @EXPORT or @EXPORT_OK
23 'all' => [ qw(XATTR_CREATE XATTR_REPLACE fuse_get_context fuse_version FUSE_IOCTL_COMPAT FUSE_IOCTL_UNRESTRICTED FUSE_IOCTL_RETRY FUSE_IOCTL_MAX_IOV) ],
24 'xattr' => [ qw(XATTR_CREATE XATTR_REPLACE) ],
25 'ioctl' => [ qw(FUSE_IOCTL_COMPAT FUSE_IOCTL_UNRESTRICTED FUSE_IOCTL_RETRY FUSE_IOCTL_MAX_IOV) ],
28 our @EXPORT_OK = ( @{ $EXPORT_TAGS{'all'} } );
31 our $VERSION = '0.14';
34 # This AUTOLOAD is used to 'autoload' constants from the constant()
35 # XS function. If a constant is not found then control is passed
36 # to the AUTOLOAD in AutoLoader.
40 ($constname = $AUTOLOAD) =~ s/.*:://;
41 croak "& not defined" if $constname eq 'constant';
42 my $val = constant($constname, @_ ? $_[0] : 0);
45 $AutoLoader::AUTOLOAD = $AUTOLOAD;
46 goto &AutoLoader::AUTOLOAD;
49 croak "Your vendor has not defined Fuse macro $constname";
54 # Fixed between 5.005_53 and 5.005_61
56 *$AUTOLOAD = sub () { $val };
59 *$AUTOLOAD = sub { $val };
65 bootstrap Fuse $VERSION;
67 if (fuse_version() >= 2.8) {
68 push(@{$EXPORT_TAGS{'all'}}, qw(notify_poll pollhandle_destroy));
71 use constant FUSE_IOCTL_COMPAT => (1 << 0);
72 use constant FUSE_IOCTL_UNRESTRICTED => (1 << 1);
73 use constant FUSE_IOCTL_RETRY => (1 << 2);
74 use constant FUSE_IOCTL_MAX_IOV => 256;
77 my @names = qw(getattr readlink getdir mknod mkdir unlink rmdir symlink
78 rename link chmod chown truncate utime open read write statfs
79 flush release fsync setxattr getxattr listxattr removexattr);
80 my $fuse_version = fuse_version();
81 if ($fuse_version >= 2.3) {
82 push(@names, qw/opendir readdir releasedir fsyncdir init destroy/);
84 if ($fuse_version >= 2.5) {
85 push(@names, qw/access create ftruncate fgetattr/);
87 if ($fuse_version >= 2.6) {
88 push(@names, qw/lock utimens bmap/);
90 if ($fuse_version >= 2.8) {
91 # junk doesn't contain a function pointer, and hopefully
92 # never will; it's a "dead" zone in the struct
93 # fuse_operations where a flag bit is declared. we don't
94 # need to concern ourselves with it, and it appears any
95 # arch with a 64 bit pointer will align everything to
96 # 8 bytes, making the question of pointer alignment for
97 # the last 2 wrapper functions no big thing.
98 push(@names, qw/junk ioctl poll/);
100 my @subs = map {undef} @names;
102 my %mapping = map { $_ => $tmp++ } @names;
103 my @otherargs = qw(debug threaded mountpoint mountopts nullpath_ok);
111 while(my $name = shift) {
112 my ($subref) = shift;
113 if(exists($otherargs{$name})) {
114 $otherargs{$name} = $subref;
116 croak "There is no function $name" unless exists($mapping{$name});
117 croak "Usage: Fuse::main(getattr => \"main::my_getattr\", ...)" unless $subref;
118 $subs[$mapping{$name}] = $subref;
121 if($otherargs{threaded}) {
122 # make sure threads are both available, and loaded.
123 if($Config{useithreads}) {
124 if(exists($threads::{VERSION})) {
125 if(exists($threads::shared::{VERSION})) {
128 carp("Thread support requires you to use threads::shared.\nThreads are disabled.\n");
129 $otherargs{threaded} = 0;
132 carp("Thread support requires you to use threads and threads::shared.\nThreads are disabled.\n");
133 $otherargs{threaded} = 0;
136 carp("Thread support was not compiled into this build of perl.\nThreads are disabled.\n");
137 $otherargs{threaded} = 0;
140 perl_fuse_main(@otherargs{@otherargs},@subs);
143 # Autoload methods go after =cut, and are processed by the autosplit program.
150 Fuse - write filesystems in Perl using FUSE
155 my ($mountpoint) = "";
156 $mountpoint = shift(@ARGV) if @ARGV;
157 Fuse::main(mountpoint=>$mountpoint, getattr=>"main::my_getattr", getdir=>"main::my_getdir", ...);
161 This lets you implement filesystems in perl, through the FUSE
162 (Filesystem in USErspace) kernel/lib interface.
164 FUSE expects you to implement callbacks for the various functions.
166 In the following definitions, "errno" can be 0 (for a success),
167 -EINVAL, -ENOENT, -EONFIRE, any integer less than 1 really.
169 You can import standard error constants by saying something like
170 "use POSIX qw(EDOTDOT ENOANO);".
172 Every constant you need (file types, open() flags, error values,
173 etc) can be imported either from POSIX or from Fcntl, often both.
174 See their respective documentations, for more information.
176 =head2 EXPORTED SYMBOLS
180 You can request all exportable symbols by using the tag ":all".
182 You can request the extended attribute symbols by using the tag ":xattr".
183 This will export XATTR_CREATE and XATTR_REPLACE.
189 Takes arguments in the form of hash key=>value pairs. There are
190 many valid keys. Most of them correspond with names of callback
191 functions, as described in section 'FUNCTIONS YOUR FILESYSTEM MAY IMPLEMENT'.
192 A few special keys also exist:
199 This turns FUSE call tracing on and off. Default is 0 (which means off).
207 The point at which to mount this filesystem. There is no default, you must
208 specify this. An example would be '/mnt'.
216 This is a comma seperated list of mount options to pass to the FUSE kernel
219 At present, it allows the specification of the allow_other
220 argument when mounting the new FUSE filesystem. To use this, you will also
221 need 'user_allow_other' in /etc/fuse.conf as per the FUSE documention
223 mountopts => "allow_other" or
232 This turns FUSE multithreading on and off. The default is 0, meaning your FUSE
233 script will run in single-threaded mode. Note that single-threaded mode also
234 means that you will not have to worry about reentrancy, though you will have to
235 worry about recursive lookups. In single-threaded mode, FUSE holds a global
236 lock on your filesystem, and will wait for one callback to return before
237 calling another. This can lead to deadlocks, if your script makes any attempt
238 to access files or directories in the filesystem it is providing. (This
239 includes calling stat() on the mount-point, statfs() calls from the 'df'
240 command, and so on and so forth.) It is worth paying a little attention and
241 being careful about this.
243 Enabling multithreading will cause FUSE to make multiple simultaneous calls
244 into the various callback functions of your perl script. If you enable
245 threaded mode, you can enjoy all the parallel execution and interactive
246 response benefits of threads, and you get to enjoy all the benefits of race
247 conditions and locking bugs, too. Please also ensure any other perl modules
248 you're using are also thread-safe.
250 (If enabled, this option will cause a warning if your perl interpreter was not
251 built with USE_ITHREADS, or if you have failed to use threads or
256 nullpath_ok => boolean
260 This flag tells Fuse to not pass paths for functions that operate on file
261 or directory handles. This will yield empty path parameters for functions
262 including read, write, flush, release, fsync, readdir, releasedir,
263 fsyncdir, truncate, fgetattr and lock. If you use this, you must return
264 file/directory handles from open, opendir and create. Default is 0 (off).
265 Only effective on Fuse 2.8 and up; with earlier versions, this does nothing.
269 =head3 Fuse::fuse_get_context
271 use Fuse "fuse_get_context";
272 my $caller_uid = fuse_get_context()->{"uid"};
273 my $caller_gid = fuse_get_context()->{"gid"};
274 my $caller_pid = fuse_get_context()->{"pid"};
276 Access context information about the current Fuse operation.
278 =head3 Fuse::fuse_version
280 Indicates the Fuse version in use; more accurately, indicates the version
281 of the Fuse API in use at build time. Returned as a decimal value; i.e.,
282 for Fuse API v2.6, will return "2.6".
284 =head3 Fuse::notify_poll
286 Only available if the Fuse module is built against libfuse 2.8 or later.
287 Use fuse_version() to determine if this is the case. Calling this function
288 with a pollhandle argument (as provided to the C<poll> operation
289 implementation) will send a notification to the caller poll()ing for
290 I/O operation availability. If more than one pollhandle is provided for
291 the same filehandle, only use the latest; you *can* send notifications
292 to them all, but it is unnecessary and decreases performance.
294 ONLY supply poll handles fed to you through C<poll> to this function.
295 Due to thread safety requirements, we can't currently package the pointer
296 up in an object the way we'd like to to prevent this situation, but your
297 filesystem server program may segfault, or worse, if you feed things to
298 this function which it is not supposed to receive. If you do anyway, we
299 take no responsibility for whatever Bad Things(tm) may happen.
301 =head3 Fuse::pollhandle_destroy
303 Only available if the Fuse module is built against libfuse 2.8 or later.
304 Use fuse_version() to determine if this is the case. This function destroys
305 a poll handle (fed to your program through C<poll>). When you are done
306 with a poll handle, either because it has been replaced, or because a
307 notification has been sent to it, pass it to this function to dispose of
310 ONLY supply poll handles fed to you through C<poll> to this function.
311 Due to thread safety requirements, we can't currently package the pointer
312 up in an object the way we'd like to to prevent this situation, but your
313 filesystem server program may segfault, or worse, if you feed things to
314 this function which it is not supposed to receive. If you do anyway, we
315 take no responsibility for whatever Bad Things(tm) may happen.
317 =head2 FUNCTIONS YOUR FILESYSTEM MAY IMPLEMENT
323 Returns a list, very similar to the 'stat' function (see
324 perlfunc). On error, simply return a single numeric scalar
325 value (e.g. "return -ENOENT();").
327 FIXME: the "ino" field is currently ignored. I tried setting it to 0
328 in an example script, which consistently caused segfaults.
330 Fields (the following was stolen from perlfunc(1) with apologies):
332 ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
333 $atime,$mtime,$ctime,$blksize,$blocks)
334 = getattr($filename);
336 Here are the meaning of the fields:
338 0 dev device number of filesystem
340 2 mode file mode (type and permissions)
341 3 nlink number of (hard) links to the file
342 4 uid numeric user ID of file's owner
343 5 gid numeric group ID of file's owner
344 6 rdev the device identifier (special files only)
345 7 size total size of file, in bytes
346 8 atime last access time in seconds since the epoch
347 9 mtime last modify time in seconds since the epoch
348 10 ctime inode change time (NOT creation time!) in seconds
350 11 blksize preferred block size for file system I/O
351 12 blocks actual number of blocks allocated
353 (The epoch was at 00:00 January 1, 1970 GMT.)
357 Arguments: link pathname.
359 Returns a scalar: either a numeric constant, or a text string.
361 This is called when dereferencing symbolic links, to learn the target.
363 example rv: return "/proc/self/fd/stdin";
367 Arguments: Containing directory name.
369 Returns a list: 0 or more text strings (the filenames), followed by a numeric errno (usually 0).
371 This is used to obtain directory listings. It's opendir(), readdir(), filldir() and closedir() all in one call.
373 example rv: return ('.', 'a', 'b', 0);
377 Arguments: Filename, numeric modes, numeric device
379 Returns an errno (0 upon success, as usual).
381 This function is called for all non-directory, non-symlink nodes,
386 Arguments: New directory pathname, numeric modes.
390 Called to create a directory.
398 Called to remove a file, device, or symlink.
406 Called to remove a directory.
410 Arguments: Existing filename, symlink name.
414 Called to create a symbolic link.
418 Arguments: old filename, new filename.
422 Called to rename a file, and/or move a file from one directory to another.
426 Arguments: Existing filename, hardlink name.
430 Called to create hard links.
434 Arguments: Pathname, numeric modes.
438 Called to change permissions on a file/directory/device/symlink.
442 Arguments: Pathname, numeric uid, numeric gid.
446 Called to change ownership of a file/directory/device/symlink.
450 Arguments: Pathname, numeric offset.
454 Called to truncate a file, at the given offset.
458 Arguments: Pathname, numeric actime, numeric modtime.
462 Called to change access/modification times for a file/directory/device/symlink.
466 Arguments: Pathname, numeric flags (which is an OR-ing of stuff like O_RDONLY
467 and O_SYNC, constants you can import from POSIX), fileinfo hash reference.
469 Returns an errno, a file handle (optional).
471 No creation, or trunctation flags (O_CREAT, O_EXCL, O_TRUNC) will be passed to open().
472 The fileinfo hash reference contains flags from the Fuse open call which may be modified by the module. The only fields presently supported are:
473 direct_io (version 2.4 onwards)
474 keep_cache (version 2.4 onwards)
475 nonseekable (version 2.9 onwards)
476 Your open() method needs only check if the operation is permitted for the given flags, and return 0 for success.
477 Optionally a file handle may be returned, which will be passed to subsequent read, write, flush, fsync and release calls.
481 Arguments: Pathname, numeric requested size, numeric offset, file handle
483 Returns a numeric errno, or a string scalar with up to $requestedsize bytes of data.
485 Called in an attempt to fetch a portion of the file.
489 Arguments: Pathname, scalar buffer, numeric offset, file handle. You can use length($buffer) to
491 Returns length($buffer) if successful (number of bytes written).
493 Called in an attempt to write (or overwrite) a portion of the file. Be prepared because $buffer could contain random binary data with NULs and all sorts of other wonderful stuff.
499 Returns any of the following:
505 $namelen, $files, $files_free, $blocks, $blocks_avail, $blocksize
509 -ENOANO(), $namelen, $files, $files_free, $blocks, $blocks_avail, $blocksize
513 Arguments: Pathname, file handle
515 Returns an errno or 0 on success.
517 Called to synchronise any cached data. This is called before the file
518 is closed. It may be called multiple times before a file is closed.
522 Arguments: Pathname, numeric flags passed to open, file handle
523 Returns an errno or 0 on success.
525 Called to indicate that there are no more references to the file. Called once
526 for every file with the same pathname and flags as were passed to open.
530 Arguments: Pathname, numeric flags
532 Returns an errno or 0 on success.
534 Called to synchronise the file's contents. If flags is non-zero,
535 only synchronise the user data. Otherwise synchronise the user and meta data.
539 Arguments: Pathname, extended attribute's name, extended attribute's value, numeric flags (which is an OR-ing of XATTR_CREATE and XATTR_REPLACE
541 Returns an errno or 0 on success.
543 Called to set the value of the named extended attribute.
545 If you wish to reject setting of a particular form of extended attribute name
546 (e.g.: regexps matching user\..* or security\..*), then return - EOPNOTSUPP.
548 If flags is set to XATTR_CREATE and the extended attribute already exists,
549 this should fail with - EEXIST. If flags is set to XATTR_REPLACE
550 and the extended attribute doesn't exist, this should fail with - ENOATTR.
552 XATTR_CREATE and XATTR_REPLACE are provided by this module, but not exported
553 by default. To import them:
563 Arguments: Pathname, extended attribute's name
565 Returns an errno, 0 if there was no value, or the extended attribute's value.
567 Called to get the value of the named extended attribute.
573 Returns a list: 0 or more text strings (the extended attribute names), followed by a numeric errno (usually 0).
577 Arguments: Pathname, extended attribute's name
579 Returns an errno or 0 on success.
583 Arguments: Pathname of a directory
584 Returns an errno, and a directory handle (optional)
586 Called when opening a directory for reading. If special handling is
587 required to open a directory, this operation can be implemented to handle
592 Arguments: Pathname of a directory, numeric offset, (optional) directory handle
594 Returns a list of 0 or more entries, followed by a numeric errno (usually 0).
595 The entries can be simple strings (filenames), or arrays containing an
596 offset number, the filename, and optionally an array ref containing the
597 stat values (as would be returned from getattr()).
599 This is used to read entries from a directory. It can be used to return just
600 entry names like getdir(), or can get a segment of the available entries,
601 which requires using array refs and the 2- or 3-item form, with offset values
602 starting from 1. If you wish to return the parameters to fill each entry's
603 struct stat, but do not wish to do partial entry lists/entry counting, set
604 the first element of each array to 0 always.
606 Note that if this call is implemented, it overrides getdir() ALWAYS.
610 Arguments: Pathname of a directory, (optional) directory handle
612 Returns an errno or 0 on success
614 Called when there are no more references to an opened directory. Called once
615 for each pathname or handle passed to opendir(). Similar to release(), but
616 for directories. Accepts a return value, but like release(), the response
617 code will not propagate to any corresponding closedir() calls.
621 Arguments: Pathname of a directory, numeric flags, (optional) directory handle
623 Returns an errno or 0 on success.
625 Called to synchronize any changes to a directory's contents. If flag is
626 non-zero, only synchronize user data, otherwise synchronize user data and
633 Returns (optionally) an SV to be passed as private_data via fuse_get_context().
637 Arguments: (optional) private data SV returned from init(), if any.
643 Arguments: Pathname, access mode flags
645 Returns an errno or 0 on success.
647 Determine if the user attempting to access the indicated file has access to
648 perform the requested actions. The user ID can be determined by calling
649 fuse_get_context(). See access(2) for more information.
653 Arguments: Pathname, create mask, open mode flags
655 Returns errno or 0 on success, and (optional) file handle.
657 Create a file with the path indicated, then open a handle for reading and/or
658 writing with the supplied mode flags. Can also return a file handle like
659 open() as part of the call.
663 Arguments: Pathname, numeric offset, (optional) file handle
665 Returns errno or 0 on success
667 Like truncate(), but on an opened file.
671 Arguments: Pathname, (optional) file handle
673 Returns a list, very similar to the 'stat' function (see
674 perlfunc). On error, simply return a single numeric scalar
675 value (e.g. "return -ENOENT();").
677 Like getattr(), but on an opened file.
681 Arguments: Pathname, numeric command code, hashref containing lock parameters, (optional) file handle
683 Returns errno or 0 on success
685 Used to lock or unlock regions of a file. Locking is handled locally, but this
686 allows (especially for networked file systems) for protocol-level locking
687 semantics to also be employed, if any are available.
689 See the Fuse documentation for more explanation of lock(). The needed symbols
690 for the lock constants can be obtained by importing Fcntl.
694 Arguments: Pathname, last accessed time, last modified time
696 Returns errno or 0 on success
698 Like utime(), but allows time resolution down to the nanosecond. Currently
699 times are passed as "numeric" (internally I believe these are represented
700 typically as "long double"), so the sub-second portion is represented as
701 fractions of a second.
703 Note that if this call is implemented, it overrides utime() ALWAYS.
707 Arguments: Pathname, numeric blocksize, numeric block number
709 Returns errno or 0 on success, and physical block number if successful
711 Used to map a block number offset in a file to the physical block offset
712 on the block device backing the file system. This is intended for
713 filesystems that are stored on an actual block device, with the 'blkdev'
718 Arguments: Pathname, (signed) ioctl command code, flags, data if ioctl op is a write, (optional) file handle
720 Returns errno or 0 on success, and data if ioctl op is a read
722 Used to handle ioctl() operations on files. See ioctl(2) for more
723 information on the fine details of ioctl operation numbers. May need to
724 h2ph system headers to get the necessary macros; keep in mind the macros
725 are highly OS-dependent.
727 Keep in mind that read and write are from the client perspective, so
728 read from our end means data is going *out*, and write means data is
729 coming *in*. It can be slightly confusing.
733 Arguments: Pathname, poll handle ID (or undef if none), event mask, (optional) file handle
735 Returns errno or 0 on success, and updated event mask on success
737 Used to handle poll() operations on files. See poll(2) to learn more about
738 event polling. Use IO::Poll to get the POLLIN, POLLOUT, and other symbols
739 to describe the events which can happen on the filehandle. Save the poll
740 handle ID to be passed to C<notify_poll> and C<pollhandle_destroy>
741 functions, if it is not undef. Threading will likely be necessary for this
744 There is not an "out of band" data transfer channel provided as part of
745 FUSE, so POLLPRI/POLLRDBAND/POLLWRBAND won't work.
747 Poll handle is currently a read-only scalar; we are investigating a way
748 to make this an object instead.
752 Mark Glines, E<lt>mark@glines.orgE<gt>
756 L<perl>, the FUSE documentation.