MacFUSE

Licence: BSD License
Version 2.2.1 | Release Date: 2011-07-22 | Download

Officially version 2.2, it is 2.2 for 10.4 Tiger, and 2.2.1 for 10.5 Leopard, 10.6 Snow Leopard, and 10.7 Lion.

Version 2.1.7 | Release Date: 2010-11-13 | Download

Fixed the issue that cause the "load failed for extension fusefs.kext" error

Fixes issues with 64-bit compatibility.

Version 2.1.5 | Release Date: 2009-02-03 | Download

Snow Leopard support. This is a developer beta release.

Version 2.0.3,2 | Release Date: 2008-12-21 | Download

None (this is just a version number correction - iusethis.com currently lists the version as 2.0.3 when it should say 2.0.3,2)

Version 2.0.3 | Release Date: 2008-12-21 | Download
No changes specified
Version 2.0.3,2 | Release Date: 2008-12-19 | Download
No changes specified
Version 2.0 | Release Date: 2008-12-09 | Download
  • Feature: MacFUSE Preference Pane. Makes it easy and straightforward to keep up-to-date with MacFUSE releases, with the user in full control.
  • Feature: 64-Bit Support. The entire MacFUSE software stack: the kernel extension, the MacFUSE user-space C library, and the Objective-C framework now also come in 64-bit versions. You must be running Leopard or above for this. Naturally, you also need 64-bit hardware to make use of these capabilities. [Experimental]
  • Feature: Support for Snow Leopard. You can now install and use MacFUSE on the latest Snow Leopard developer seed. [Highly Experimental]
  • Feature: Enhanced DTrace support. MacFUSE.framework now contains USDT probes that will be helpful to those developing file systems in Objective-C. For example, look at the updated LoopbackFS example file system: the logging code from it has been removed because better tracing information can be had using DTrace. Consequently, the file system code is shorter and easier to read.
  • Feature: Xcode project templates. MacFUSE now comes with project templates for helping developers get started even faster on their new file systems. You can now even create a file system with the proverbial "zero lines of code".
  • Feature: Debugging symbol bundles included for MacFUSE Objective-C and C libraries. Developers can now do source-level debugging within the Objective-C and C libraries even with the official MacFUSE builds. Look for dSYM bundles in the Resources/Debug/ subdirectory within MacFUSE.framework.
  • Feature: Support for 64-bit inode numbers in the user-space library on Leopard and above. Developers can now choose to use 64-bit inode numbers in their file systems. To do so, a developer would have to compile their file system with -D__DARWIN_64_BIT_INO_T=1 as part of CFLAGS. Then, instead of linking against libfuse, they would have to link against libfuse_ino64--that is, -lfuse_ino64 instead of -lfuse.
  • Feature: New option auto_cache. When you enable this option, MacFUSE will automatically purge the buffer cache and/or attributes of files based on changes it detects in modification times. By default, if MacFUSE detects a change in a file's size during getattr(), it will purge that file's buffer cache. When auto_cache is enabled, MacFUSE will additionally detect modification time changes during getattr() and open(). Relevant knote messages are also generated. All this is subject to the attribute timeout. (That is, up to one purge per attribute timeout window.) As long as your file system's getattr() returns up-to-date size and modification time information, this should work as intended. For file systems that wish the kernel to keep up with "remote" changes, this should obviate the need for explicit purging through fuse_purge_np() (see below).
  • Feature: New user-space library function fuse_purge_np(); can be used by a user-space file system daemon to purge a given file's buffer cache, tell the kernel that the file's size has changed, invalidate the file's in-kernel attributes cache, and generate an appropriate kernel event (kevent) that can be received through kqueue(). Note that the auto_cache option described above should make explicit use of this function unnecessary in most cases. [Experimental]
  • Feature: New user-space library function fuse_knote_np(); can be used by a user-space file system daemon to generate arbitrary kernel events (kevent) for a given file. Note that the auto_cache option described above should make explicit use of this function unnecessary in most cases. [Experimental]
  • Feature: Support for multiple concurrent file systems in a single process; enhancements to the user-space library should allow developers to run multiple instances of either a given file system or even different file systems without having to create a separate process for each instance. Moreover, each instance can be managed (mounted, accessed, unmounted) independently. [Experimental]
  • Feature: New callback exchange; provides support for exchanging data between two files. (See exchangedata(2).)
  • Feature: New callback getxtimes; provides support for reading backup and creation times. (See ATTR_CMN_BKUPTIME and ATTR_CMN_CRTIME in getattrlist(2).)
  • Feature: New callback chflags; provides support for setting file flags. (See chflags(2).)
  • Feature: New callback setbkuptime; provides support for setting backup time.
  • Feature: New callback setcrtime; provides support for setting creation time.
  • Feature: New callbacks setattr_x and fsetattr_x; provides support for setting many attributes in a single call. Not only Mac OS X has a large number of settable attributes, heavy file system metadata activity, which is quite common and can occur behind the scenes, can generate a really large number of calls to set one or more attributes. In line with the "keeping things simple" philosophy, the MacFUSE API fans out a kernel-level setattr call into individual calls such as chmod, chown, utimens, truncate, ftruncate, and the newly introduced chflags, setbkuptime, and setcrtime. Depending on your user-space file system, you may really wish that you could handle all this in one call instead of receiving numerous back-to-back calls. setattr_x and fsetattr_x let you do that. NOTE that if you implement these calls, you will NOT receive ANY of the other "set" calls even if you do implement the latter. In other words, you will only receive setattr_x and fsetattr_x; the chmod, chown, utimens, truncate, ftruncate, chflags, setcrtime, and setbkuptime callbacks will never be called. (You must therefore handle everything at once.) Use this callback only if you know you need to use it. See the reference file system source (loopbackc) to see an example of how to use [f]setattr_x.
  • Feature: Backward compatibility (both binary and source levels) despite new callbacks; existing file system binaries linked against older MacFUSE versions should continue to work; file systems can choose to opt out of all the aforementioned new callbacks.
  • Update: Better version of the loopback reference file system; implements newly introduced callbacks and provides higher fidelity with the native file system.
  • Packaging: The user-space library is now installed with proper "current" and "compatibility" version numbers; it is also installed with an appropriate file name such as libfuse.2.7.3.dylib instead of the constant name libfuse.0.0.0.dylib. To maintain compatibility with existing binaries, a new symbolic link libfuse.0.dylib is included for the time being.
  • Packaging: A streamlined install/update mechanism is now part of MacFUSE. The mechanism greatly simplifies and improves install/update experience both for end users and for developers who use MacFUSE in their software. There is a single "unified" MacFUSE package that contains binaries for all supported platforms.
  • Building: A new build/packaging mechanism is now part of the MacFUSE source tree. This is relevant only to those who experiment with MacFUSE internals.
  • Bugfix: Fixed a bug that could cause a getattr call to report the older size after a write call if the former came before the server could finish the write.
  • Bugfix: Fixed a bug that could cause the call for setting the modification time for a file system object to be ignored under certain circumstances.
Version 2.0.3,2 | Release Date: 2008-12-01 | Download

Incorrect version number 2.1.5

Version 1.7.1 | Release Date: 2008-06-30 | Download
  • Bugfix: Fixed a kernel issue that could cause resource forks larger than 128KB to be truncated when accessed through the Finder.
  • Bugfix: Fixed a kernel issue where the file system could fail to "catch up" on a file's size when the size changed unbeknownst to MacFUSE (say, on a remote server.)
  • Fix: Changed a kernel policy that could prevent generation of certain fsevents. Although generally harmless in Leopard 10.5.2 and below, this could confuse higher layers of system software in 10.5.3. (The issue manifested as problematic file saves.)
  • Fix: 10.4: Fixed a compilation artifact issue where the MacFUSE 1.5 kernel extension could fail to load on PowerPC 10.4.x systems with an "unknown cmd field" error from kextload.
  • Fix: Packaging: The IFPkgFlagInstalledSize field is handled better in the package.
  • MacFUSE.framework Changes
    • Support for a position parameter in extended attributes delegate methods. The old methods are deprecated, although they will still be called (for now) if the file system does not implement the newer methods.
Version 1.5.1 | Release Date: 2008-05-01 | Download
Version 1.5.1:
  • Bugfix: Fixed bug where the Finder would sometimes report zero KB free in a newly mounted MacFUSE volume.
  • Bugfix: Fixed a signal-related bug that prevented a process from calling fuse_main() more than once (for example, if the process wanted to remount a volume after it had been unmounted.)
  • Bugfix: Fixed an exit(3) call that should have been _exit(3). Could cause tear-down issues for certain file systems.
  • Feature: If a user file system becomes dead or unreachable (for example, if the daemon crashed), MacFUSE will report -1 as the file system subtype (the f_fssubtype field of struct statfs64 and the f_reserved1 field of struct statfs.) The MacFUSE file system property list files now identify subtype -1 as the "dead" file system.
  • Feature: 10.5: Experimental support for select(2) on the user-kernel device. Must be explicitly enabled at kernel extension compile time through M_MACFUSE_ENABLE_DSELECT.
  • Feature: 10.5: Added support for file flags (see chflags(2)). Currently, a user file system can only provide these flags for reading. Support for setting these flags will come in the next release.
  • Update: 10.5: User-space library now based on FUSE library version 2.7.3.
  • Packaging: 10.5: MacFUSE for Tiger (the ready-to-install package) can now also be compiled on Leopard.
  • MacFUSE.framework Changes
    • 10.5: Support for garbage collection.
    • 10.5: Includes BridgeSupport data.
    • Improved mount failure handling and notifications.
    • Improved documentation in header file; explicitly called out the keys that are supported in various delegate methods that use NSDictionary.
    • Support for typeCode and creatorCode in GMFinderInfo class.
    • Explicit constants to use as keys for notification dictionary, etc.
    • Added read support for the st_flags field of struct stat.
    • Fixed bug where the st_ctimespec field of struct stat was being set to NSFileCreationDate. The framework now sets st_ctimespec to equal st_mtimespec; the NSFileCreationDate is not currently supported.
    • Improved resolutions of times used by AttributesOfItemAtPath:error and setAttributes:ofItemAtPath:error:.
    • Added code for calling createSymbolicLinkAtPath: and linkItemAtPath:.
    • Added support for mode_t in mkdir. Tightened up NSFilePosixPermissions code in mkdir, chmod, and create.
    • 10.4: Improved create support when using custom icons (synthesized AppleDouble files) on 10.4.
Version 1.3.0/1.3.1 | Release Date: 2008-03-02 | Download
  • includes the new MacFUSE.framework (installed in /Library/Frameworks/), a framework designed to simplify file-system development for Objective-C programmers.
  • [Leopard-only] Added new built-in stacking module threadid to the user-space library. It can be used when you want each file system request to come in to the user-space file system with the user/group IDs of the caller making the request.
  • [Leopard-only] Now includes version 2.7.2 of the user-space FUSE library.
  • fixed an issue that caused sparse disk images on SSHFS fail to mount on Leopard.
  • ixed an issue with the handling of the nosyncwrites option.
  • fixed an issue with the handling of .DS_Store files when the noappledouble option was specified.
  • fixed an issue with the handling of extended attributes when a user-space file system returned ENOTSUP in setxattr().
  • fixed an incorrect error message that users saw if they attempted to use a version of MacFUSE mismatched with their operating system version.
  • user-space library now exports operating-system version-detection routines.
Version 1.1.0 / 1.1.1 | Release Date: 2007-11-06 | Download

Improvements (Kernel)

  • Improved handling of synchronous I/O and uncached I/O.
  • vnop_access() now summarily allows calls for symbolic links.

Bugfixes (Kernel)

  • Fixed issue with writes to newly created ._ files in noubc (no unified buffer cache) mode. The issue could lead to failed file creation and/or failed file copies.
  • Fixed issue with handling the root vnode's parent ID when use_ino is in effect. The issue led to the Finder refusing to copy from certain volumes.

Improvements (User Space)

  • Added const char *macfuse_version(void) to the user-space library.
  • Added void fuse_unmount_compat22(const char *mountpoint) to the user-space library.
  • Simplified xmp_access() in the fusexmp_fh example file system.

Bugfixes (User Space)

  • Fixed incorrect listxattr() behavior In the fusexmp_fh example file system. The issue could lead to a failed file copy when the source had both ACLs and non-ACL extended attributes.

Build and Packaging Improvements

  • MacFUSE releases for "Leopard" and "Tiger" now have different version numbers. See MACFUSE_VERSIONING for details.
  • Fixed make-pkg.sh so as not to include spurious .svn directories in its output on Leopard.
  • Added operating system version to the disk image volume name.
Version 1.0.0 | Release Date: 2007-10-26 | Download

Leopard Support

  • Largely identical codebases for Mac OS X "Tiger" and "Leopard". Platform-specific optimizations and improvements where possible and appropriate.
  • Leopard binaries, both for kernel and user code, link against 10.5 SDKs.
  • Operating environment compatibility now checked and ensured at various levels: in the user-space library, in the mount utility, and in the load utility. Compatibility failure is reported through system-wide notifications and through GUI dialogs, which can optionally be suppressed.
  • open now supports O_SYMLINK.
  • Reference file system now supports lchmod.
  • Leopard-specific volume capabilities, volume attributes, and file attributes recognized.
  • Much improved Finder interaction: better mount-time behavior, better support for Finder metadata, better handling of file system failure.
  • Custom volume icon support based entirely on extended attributes.
  • Installed under /Library/Filesystems/ on Leopard.

New/Improved Mount-Time Options

  • This release has several new mount-time options. Please see http://code.google.com/p/macfuse/wiki/OPTIONS for details.

Improvements and Feature Additions (Kernel)

  • Improved operation when in direct I/O mode: better pagein/pageout failure handling; cached file size purged appropriately upon writes; execution denial when direct I/O enabled.
  • Improved permissions handling that can adaptively take input from the kernel, the kernel part of MacFUSE, and user-space file systems.
  • Improved extended attributes handling that can adaptively take input from the kernel, the kernel part of MacFUSE, and user-space file systems.
  • Improved handling of resource forks--can be handled entirely through Apple Double files, entirely through extended attributes, or a mix thereof.
  • Support for "large" resource forks (and large extended attributes in general). Default sane upper limit (compile-time) is 4MB.
  • Mounting behavior is now always synchronous. That is, mount processing in the kernel now waits (with a timeout) for user space to respond before returning success. This means calls such as statfs/statvfs don't have to cook up any fake data in the window in which programs (particularly the Finder) want to query the volume before user space has responded.
  • Rewritten, finer grained device layer locking.
  • Improved vnode revocation and triggers for such revocation.
  • Improved dead file system (deadfs) shim built into MacFUSE.
  • Added generation number propagation.
  • Added support for message queueing at either the head or the tail of the kernel-user pipe.
  • Improved mmap handling, with fault tolerant file handle fetching.
  • Improved I/O handling in the case where vnop_strategy has to retrieve a file handle at the "last moment" (execve, asynchronous I/O, and possibly mmap paths).
  • Randomly generated "secrets" shared between the /dev/fuseN device opener and the file system mounter (the two can be separate processes or the same process).
  • Root vnode now cached in the private mount data.
  • Optional preflight authorization for the case where we fetch a file handle without a preceding open call.
  • Optional negative name caching.
  • Optional munging of the file system type name in the kernel (allows user-space file systems to use their own file system bundles).
  • Improved authorization of sensitive mount-time options such as allow_other and allow_root.
  • New mechanism for per-file buffer cache purging; can be used by user-space file systems.
  • Support for custom killing of IPC tickets (FT_KILL).
  • Support for "canfail" (non-panic'ing) versions of memory allocation and IPC parameter packing calls.

Improvements and Feature Additions (User Space)

  • Custom volume icon support is now provided through a stack module in the user-space library.
  • User-space library now based on FUSE library version 2.7.1, with several improvements and new features such as module stacking.
  • Improved termination behavior in the user-space library--things should clean up better and several unmount/exit-time issues should no longer occur.
  • The user-space library now uses a custom (POSIX-like) implementation of semaphores that's better suited to MacFUSE.
  • Improved Darwin-specific abstraction in the user-space library. Code factored out to fuse_darwin.c, fuse_darwin.h, and mount_darwin.c. Darwin-specific features available to third parties accessible through fuse_darwin.h.
  • The pass-through file system (xmp) has been overhauled for MacFUSE to be a reference file system. In particular, it has more extensive support for resource forks and extended attributes in general.
  • mount_fusefs now dynamically looks up file system personalities in the on-disk Info.plist file; has fuzzy match support for heuristic matching of a file system type to the exec path of a file system daemon.

Performance and Resource Consumption

  • Greatly reduced kernel memory consumption. Proactive memory freeing triggered when giant buffers are detected.
  • Logic overhauling and redundancy analysis used to reduce the number of certain calls (such as vnop_access) in highly trafficked paths.

Bugfixes (Kernel)

  • Fixed mmap descriptor-type mismatch issue.
  • Fixed an erroneous delete/rename-time kauth check.
  • Fixed a leak in vnode destruction code.
  • Fixed a termination-time race in the kernel.
  • Fixed an issue where the size of a newly created directory wasn't immediately available in the vnode's attributes.
  • Fixed a file handle race that occurred in user space but due to a non-blocking operation by the kernel.
  • Fixed vnode_iterate deadlock at unmount time.
  • Fixed a realloc panic.
  • Fixed parent ID issue for the root vnode.
  • Fixed issue when file handle tracking would be out of whack (non-fatal) if a file system died abruptly.
  • Fixed locking issue with vnode printing.
  • Fixed fsync behavior to be synchronous when appropriate.
  • Fixed deadlock because of a bug in the deadfs shim.
  • Fixed a bug in the handling of per-vnode noncached I/O.

Bugfixes (User Space)

  • Fixed an issue with the user-space daemon not exiting upon certain failed mount attempts.
  • Fixed thread cancelation issues in the user-space library.
  • Fixed an issue with the unmount code in the user-space library depending on the mount path alone.
  • Fixed issue with Python bindings not loading with the bleeding edge version of MacFUSE.

Introspection and Debugging Support

  • Added debugging control for printing all vnodes for a given mount.
  • Added debugging control for "hard killing" a MacFUSE volume.
  • More detailed log messages (with vnode names in some cases).
  • Several counters, resource usage statistics, and tunable variables accessible through the sysctl interface. (Try sysctl macfuse)

New/Updated Documentation

  • Mount-Time Options (http://code.google.com/p/macfuse/wiki/OPTIONS)
  • FAQ (http://code.google.com/p/macfuse/wiki/FAQ)
  • HOWTO (http://code.google.com/p/macfuse/wiki/HOWTO)

Build and Packaging Improvements

  • Much simplified compilation and package building: a single command can build all components into a ready-to-install package. Unified and simplified configuration scripts now available for both core MacFUSE components as well as file systems such as sshfs.
  • Improved packaging. Note that the MacFUSE disk image name now includes the OS version.
  • Cleaner project structure as visible in Xcode. Leopard version done in Xcode 3.x.

Specific File Systems

  • Several improvements and bugfixes for sshfs.
  • procfs overhauled; now Leopard-only.
Version 0.4.0 | Release Date: 2007-06-04 | Download

* Support for custom volume icons in the user-space library (see [CUSTOM_VOLUME_ICON] for details). You can specify a volume icon through the new `volicon` option.

* The installation or upgrading of MacFUSE will no longer prompt for a system restart. Note that a restart was never required--it was only recommended (you could, if you wanted to, close the Installer window instead of clicking on the `Restart` button). The MacFUSE kernel extension can be unloaded/loaded dynamically, so a restart doesn't have to be a requirement. However, if a MacFUSE volume is mounted when you upgrade MacFUSE, a subsequent mount will not work with the older kernel extension that's in kernel memory and can't be unloaded because it's busy. The new behavior is for `load_fusefs` to try to dynamically unload the old kernel extension if possible. If such unloading succeeds (or if it wasn't needed because nothing old was loaded), then everything is good. If the unloading fails, you will now see a warning dialog that tells you to either eject all currently mounted MacFUSE volumes or to restart the system.

* New option `defer_auth` that causes MacFUSE to use a permissions handling model in which neither MacFUSE nor the local kernel will attempt to handle permissions. Regardless of ownership and as-seen permissions, operations will initially go through to the file system daemon, and it's up to the daemon to do what it pleases. For example, in the case of sshfs, no matter what uid, gid, or permissions you see, what happens eventually upon a file operation will depend on what the SFTP server does.

* The `allow_root` option, whose handling was disabled until now, can now be used. Only a user who is a member of the MacFUSE Admin Group can use this option. The superuser can designate any single group id as the MacFUSE Admin Group--through the `sysctl` command (the specific sysctl variable to set is `macfuse.tunables.admin_group`). Note that by default, this variable contains the group ID of `admin` group on Mac OS X. The use of `allow_root` is strongly discouraged as it can make the system considerably more vulnerable to security threats.

* The timeout alert panel now also covers the pre-init case, that is, the case of the in-kernel wait for the asynchronous user-kernel FUSE_INIT handshake timing out. This requires a thread callout in the kernel.

* Fix for a rare (but possible) unmount-time hang. The same fix also fixes a rare (but possible) NULL-pointer dereference in the kernel.

* The locations of where things are installed have changed. The kernel extension (`fusefs.kext`) is no longer installed under `/Library/Extensions/`. Instead, the file system bundle (`/System/Library/Filesystems/fusefs.fs/`) now contains everything "under one roof" (except the user-space library). Moreover, `fusefs.fs` now contains a `Support/` subdirectory that in turn contains `fusefs.kext`, `load_fusefs`, `mount_fusefs`, and the uninstall script (`uninstall-macfuse-core.sh`).

Version 0.3.0 | Release Date: 2007-05-07 | Download
  • User-space FUSE library updated to version 2.6.5 of FUSE.
  • Fix to the user-space FUSE library to deal better with a missing mount-point argument.
  • "Not responding" alert panel default timeout changed to 20 seconds (up from 10 seconds). Some reorganization of the alert panel.
  • The noauthopaque and noauthopaqueaccess options are now deprecated. MacFUSE will now use an adaptive approach to determining whether a given file system daemon implements the access() method, and based on the outcome, MacFUSE will use the appropriate permissions handling.
  • Fix for dealing with an issue regarding "remote" (unbeknownst to MacFUSE) deletion of a file.
  • Fix for one condition that can lead to the "vnode reclaimed with valid fufh" kernel panic.
  • Miscellaneous tweakings.
Version 0.2.5 | Release Date: 2007-04-21 | Download
  • Alert panel for displaying file system daemon timeouts. Details: A common complaint of MacFUSE users (especially those using sshfs) is that the Finder, and sometimes other parts of the Mac OS X user interface, do not handle disruption in network connectivity well. Since version 0.1.9, MacFUSE has had the daemon_timeoutdaemon_timeout option, the kernel would wait forever, although you can still kill the daemon or forcibly unmount the volume. MacFUSE 0.2.5 makes the situation more flexible. Now, there is a daemon_timeout (10 seconds) to begin with. If the daemon hasn't responded for that time, the kernel will show an alert dialog giving the user two choices: "Continue to Wait" or "Eject". Choosing the former will make the dialog disappear and the kernel will wait until either the daemon resumes responding or there's another timeout, at which point it will show the dialog again. Choosing "Eject" will arrange for the volume to be ejected instantly. The alert dialog itself has a timeout. If the user doesn't choose within some time (20 seconds), the dialog will disappear and the kernel will assume "Continue to Wait". option, which can be used to specify a timeout for the user-space file system to respond. If the kernel doesn't hear back from the daemon within that time, it will mark the file system as "dead". This will stop the Finder from "beachballing", but will also eject the volume instantly. To be more precise, it will arrange for the volume to be ejected. If you didn't specify the
  • Killing the file system daemon after unmount. Details: After a successful unmount, sometimes (or often, depending on the circumstances) the user-space file system daemon doesn't exit, but continues to "hang around". The hang is benign in that you can easily get rid of the daemon (send it a SIGABRT or SIGKILL), but it's annoying nevertheless. The reason for this hang is the less than stellar behavior of Pthread cancellation on Mac OS X (and the FUSE library's dependence on pthread_cancel() and such). This is nontrivial to fix. MacFUSE 0.2.5 introduces a new option kill_on_unmount. If this option is specified, the kernel would send a SIGKILL to the daemon as the very last step of unmounting. This isn't so bad because before this, the kernel sends a synchronous FUSE_DESTROY message to the daemon, so the latter will still have an opportunity to shut things down gracefully.
  • Ping Disk Arbitration by default. Details: MacFUSE 0.2.5 pings Disk Arbitration by default (that is, it acts as if the ping_diskarb option was specified on the command line). For backward compatibility, you can still specify ping_diskarb. Conversely, if you do NOT want Disk Arbitration to be pinged, you now have to explicitly specify a new option: noping_diskarb.
  • Default format string for file systems with unspecified subtype. Details: If a user-space file system daemon does not specify its subtype, andif the type cannot be inferred by the MacFUSE mount utility, MacFUSE will now use the string "Generic MacFUSE File System (MacFUSE)" instead of letting the Finder show the volume as of an unknown format.
  • asm no longer redefined in the FUSE library. Details: As a hack to get things working cheaply on Mac OS X, I had originally redefined asm(x) to nothing because the FUSE user library uses asm with the ".symver" directive, which isn't available on Mac OS X. This is fine if the user file system daemon doesn't need to use asm itself (unlikely). The daemon could include other headers that have asm in there somewhere. In any case, redefining asm is ugly, so the code no longer does that and uses other changes.
  • Although not part of MacFUSE Core, there is an updated version of the sshfs file system with several important and useful changs. For details, see MACFUSE_FS_SSHFS.
Version 0.2.2 | Release Date: 2007-02-26 | Download
  • Fixed a bug which, depending upon the size of a file being read, and the user/kernel buffer sizes involved, could lead to the tail of the read data being zeroed.
  • Fixed a bug that could trigger the "vnode reclaimed with valid fufh" panic.
  • Added a workaround allowing better Finder support for copying files and folders to an ACL-enabled MacFUSE volume. Note that even with this workaround, there are some remaining Finder issues on ACL-enabled volumes.
  • New option: 'noapplespecial'. When enabled, Apple Double files (the ones that begin with the dot and underscore characters) and .DS_Store files will become inaccessible/invisible/un-creatable within a MacFUSE mount. You won't even see them in a directory listing. You will also not be able to create a file or directory that begins with dot-underscore (except for the 2-character dot-underscore literal itself). I personally am not too excited about this option, but here it is in case somebody wants to experiment. I haven't tested this, especially in how it might affect the Finder and other applications. Use at your own peril.
  • New option: 'nosynconclose'. Requires 'nosyncwrites'. Unless you understand exactly what it does, please don't use it. If you have to ask what it does, please don't use it.
Version 0.2.1 | Release Date: 2007-02-15 | Download

In MacFUSE 0.2.0, the 'volname' option erroneously got "merged" with the 'extended_security' option (if you set one, you incorrectly get the other). Since 'extended_security' is more experimental in nature currently, it shouldn't be enabled every time you use 'volname'. This is a minor release to fix this issue.

Version 0.2.0 | Release Date: 2007-02-11 | Download
  • New option: 'novncache'.

Details: The new mount option 'novncache' can be used to turn off VFS name caching (name -> vnode lookups) in the kernel. This is useful when you want lookup operations to go to the file system daemon every time. This is useful in conjunction with the existing 'noubc' and 'noreadahead' options. So, if you use the combination '-onovncache,noubc,noreadahead', you should have a mount that will bypass most of the fcaching and go to the daemon every time. Of course, this would be slower. NOTE that if you're dealing with 32-bit executables, the situation is a bit more complex because of the "Task Working Set" caching mechanism in Mac OS X.

  • New option: 'nolocalcaches'.

Details: 'nolocalcaches' is a meta option that is equivalent to 'noreadahead,noubc,novncache'. In particular, you can use '-onolocalcaches' along with the sshfs option '-ocache=no' to get file system behavior wherein most calls go to the server every time, resulting in a more up-to-date view of the remote file system, albeit with some overhead.

  • New option: 'direct_io'.

Details: The 'direct_io' mount option from Linux FUSE is now supported. This option can be used both at a file level or for the entire mount. To use it at a file level, your file system daemon should set the direct_io field of the fuse_file_info structure to 1 in the open() method. To use it for the entire mount, specify it as a mount-time option. 'direct_io' implies 'novncache', 'noubc', 'noreadahead' for the file (vnode) in question. Additionally, it forces the file system to be written synchronously ('nosyncwrites' is disabled for the /entire mount/, not just the file in question). But what does this option do (besides altering these above options)? Well, on Mac OS X, it introduces another read path from the kernel to the MacFUSE file system daemon. The new path does not go through the buffer cache (or the cluster layer). This allows you to specify one file size in the getattr() method and supply /less/ data in the read() method. Without the 'direct_io' option, MacFUSE will pad the missing data with zeros and return success. With the 'direct_io' option, MacFUSE will simply return the 'short' data and the read() call will not fail. This is useful when you don't know the size of the data for one reason or another (it's expensive to compute the size; it's not really possible to compute the size because you're streaming the data; etc.) Please NOTE: if an application insists on wanting the exact amount of data that you advertised in getattr(), 'direct_io' can't do anything about that, of course. The Finder is one such application.

  • Improved MacFUSE version tracking.

Details: The MacFUSE kernel extension now logs a version message when you load it. The message is of the form:

MacFUSE: starting (version 0.2.0, Feb 10 2007, 10:34:26)

The date/time shown is a build timestamp. You can also view the version of a loaded MacFUSE kernel extension by using the sysctl command from the Terminal (just type 'sysctl macfuse' on the command line). This will allow a better approximation of which build you are running. Additionally, the mount_fusefs command now checks the version of the loaded fusefs.kext and bails out (by default) if there's a version mismatch between itself and the kext. If you really must, you can override this behavior by setting the MOUNT_FUSEFS_IGNORE_VERSION_MISMATCH environment variable.

  • Advanced 'reverse' (user->kernel) interface for file system daemons.

Details: There's a preliminary advanced interface that file systems can use (don't use it just yet, unless you know exactly what you're doing and why) to do some weird things like: mark an existing vnode as "gone" (a variant of the revoke() system call), purge a node's in-kernel attribute cache, VFS name cache, or UBC. This interface will certainly change and evolve in future, so please don't create any dependencies on it yet.

  • Paremetrized the upper limit on the size of an extended attribute that you can set on files in a MacFUSE file system.

Details: The limit (FUSE_MAXATTRIBUTESIZE) is defined in fusefs/common/fuse_param.h, and is 128KB by default. This matters because if you want to support writing larger extended attributes, you will need to tweak this parameter and recompile fusefs.kext. The 128KB value is not ad-hoc. The FUSE user-space library has an upper limit (approximately 128KB) on the size of the kernel channel" buffer--you will also have to increase this limit and recompile the user-space library. Besides, the following points apply to extended attribute sizes in Mac OS X:

- HFS+ supports a maximum inline attribute size of 3802 bytes. - However, HFS+ does support arbitrary sizes for resource forks, even though a resource fork is advertised as an extended attribute ("com.apple.resourceFork"). It's not a "real" extended attribute though--HFS+ intercepts this one and handles it itself. - The extended attribute handling code in the xnu kernel has an upper limit of 128KB on extended attribute data.

  • Better support for extended attributes in general.

Details: MacFUSE now tries to be rather clever when dealing with extended attributes. If a user-space file system implements xattr functions, MacFUSE will pass on { get, list, remove, set }xattr() calls to user space. There are 2 exceptions to this: if the extended attributes happen to be those corresponding to Finder Info or Resource Forks. The reason for this: well, since regular extended attributes are subject to an upper limit (128KB by default), if we want arbitrary size resource forks, we have to treat them differently (like HFS+ does). MacFUSE treats them differently by telling the kernel to store them as Apple Double files. MacFUSE will also cause other attributes to be stored in Apple Double files if the file system daemon doesn't implement setxattr(). In fact, MacFUSE "learns" on the very first setxattr() call if the daemon implements this method or not--based on the return value. If the daemon doesn't implement the call, future setxattr() calls will not even go to user space: they will be short-circuited in the kernel, which will use Apple Double files. One noteworthy point here is that the kernel's generic xattr handling code (specifically the part that deals with Apple Double files) requires file locking (the O_EXLOCK flag to open) to work. This brings us to the next changelog item.

  • Support for advisory locking.

Details: Actually, MacFUSE always "had" advisory locking support. A file system in Mac OS X can get such locking for free by simply setting a flag. Unfortunately, Apple "forgot" to export this flag (rather, the function that sets this flag). Therefore, kernel extensions currently cannot set this flag without some sort of a kludge. Since advisory locking is rather critical now because extended attributes support requires it, I've decided to turn this flag on through cheap kludgy means (hardcoding the offset of a field in an Apple-private data structure). On the bright side, this means extended attributes will work nicely and you have locking available. On the flip side, if the aforementioned offset ever changes suddenly in a Mac OS X release, you might have a kernel panic :-) Apple really needs to export this function.

  • Support for Mac OS X Extended Security (Access Control Lists), new option: 'extended_security'.

Details: You can now pass the 'extended_security' option at mount-time to enable support for ACLs on a MacFUSE file system. The ACLs that you get are identical to those in HFS+, except that they are stored in Apple Double files instead of being stored in the HFS+ attributes B-Tree. Of course, you can use the same commands ("chmod +a 'singh deny read'", "ls -le", etc.) to work with these ACLs. See the man page of chmod for details. IMPORTANT: If you want the kernel to honor these ACLs while accessing the file system, you also need to pass the 'noauthopaque' option at mount time. Without this option, the kernel will try to talk to the user-space daemon for authorizations. CAVEAT: The Apple Double files used to store ACLs have the default owner, group, permissions as a normal file would.

  • Support for the kqueue/kevent notification mechanism.

Details: MacFUSE now implements the necessary kernel functions for supporting the kqueue/kevent kernel event notification mechanism. See kqueue(2) on how you can use kqueue() and kevent() to use this mechanism on a MacFUSE file system. NOTE that implementing this mechanism in the kernel requires using unsupported Apple programming interfaces, which means that in future, it is possible that some revision of Mac OS X will not let this work. Therefore, the entire kqueue/kevent support in MacFUSE is a compile-time option that's conrolled by the MACFUSE_ENABLE_UNSUPPORTED macro in fusefs/common/fuse_param.h.

  • Improved support for asynchronous writes (the 'nosyncwrites' option).

Details: Heh, I "improved" support for the 'nosyncwrites' option in at least two earlier releases, but I keep forgetting some detail. I'll need to explain the MacFUSE architecture to clarify why this is a bit tricky, but suffice it to say that asynchronous writes are never as easy on a "distributed"/"remote" file system as they are on a "local" file system. Unlike NFS on Mac OS X, MacFUSE doesn't have a special-purpose buffer cache either. That said, 'nosyncwrites' now follows sync-on-close semantics. As long as you have a file open, writes are asynchronous, but when you close the file, MacFUSE will sync it.

  • Statistics available through the sysctl interface: values of some in-kernel counters and constants can be seen through the sysctl interface (try "sysctl macfuse" on the command line).
  • Fixed a rather bad accounting bug that caused a certain type of MacFUSE-allocated memory to be not freed until the time you unmounted the MacFUSE volume.
  • User-Space library updated to FUSE 2.6.3.
  • Miscellaneous Improvements: many parts of the kernel extension have been tweaked and improved.
Version 0.1.9 | Release Date: 2007-02-02 | Download

MacFUSE 0.1.9 (There was no 0.1.8 release)

  • The installer package does a better job of cleaning up previously installed MacFUSE files.
  • There is now a check that we are installing on at least a 10.4 system.
  • There is an uninstall program.
  • Fixed a potential kernel panic while unmounting forcibly.
  • Fixed a kernel panic that could be triggered at vnode-reclaim time if MacFUSE didn't validate the type of the vnode at vnode-creation time.
  • The user-space library has better termination behavior.

Details: It handles SIGTERM/SIGINT hopefully properly now, and will try to automatically unmount the file system under most circumstances. Even when a file system daemon misbehaves and refuses to cooperate during termination, you should be able to force-quit the daemon and unmounting should proceed. Overall, this should result in much better experience, especially during file system development (when your daemons might be dying and misbehaving all the time).

  • There is improved support for operation without buffer caching (the 'noubc' option).
  • There is improved support for asynchronous writes (the 'nosyncwrites' option).
  • The 'nosyncwrites' option is now mutually exclusive with the 'noubc' and 'noreadahead' options.
  • mount_fusefs now sends notifications to OS X's distributed notification center as a file system is being mounted.

Details: There is one notification sent right after a successful mount, one after the file system has initialized (the daemon has acknowledged FUSE_INIT), and another if there has been a timeout waiting for the file system to initialize. All these notifications are sent for an object called "com.google.filesystems.fusefs.unotifications". There is also a user-data dictionary in each notification. The dictionary at least contains the mount-path in question. See fusefs/common/fuse_mount.h for the names of these notification, etc. To learn how to receive these notifications, see the documentation for CFNotificationCent

Version 0.1.0b006 | Release Date: 2007-01-12 | Download
No changes specified
Version 2.1.7 | Release Date: 2007-01-01 | Download

support 64bit

Version 0.1.7 | Release Date: 1970-01-01 | Download
  • The file "/usr/local/bin/mount_fusefs" is removed. The mount_fusefs
    in the fusefs.fs bundle is the actual binary used by libfuse. This
    obviates the need to have "/usr/local/bin" in your path, making it a
    bit easier to write fuse file system apps.
  • The kext has been moved from /System/Library/Extensions to
    /Library/Extensions. Dynamically loading the kext on first mount seems
    to be working well enough, so we don't anticipate a need to load at
    boot-time. This move will also free us from having to worry about the
    kext cache.
  • Fix for timestamp issues (#33).
  • Fixed a problem with 64 bit file offsets that was causing issues
    with files greater than 4GB.
  • mount_fusefs will no longer automatically append a "@%d" (%d being
    the fuse device number) to the fsname. This is for the benefit of
    those running ntfs-3g with disk utility.
  • Improved support for "ping_diskarb" mount option (see issue #10).
    The mount_fusefs program with the ping_diskarb option now waits for
    the file system to initialize before notifying disk arbitration that
    the mount occurred. Currently it will wait for up to 5 seconds at most
    and then cancel the ping_diskarb if the file system does not
    initialize within that time.
  • The mount_fusefs program will wait for the file system to initialize
    (similar to ping_diskarb above). It will then send the notification
    "com.google.filesystems.fusefs.unotifications.mounted" with a string
    containing the mount path as the object to the distributed
    notification center. This is so that projects like MacFUSE ntfs-3g
    can create their own mount wrapper that waits until the file system is
    initialized before exiting.
  • Support for operation with buffer cache and readahead turned off for
    the cases where the "remote" file size is changing without the local
    file system's knowledge.
  • From now on, no more tarballs. We'll only have package installers.