Merge pull request #247 from trapexit/epmfs

re-add minfreespace check to epmfs policy

.gitignore

@@ -12,6 +12,14 @@
 *.la
 *.a
 
+# build artifacts
+mergerfs
+obj/
+src/version.hpp
+
 # Debian files
 debian/files
 debian/changelog
+
+# RPM files
+rpmbuild/

LICENSE

@@ -1,23 +1,15 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

Makefile

@@ -1,24 +1,17 @@
-# The MIT License (MIT)
+#  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 #
-# Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+#  Permission to use, copy, modify, and/or distribute this software for any
+#  purpose with or without fee is hereby granted, provided that the above
+#  copyright notice and this permission notice appear in all copies.
 #
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+#  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+#  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+#  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+#  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+#  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+#  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+#  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
 
 PKGCONFIG =  	$(shell which pkg-config)
 GIT 	  = 	$(shell which git)
@@ -33,11 +26,14 @@ INSTALL   = 	$(shell which install)
 MKTEMP    = 	$(shell which mktemp)
 STRIP     = 	$(shell which strip)
 PANDOC    =	$(shell which pandoc)
+SED       =     $(shell which sed)
+GZIP      =     $(shell which gzip)
+RPMBUILD  =     $(shell which rpmbuild)
 GIT2DEBCL =     ./tools/git2debcl
 CPPFIND   =     ./tools/cppfind
 
 ifeq ($(PKGCONFIG),"")
-$(error "pkg-config not installed"
+$(error "pkg-config not installed")
 endif
 
 ifeq ($(PANDOC),"")
@@ -62,6 +58,8 @@ FLOCK       = $(shell $(CPPFIND) "fuse_fs_flock")
 READ_BUF    = $(shell $(CPPFIND) "fuse_fs_read_buf")
 WRITE_BUF   = $(shell $(CPPFIND) "fuse_fs_write_buf")
 
+UGID_USE_RWLOCK = 0
+
 OPTS 	    = -O2
 SRC	    = $(wildcard src/*.cpp)
 OBJ         = $(SRC:src/%.cpp=obj/%.o)
@@ -71,6 +69,7 @@ MANPAGE     = $(TARGET).1
 FUSE_CFLAGS = $(shell $(PKGCONFIG) --cflags fuse)
 CFLAGS      = -g -Wall \
 	      $(OPTS) \
+	      -Wno-unused-result \
               $(FUSE_CFLAGS) \
               -DFUSE_USE_VERSION=26 \
               -MMD \
@@ -78,33 +77,52 @@ CFLAGS      = -g -Wall \
 	      -DFALLOCATE=$(FALLOCATE) \
               -DFLOCK=$(FLOCK) \
 	      -DREAD_BUF=$(READ_BUF) \
-              -DWRITE_BUF=$(WRITE_BUF)
+              -DWRITE_BUF=$(WRITE_BUF) \
+	      -DUGID_USE_RWLOCK=$(UGID_USE_RWLOCK)
 LDFLAGS       = $(shell $(PKGCONFIG) fuse --libs)
 
-BINDIR 	      =	$(PREFIX)/usr/bin
-MANDIR 	      =	$(PREFIX)/usr/share/man/man1
-INSTALLBINDIR = $(DESTDIR)$(BINDIR)
-INSTALLMANDIR = $(DESTDIR)$(MANDIR)
+PREFIX        = /usr/local
+EXEC_PREFIX   = $(PREFIX)
+DATAROOTDIR   = $(PREFIX)/share
+DATADIR       = $(DATAROOTDIR)
+BINDIR        = $(EXEC_PREFIX)/bin
+SBINDIR       = $(EXEC_PREFIX)/sbin
+MANDIR        = $(DATAROOTDIR)/man
+MAN1DIR       = $(MANDIR)/man1
+
+INSTALLBINDIR  = $(DESTDIR)$(BINDIR)
+INSTALLSBINDIR = $(DESTDIR)$(SBINDIR)
+INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)
 
 ifeq ($(XATTR_AVAILABLE),0)
 $(warning "xattr not available: disabling")
 CFLAGS += -DWITHOUT_XATTR
 endif
 
-all: $(TARGET) clonepath
+all: $(TARGET)
 
 help:
 	@echo "usage: make"
 	@echo "make XATTR_AVAILABLE=0 - to build program without xattrs functionality (auto discovered otherwise)"
 
-$(TARGET): obj/obj-stamp $(OBJ)
+$(TARGET): src/version.hpp obj/obj-stamp $(OBJ)
 	$(CXX) $(CFLAGS) $(OBJ) -o $@ $(LDFLAGS)
 
-clonepath: $(TARGET)
-	$(LN) -s $< $@
+mount.mergerfs: $(TARGET)
+	$(LN) -fs "$<" "$@"
 
 changelog:
-	$(GIT) log --pretty --numstat --summary | git2cl > ChangeLog
+	$(GIT2DEBCL) --name $(TARGET) > ChangeLog
+
+authors:
+	$(GIT) log --format='%aN <%aE>' | sort -f | uniq > AUTHORS
+
+src/version.hpp:
+	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
+	@echo "#ifndef _VERSION_HPP" > src/version.hpp
+	@echo "#define _VERSION_HPP" >> src/version.hpp
+	@echo "static const char MERGERFS_VERSION[] = \"$(VERSION)\";" >> src/version.hpp
+	@echo "#endif" >> src/version.hpp
 
 obj/obj-stamp:
 	$(MKDIR) -p obj
@@ -113,57 +131,81 @@ obj/obj-stamp:
 obj/%.o: src/%.cpp
 	$(CXX) $(CFLAGS) -c $< -o $@
 
-clean:
+clean: rpm-clean
 	$(RM) -rf obj
-	$(RM) -f "$(TARGET)" "$(MANPAGE)" clonepath
-	$(FIND) -name "*~" -delete
+	$(RM) -f src/version.hpp
+	$(RM) -f "$(TARGET)" "$(MANPAGE)" mount.mergerfs
+	$(FIND) . -name "*~" -delete
 
 distclean: clean
 	$(GIT) clean -fd
 
-install: install-base install-clonepath install-man
+install: install-base install-mount.mergerfs install-man
 
 install-base: $(TARGET)
 	$(INSTALL) -v -m 0755 -D "$(TARGET)" "$(INSTALLBINDIR)/$(TARGET)"
 
-install-clonepath: clonepath
-	$(CP) -a $< "$(INSTALLBINDIR)/$<"
+install-mount.mergerfs: mount.mergerfs
+	$(MKDIR) -p "$(INSTALLBINDIR)"
+	$(CP) -a "$<" "$(INSTALLBINDIR)/$<"
 
 install-man: $(MANPAGE)
-	$(INSTALL) -v -m 0644 -D "$(MANPAGE)" "$(INSTALLMANDIR)/$(MANPAGE)"
+	$(INSTALL) -v -m 0644 -D "$(MANPAGE)" "$(INSTALLMAN1DIR)/$(MANPAGE)"
 
 install-strip: install-base
 	$(STRIP) "$(INSTALLBINDIR)/$(TARGET)"
 
-uninstall: uninstall-base uninstall-clonepath uninstall-man
+uninstall: uninstall-base uninstall-mount.mergerfs uninstall-man
 
 uninstall-base:
 	$(RM) -f "$(INSTALLBINDIR)/$(TARGET)"
 
-uninstall-clonepath:
-	$(RM) -f "$(INSTALLBINDIR)/clonepath"
+uninstall-mount.mergerfs:
+	$(RM) -f "$(INSTALLBINDIR)/mount.mergerfs"
 
 uninstall-man:
-	$(RM) -f "$(INSTALLMANDIR)/$(MANPAGE")
+	$(RM) -f "$(INSTALLMAN1DIR)/$(MANPAGE)"
 
 $(MANPAGE): README.md
+ifneq (,$(PANDOC))
 	$(PANDOC) -s -t man -o $(MANPAGE) README.md
+else
+	$(CP) man/mergerfs.1 .
+endif
 
 man: $(MANPAGE)
 
-tarball: clean changelog man
+tarball: clean man changelog authors src/version.hpp
 	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
+	$(eval VERSION := $(subst -,_,$(VERSION)))
 	$(eval FILENAME := $(TARGET)-$(VERSION))
 	$(eval TMPDIR := $(shell $(MKTEMP) --tmpdir -d .$(FILENAME).XXXXXXXX))
 	$(MKDIR) $(TMPDIR)/$(FILENAME)
 	$(CP) -ar . $(TMPDIR)/$(FILENAME)
-	$(TAR) --exclude=.git -cz -C $(TMPDIR) -f ../$(FILENAME).tar.gz $(FILENAME)
+	$(TAR) --exclude=.git -cz -C $(TMPDIR) -f $(FILENAME).tar.gz $(FILENAME)
 	$(RM) -rf $(TMPDIR)
 
-deb:
+debian-changelog:
+	$(GIT2DEBCL) --name $(TARGET) > debian/changelog
+
+signed-deb: debian-changelog
+	dpkg-buildpackage
+
+deb: debian-changelog
+	dpkg-buildpackage -uc -us
+
+rpm-clean:
+	$(RM) -rf rpmbuild
+
+rpm: tarball
 	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
-	$(GIT2DEBCL) $(TARGET) $(VERSION) > debian/changelog
-	$(GIT) buildpackage --git-ignore-new
+	$(eval VERSION := $(subst -,_,$(VERSION)))
+	$(MKDIR) -p rpmbuild/BUILD rpmbuild/RPMS rpmbuild/SOURCES
+	$(SED) 's/__VERSION__/$(VERSION)/g' $(TARGET).spec > \
+		rpmbuild/SOURCES/$(TARGET).spec
+	cp -ar $(TARGET)-$(VERSION).tar.gz rpmbuild/SOURCES
+	$(RPMBUILD) -ba rpmbuild/SOURCES/$(TARGET).spec \
+		--define "_topdir $(CURDIR)/rpmbuild"
 
 .PHONY: all clean install help
 

README.md

@@ -1,42 +1,54 @@
 % mergerfs(1) mergerfs user manual
 % Antonio SJ Musumeci <trapexit@spawn.link>
-% 2015-06-05
+% 2016-02-21
 
 # NAME
 
-mergerfs - another FUSE union filesystem
+mergerfs - another (FUSE based) union filesystem
 
 # SYNOPSIS
 
-mergerfs -o&lt;options&gt; &lt;srcpoints&gt; &lt;mountpoint&gt;
+mergerfs -o&lt;options&gt; &lt;srcmounts&gt; &lt;mountpoint&gt;
 
 # DESCRIPTION
 
-mergerfs is similar to mhddfs, unionfs, and aufs. Like mhddfs in that it too uses [FUSE](http://en.wikipedia.org/wiki/Filesystem_in_Userspace). Like aufs in that it provides multiple policies for how to handle behavior.
+**mergerfs** is a union filesystem geared towards simplifing storage and management of files across numerous commodity storage devices. It is similar to **mhddfs**, **unionfs**, and **aufs**.
 
-Why create mergerfs when those exist? mhddfs isn't really maintained or flexible. There are also security issues when with running as root. aufs is more flexible than mhddfs but contains some hard to debug inconsistencies in behavior on account of it being a kernel driver. Neither support file attributes ([chattr](http://linux.die.net/man/1/chattr)).
+# FEATURES
+
+* Runs in userspace (FUSE)
+* Configurable behaviors
+* Support for extended attributes (xattrs)
+* Support for file attributes (chattr)
+* Runtime configurable (via xattrs)
+* Safe to run as root
+* Opportunistic credential caching
+* Works with heterogeneous filesystem types
+* Handling of writes to full drives
+* Handles pool of readonly and read/write drives
 
 # OPTIONS
 
 ###options###
 
-`defaults` is a shortcut for `big_writes`, `auto_cache`, `atomic_o_trunc`, `splice_read`, `splice_write`, and `splice_move`. These options seem to provide the best performance.
+* **defaults**: a shortcut for FUSE's **atomic_o_trunc**, **auto_cache**, **big_writes**, **default_permissions**, **splice_move**, **splice_read**, and **splice_write**. These options seem to provide the best performance.
+* **direct_io**: causes FUSE to bypass an addition caching step which can increase write speeds at the detriment of read speed. 
+* **minfreespace**: the minimum space value used for creation policies. Understands 'K', 'M', and 'G' to represent kilobyte, megabyte, and gigabyte respectively. (default: 4G)
+* **moveonenospc**: when enabled (set to **true**) if a **write** fails with **ENOSPC** a scan of all drives will be done looking for the drive with most free space which is at least the size of the file plus the amount which failed to write. An attempt to move the file to that drive will occur (keeping all metadata possible) and if successful the original is unlinked and the write retried. (default: false)
+* **func.&lt;func&gt;=&lt;policy&gt;**: sets the specific FUSE function's policy. See below for the list of value types. Example: **func.getattr=newest**
+* **category.&lt;category&gt;=&lt;policy&gt;**: Sets policy of all FUSE functions in the provided category. Example: **category.create=mfs**
 
-All [FUSE](http://fuse.sourceforge.net) functions which have a category (see below) are option keys. The syntax being `func.<func>=<policy>`.
+**NOTE:** Options are evaluated in the order listed so if the options are **func.rmdir=rand,category.action=ff** the **action** category setting will override the **rmdir** setting.
 
-To set all function policies in a category use `category.<category>=<policy>` such as `category.create=mfs`.
+###srcmounts###
 
-They are evaluated in the order listed so if the options are `func.rmdir=rand,category.action=ff` the `action` category setting will override the `rmdir` setting.
-
-###srcpoints###
-
-The source points argument is a colon (':') delimited list of paths. To make it simplier to include multiple source points without having to modify your [fstab](http://linux.die.net/man/5/fstab) we also support [globbing](http://linux.die.net/man/7/glob).
+The source mounts argument is a colon (':') delimited list of paths. To make it simpler to include multiple source mounts without having to modify your [fstab](http://linux.die.net/man/5/fstab) we also support [globbing](http://linux.die.net/man/7/glob). **The globbing tokens MUST be escaped when using via the shell else the shell itself will probably expand it.**
 
 ```
-$ mergerfs /mnt/disk*:/mnt/cdrom /media/drives
+$ mergerfs /mnt/disk\*:/mnt/cdrom /media/drives
 ```
 
-The above line will use all points in /mnt prefixed with *disk* and the directory *cdrom*.
+The above line will use all mount points in /mnt prefixed with *disk* and the directory *cdrom*.
 
 In /etc/fstab it'd look like the following:
 
@@ -45,162 +57,196 @@ In /etc/fstab it'd look like the following:
 /mnt/disk*:/mnt/cdrom  /media/drives  fuse.mergerfs  defaults,allow_other  0       0
 ```
 
-**NOTE:** the globbing is done at mount time. If a new directory is added matching the glob after the fact it will not be included.
+**NOTE:** the globbing is done at mount or xattr update time. If a new directory is added matching the glob after the fact it will not be included.
 
-# POLICIES
+# FUNCTIONS / POLICIES / CATEGORIES
 
-Filesystem calls are broken up into 3 categories: action, create, search. There are also some calls which have no policy attached due to state being kept between calls. These categories can be assigned a policy which dictates how [mergerfs](http://github.com/trapexit/mergerfs) behaves. Any policy can be assigned to a category though some aren't terribly practical. For instance: rand (Random) may be useful for **create** but could lead to very odd behavior if used for **search**.
+The filesystem has a number of functions. Those functions are grouped into 3 categories: **action**, **create**, **search**. These functions and categories can be assigned a policy which dictates how **mergerfs** behaves. Any policy can be assigned to a function or category though some are not very practical. For instance: **rand** (Random) may be useful for file creation (create) but could lead to very odd behavior if used for `chmod`.
 
-#### Functional  classifications ####
-| FUSE Function | Class |
-|-------------|---------|
-| access      | search  |
-| chmod       | action  |
-| chown       | action  |
-| create      | create  |
-| fallocate   | N/A     |
-| fgetattr    | N/A     |
-| fsync       | N/A     |
-| ftruncate   | N/A     |
-| getattr     | search  |
-| getxattr    | search  |
-| ioctl       | N/A*    |
-| link        | action  |
-| listxattr   | search  |
-| mkdir       | create  |
-| mknod       | create  |
-| open        | search  |
-| read        | N/A     |
-| readdir     | N/A     |
-| readlink    | search  |
-| release     | N/A     |
-| removexattr | action  |
-| rename      | action  |
-| rmdir       | action  |
-| setxattr    | action  |
-| statfs      | N/A     |
-| symlink     | create  |
-| truncate    | action  |
-| unlink      | action  |
-| utimens     | action  |
-| write       | N/A     |
+All policies when used to create will ignore drives which are mounted readonly. This allows for read/write and readonly drives to be mixed together.
 
-`ioctl` behaves differently if its acting on a directory. It'll use the `getattr` policy to find and open the directory before issuing the `ioctl`. In other cases where something may be searched (to confirm a directory exists across all source mounts) then `getattr` will be used.
+#### Function / Category classifications ####
+
+| Category | FUSE Functions |
+|----------|----------------|
+| action   | chmod, chown, link, removexattr, rename, rmdir, setxattr, truncate, unlink, utimens |
+| create   | create, mkdir, mknod, symlink |
+| search   | access, getattr, getxattr, ioctl, listxattr, open, readlink |
+| N/A      | fallocate, fgetattr, fsync, ftruncate, ioctl, read, readdir, release, statfs, write |
+
+Due to FUSE limitations **ioctl** behaves differently if its acting on a directory. It'll use the **getattr** policy to find and open the directory before issuing the **ioctl**. In other cases where something may be searched (to confirm a directory exists across all source mounts) then **getattr** will be used.
 
 #### Policy descriptions ####
+
+Most policies when called to create will filter out drives which are readonly or have less than **minfreespace**.
+
 | Policy | Description |
 |--------------|-------------|
-| ff (first found) | Given the order of the paths act on the first one found (regardless if stat would return EACCES). |
-| ffwp (first found w/ permissions) | Given the order of the paths act on the first one found which you have access (stat does not error with EACCES). |
-| newest (newest file) | If multiple files exist return the one with the most recent mtime. |
-| mfs (most free space) | Assuming the path is found to exist (ENOENT would not be returned) use the drive with the most free space available. |
-| epmfs (existing path, most free space) | If the path exists in multiple locations use the one with the most free space. Otherwise fall back to mfs. |
-| rand (random) | Pick an existing destination at random. |
-| all | Applies action to all found. For searches it will behave like first found `ff`. |
+| all | Search category: acts like **ff**. Action category: apply to all found. Create category: for **mkdir**, **mknod**, and **symlink** perform on all read/write drives with **minfreespace**. **create** filters the same way but acts like **ff**. |
+| eplfs (existing path, least free space) | If the path exists on multiple drives use the one with the least free space. Falls back to **lfs**. |
+| epmfs (existing path, most free space) | If the path exists on multiple drives use the one with the most free space. Falls back to **mfs**. |
+| erofs | Exclusively return **-1** with **errno** set to **EROFS**. By setting **create** functions to this you can in effect turn the filesystem readonly. |
+| ff (first found) | Given the order of the drives, as defined at mount time or when configured via xattr interface, act on the first one found. |
+| lfs (least free space) | Pick the drive with the least available free space but more than **minfreespace**. Falls back to **mfs**. |
+| mfs (most free space) | Use the drive with the most available free space. Falls back to **ff**. |
+| newest (newest file) | Pick the file / directory with the largest mtime. |
+| rand (random) | Calls **all** and then randomizes. |
 
 #### Defaults ####
+
 | Category | Policy |
 |----------|--------|
 | action   | all    |
 | create   | epmfs  |
 | search   | ff     |
 
+#### rename & link ####
+
+[rename](http://man7.org/linux/man-pages/man2/rename.2.html) is a tricky function in a merged system. Normally if a rename can't be done atomically due to the source and destination paths existing on different mount points it will return `-1` with `errno = EXDEV`. The atomic rename is most critical for replacing files in place atomically (such as securing writing to a temp file and then replacing a target). The problem is that by merging multiple paths you can have N instances of the source and destinations on different drives. This can lead to several undesirable situtations with or without errors and it's not entirely obvious what to do when an error occurs.
+
+Originally mergerfs would return EXDEV whenever a rename was requested which was cross directory in any way. This made the code simple and was technically complient with POSIX requirements. However, many applications fail to handle EXDEV at all and treat it as a normal error or they only partially support EXDEV (don't respond the same as `mv` would). Such apps include: gvfsd-fuse v1.20.3 and prior, Finder / CIFS/SMB client in Apple OSX 10.9+, NZBGet, Samba's recycling bin feature.
+
+* If using a policy which tries to preserve directories (epmfs,eplfs)
+  * Using the `rename` policy get the list of files to rename
+  * For each file attempt rename:
+    * If failure with ENOENT run `create` policy
+    * If create policy returns the same drive as currently evaluating then clone the path
+    * Re-attempt rename
+  * If **any** of the renames succeed the higher level rename is considered a success
+  * If **no** renames succeed the first error encountered will be returned
+  * On success:
+    * Remove the target from all drives with no source file
+    * Remove the source from all drives which failed to rename
+* If using a policy which does **not** try to preserve directories
+  * Using the `rename` policy get the list of files to rename
+  * Using the `getattr` policy get the target path
+  * For each file attempt rename:
+    * If the source drive != target drive:
+      * Clone target path from target drive to source drive
+    * Rename
+  * If **any** of the renames succeed the higher level rename is considered a success
+  * If **no** renames succeed the first error encountered will be returned
+  * On success:
+    * Remove the target from all drives with no source file
+    * Remove the source from all drives which failed to rename
+
+The the removals are subject to normal entitlement checks.
+
+The above behavior will help minimize the likelihood of EXDEV being returned but it will still be possible. To remove the possibility all together mergerfs would need to perform the as `mv` does when it receives EXDEV normally.
+
+`link` uses the same basic strategy.
+
 #### readdir ####
 
-[readdir](http://linux.die.net/man/3/readdir) is very different from most functions in this realm. It certainly could have it's own set of policies to tweak its behavior. At this time it provides a simple `first found` merging of directories and file found. That is: only the first file or directory found for a directory is returned. Given how FUSE works though the data representing the returned entry comes from `getattr`.
+[readdir](http://linux.die.net/man/3/readdir) is different from all other filesystem functions. It certainly could have it's own set of policies to tweak its behavior. At this time it provides a simple **first found** merging of directories and files found. That is: only the first file or directory found for a directory is returned. Given how FUSE works though the data representing the returned entry comes from **getattr**.
 
-It could be extended to offer the ability to see all files found. Perhaps concatinating `#` and a number to the name. But to really be useful you'd need to be able to access them which would complicate file lookup.
+It could be extended to offer the ability to see all files found. Perhaps concatenating **#** and a number to the name. But to really be useful you'd need to be able to access them which would complicate file lookup.
 
 #### statvfs ####
 
-[statvfs](http://linux.die.net/man/2/statvfs) normalizes the source drives based on the fragment size and sums the number of adjusted blocks and inodes. This means you will see the combined space of all sources. Total, used, and free. The sources however are dedupped based on the drive so multiple points on the same drive will not result in double counting it's space.
-
-**NOTE:** Since we can not (easily) replicate the atomicity of an `mkdir` or `mknod` without side effects those calls will first do a scan to see if the file exists and then attempts a create. This means there is a slight race condition. Worse case you'd end up with the directory or file on more than one mount.
+[statvfs](http://linux.die.net/man/2/statvfs) normalizes the source drives based on the fragment size and sums the number of adjusted blocks and inodes. This means you will see the combined space of all sources. Total, used, and free. The sources however are dedupped based on the drive so multiple sources on the same drive will not result in double counting it's space.
 
 # BUILDING
 
-* Need to install FUSE development libraries (libfuse-dev).
-* Optionally need libattr1 (libattr1-dev).
+**NOTE:** Prebuilt packages can be found at: https://github.com/trapexit/mergerfs/releases
 
+First get the code from [github](http://github.com/trapexit/mergerfs).
 
 ```
-[trapexit:~/dev/mergerfs] $ make help
-usage: make
-make XATTR_AVAILABLE=0 - to build program without xattrs functionality (auto discovered otherwise)
+$ git clone https://github.com/trapexit/mergerfs.git
+$ # or
+$ wget https://github.com/trapexit/mergerfs/archive/master.zip
 ```
 
-# Runtime Settings
+#### Debian / Ubuntu
+```
+$ sudo apt-get install g++ pkg-config git git-buildpackage pandoc debhelper libfuse-dev libattr1-dev python
+$ cd mergerfs
+$ make deb
+$ sudo dpkg -i ../mergerfs_version_arch.deb
+```
 
-#### /.mergerfs pseudo file ####
+#### Fedora
+```
+$ su -
+# dnf install rpm-build fuse-devel libattr-devel pandoc gcc-c++ git make which python
+# cd mergerfs
+# make rpm
+# rpm -i rpmbuild/RPMS/<arch>/mergerfs-<verion>.<arch>.rpm
+```
+
+#### Generically
+
+Have git, python, pkg-config, pandoc, libfuse, libattr1 installed.
+
+```
+$ cd mergerfs
+$ make
+$ make man
+$ sudo make install
+```
+
+# RUNTIME
+
+#### .mergerfs pseudo file ####
 ```
 <mountpoint>/.mergerfs
 ```
 
-There is a pseudo file available at the mountpoint which allows for the runtime modification of certain mergerfs options. The file will not show up in readdirs but can be stat'ed and manipulated via [{list,get,set}xattrs](http://linux.die.net/man/2/listxattr) calls.
+There is a pseudo file available at the mount point which allows for the runtime modification of certain **mergerfs** options. The file will not show up in **readdir** but can be **stat**'ed and manipulated via [{list,get,set}xattrs](http://linux.die.net/man/2/listxattr) calls.
 
 Even if xattrs are disabled the [{list,get,set}xattrs](http://linux.die.net/man/2/listxattr) calls will still work.
 
 ##### Keys #####
-* user.mergerfs.srcmounts
-* user.mergerfs.category.action
-* user.mergerfs.category.create
-* user.mergerfs.category.search
-* user.mergerfs.func.access
-* user.mergerfs.func.chmod
-* user.mergerfs.func.chown
-* user.mergerfs.func.create
-* user.mergerfs.func.getattr
-* user.mergerfs.func.getxattr
-* user.mergerfs.func.link
-* user.mergerfs.func.listxattr
-* user.mergerfs.func.mkdir
-* user.mergerfs.func.mknod
-* user.mergerfs.func.open
-* user.mergerfs.func.readlink
-* user.mergerfs.func.removexattr
-* user.mergerfs.func.rename
-* user.mergerfs.func.rmdir
-* user.mergerfs.func.setxattr
-* user.mergerfs.func.symlink
-* user.mergerfs.func.truncate
-* user.mergerfs.func.unlink
-* user.mergerfs.func.utimens
+
+Use `xattr -l /mount/point/.mergerfs` to see all supported keys.
+
+##### user.mergerfs.srcmounts #####
+
+For **user.mergerfs.srcmounts** there are several instructions available for manipulating the list. The value provided is just as the value used at mount time. A colon (':') delimited list of full path globs.
+
+| Instruction | Description |
+|--------------|-------------|
+| [list]       | set |
+| +<[list]     | prepend |
+| +>[list]     | append |
+| -[list]      | remove all values provided |
+| -<           | remove first in list |
+| ->           | remove last in list |
+
+##### minfreespace #####
+
+Input: interger with an optional multiplier suffix. **K**, **M**, or **G**.
+
+Output: value in bytes
+
+##### moveonenospc #####
+
+Input: **true** and **false**
+
+Ouput: **true** or **false**
+
+##### categories / funcs #####
+
+Input: short policy string as described elsewhere in this document
+
+Output: the policy string except for categories where its funcs have multiple types. In that case it will be a comma separated list
 
 ##### Example #####
 
 ```
 [trapexit:/tmp/mount] $ xattr -l .mergerfs
 user.mergerfs.srcmounts: /tmp/a:/tmp/b
-user.mergerfs.category.action: all
-user.mergerfs.category.create: epmfs
-user.mergerfs.category.search: ff
-user.mergerfs.func.access: ff
-user.mergerfs.func.chmod: all
-user.mergerfs.func.chown: all
-user.mergerfs.func.create: epmfs
-user.mergerfs.func.getattr: ff
-user.mergerfs.func.getxattr: ff
-user.mergerfs.func.link: all
-user.mergerfs.func.listxattr: ff
-user.mergerfs.func.mkdir: epmfs
-user.mergerfs.func.mknod: epmfs
-user.mergerfs.func.open: ff
-user.mergerfs.func.readlink: ff
-user.mergerfs.func.removexattr: all
-user.mergerfs.func.rename: all
-user.mergerfs.func.rmdir: all
-user.mergerfs.func.setxattr: all
-user.mergerfs.func.symlink: epmfs
-user.mergerfs.func.truncate: all
-user.mergerfs.func.unlink: all
-user.mergerfs.func.utimens: all
+user.mergerfs.minfreespace: 4294967295
+user.mergerfs.moveonenospc: false
+...
 
 [trapexit:/tmp/mount] $ xattr -p user.mergerfs.category.search .mergerfs
 ff
 
-[trapexit:/tmp/mount] $ xattr -w user.mergerfs.category.search ffwp .mergerfs
+[trapexit:/tmp/mount] $ xattr -w user.mergerfs.category.search newest .mergerfs
 [trapexit:/tmp/mount] $ xattr -p user.mergerfs.category.search .mergerfs
-ffwp
+newest
 
 [trapexit:/tmp/mount] $ xattr -w user.mergerfs.srcmounts +/tmp/c .mergerfs
 [trapexit:/tmp/mount] $ xattr -p user.mergerfs.srcmounts .mergerfs
@@ -215,32 +261,13 @@ ffwp
 /tmp/a:/tmp/b:/tmp/c
 ```
 
-##### user.mergerfs.srcmounts #####
-
-For **user.mergerfs.srcmounts** there are several instructions available for manipulating the list. The value provided is just as the value used at mount time. A colon (':') delimited list of full path globs.
-
-| Instruction | Description |
-|--------------|-------------|
-| +[list] | append |
-| +<[list] | prepend |
-| +>[list] | append |
-| -[list] | remove all values provided |
-| -< | remove first in list |
-| -> | remove last in list |
-| =[list] | set |
-| [list] | set |
-
-##### misc #####
-
-Categories and funcs take a policy as described in the previous section. When reading funcs you'll get the policy string. However, with categories you'll get a coma separated list of policies for each type found. For example: if all search functions are `ff` except for `access` which is `ffwp` the value for `user.mergerfs.category.search` will be `ff,ffwp`.
-
 #### mergerfs file xattrs ####
 
-While they won't show up when using [listxattr](http://linux.die.net/man/2/listxattr) mergerfs offers a number of special xattrs to query information about the files served. To access the values you will need to issue a [getxattr](http://linux.die.net/man/2/getxattr) for one of the following:
+While they won't show up when using [listxattr](http://linux.die.net/man/2/listxattr) **mergerfs** offers a number of special xattrs to query information about the files served. To access the values you will need to issue a [getxattr](http://linux.die.net/man/2/getxattr) for one of the following:
 
-* **user.mergerfs.basepath:** the base mount point for the file given the current search policy
+* **user.mergerfs.basepath:** the base mount point for the file given the current getattr policy
 * **user.mergerfs.relpath:** the relative path of the file from the perspective of the mount point
-* **user.mergerfs.fullpath:** the full path of the original file given the search policy
+* **user.mergerfs.fullpath:** the full path of the original file given the getattr policy
 * **user.mergerfs.allpaths:** a NUL ('\0') separated list of full paths to all files found
 
 ```
@@ -257,27 +284,90 @@ A B C
 /mnt/b/full/path/to/A
 ```
 
-# Tips / Notes
+# TOOLING
 
-* The recommended options are `defaults,allow_other`. The `allow_other` is to allow users who are not the one which executed mergerfs access to the mountpoint. `defaults` is described above and should offer the best performance. It's possible that if you're running on an older platform the `splice` features aren't available and could error. In that case simply use the other options manually.
-* Remember that some policies mixed with some functions may result in strange behaviors. Not that some of these behaviors and race conditions couldn't happen outside [mergerfs](http://github.com/trapexit/mergerfs) but that they are far more likely to occur on account of attempt to merge together multiple sources of data which could be out of sync due to the different policies.
-* An example: [Kodi](http://kodi.tv) can apparently use directory [mtime](http://linux.die.net/man/2/stat) to more efficiently determine whether or not to scan for new content rather than simply performing a full scan. If using the current default `getattr` policy of `ff` it's possible Kodi will miss an update on account of it returning the first directory found's `stat` info and its a later directory on another mount which had the `mtime` recently updated. To fix this you will want to set `func.getattr=newest`. Remember though that this is just `stat`. If the file is later `open`ed or `unlink`ed and the policy is different for those then a completely different file or directory could be acted on.
-* Due to previously mentioned issues its generally best to set `category` wide policies rather than individual `func`s. This will help limit the confusion of tools such as [rsync](http://linux.die.net/man/1/rsync).
+Find tooling to help with managing `mergerfs` at: https://github.com/trapexit/mergerfs-tools
+
+* mergerfs.fsck: Provides permissions and ownership auditing and the ability to fix them
+* mergerfs.mktrash: Creates FreeDesktop.org Trash specification compatible directories on a mergerfs mount
+
+# TIPS / NOTES
+
+* Detailed guides to setting up a backup solution using mergerfs and other technologies: https://github.com/trapexit/backup-and-recovery-howtos
+* If you don't see some directories / files you expect in a merged point be sure the user has permission to all the underlying directories. If `/drive0/a` has is owned by `root:root` with ACLs set to `0700` and `/drive1/a` is `root:root` and `0755` you'll see only `/drive1/a`. Use `mergerfs.fsck` to audit the drive for out of sync permissions.
+* Since POSIX gives you only error or success on calls its difficult to determine the proper behavior when applying the behavior to multiple targets. **mergerfs** will return an error only if all attempts of an action fail. Any success will lead to a success returned.
+* The recommended options are **defaults,allow_other**. The **allow_other** is to allow users who are not the one which executed mergerfs access to the mountpoint. **defaults** is described above and should offer the best performance. It's possible that if you're running on an older platform the **splice** features aren't available and could error. In that case simply use the other options manually.
+* If write performance is valued more than read it may be useful to enable **direct_io**. Best to benchmark with and without and choose appropriately.
+* Remember: some policies mixed with some functions may result in strange behaviors. Not that some of these behaviors and race conditions couldn't happen outside **mergerfs** but that they are far more likely to occur on account of attempt to merge together multiple sources of data which could be out of sync due to the different policies.
+* An example: [Kodi](http://kodi.tv) and [Plex](http://plex.tv) can use directory [mtime](http://linux.die.net/man/2/stat) to more efficiently determine whether to scan for new content rather than simply performing a full scan. If using the current default **getattr** policy of **ff** its possible **Kodi** will miss an update on account of it returning the first directory found's **stat** info and its a later directory on another mount which had the **mtime** recently updated. To fix this you will want to set **func.getattr=newest**. Remember though that this is just **stat**. If the file is later **open**'ed or **unlink**'ed and the policy is different for those then a completely different file or directory could be acted on.
+* Due to previously mentioned issues its generally best to set **category** wide policies rather than individual **func**'s. This will help limit the confusion of tools such as [rsync](http://linux.die.net/man/1/rsync).
+
+# KNOWN ISSUES / BUGS
+
+#### Trashing files occasionally fails
+
+This is the same issue as with Samba. `rename` returns `EXDEV` (in our case that will really only happen with path preserving policies like `epmfs`) and the software doesn't handle the situtation well. This is unfortunately a common failure of software which moves files around. The standard indicates that an implementation `MAY` choose to support non-user home directory trashing of files (which is a `MUST`). The implementation `MAY` also support "top directory trashes" which many probably do. 
+
+To create a `$topdir/.Trash` directory as defined in the standard use the [mergerfs-tools](https://github.com/trapexit/mergerfs-tools) tool `mergerfs.mktrash`.
+
+#### Samba: Moving files / directories fails
+
+Workaround: Copy the file/directory and then remove the original rather than move.
+
+This isn't an issue with Samba but some SMB clients. GVFS-fuse v1.20.3 and prior (found in Ubuntu 14.04 among others) failed to handle certain error codes correctly. Particularly **STATUS_NOT_SAME_DEVICE** which comes from the **EXDEV** which is returned by **rename** when the call is crossing mount points. When a program gets an **EXDEV** it needs to explicitly take an alternate action to accomplish it's goal. In the case of **mv** or similar it tries **rename** and on **EXDEV** falls back to a manual copying of data between the two locations and unlinking the source. In these older versions of GVFS-fuse if it received **EXDEV** it would translate that into **EIO**. This would cause **mv** or most any application attempting to move files around on that SMB share to fail with a IO error.
+
+[GVFS-fuse v1.22.0](https://bugzilla.gnome.org/show_bug.cgi?id=734568) and above fixed this issue but a large number of systems use the older release. On Ubuntu the version can be checked by issuing `apt-cache showpkg gvfs-fuse`. Most distros released in 2015 seem to have the updated release and will work fine but older systems may not. Upgrading gvfs-fuse or the distro in general will address the problem.
+
+In Apple's MacOSX 10.9 they replaced Samba (client and server) with their own product. It appears their new client does not handle **EXDEV** either and responds similar to older release of gvfs on Linux.
+
+#### Supplemental user groups
+
+Due to the overhead of [getgroups/setgroups](http://linux.die.net/man/2/setgroups) mergerfs utilizes a cache. This cache is opportunistic and per thread. Each thread will query the supplemental groups for a user when that particular thread needs to change credentials and will keep that data for the lifetime of the thread. This means that if a user is added to a group it may not be picked up without the restart of mergerfs. However, since the high level FUSE API's (at least the standard version) thread pool dynamically grows and shrinks it's possible that over time a thread will be killed and later a new thread with no cache will start and query the new data.
+
+The gid cache uses fixed storage to simplify the design and be compatible with older systems which may not have C++11 compilers. There is enough storage for 256 users' supplemental groups. Each user is allowed upto 32 supplemental groups. Linux >= 2.6.3 allows upto 65535 groups per user but most other *nixs allow far less. NFS allowing only 16. The system does handle overflow gracefully. If the user has more than 32 supplemental groups only the first 32 will be used. If more than 256 users are using the system when an uncached user is found it will evict an existing user's cache at random. So long as there aren't more than 256 active users this should be fine. If either value is too low for your needs you will have to modify `gidcache.hpp` to increase the values. Note that doing so will increase the memory needed by each thread.
+
+#### mergerfs or libfuse crashing
+
+If suddenly the mergerfs mount point disappears and `Transport endpoint is not connected` is returned when attempting to perform actions within the mount directory **and** the version of libfuse (use `mergerfs -v` to find the version) is older than `2.9.4` its likely due to a bug in libfuse. Affected versions of libfuse can be found in Debian Wheezy, Ubuntu Precise and others.
+
+In order to fix this please install newer versions of libfuse. If using a Debian based distro (Debian,Ubuntu,Mint) you can likely just install newer versions of [libfuse](https://packages.debian.org/unstable/libfuse2) and [fuse](https://packages.debian.org/unstable/fuse) from the repo of a newer release.
 
 # FAQ
 
-#### It's mentioned that there are some security issues with `mhddfs`. What are they? How does `mergerfs` address them?
+#### Why use mergerfs over mhddfs?
 
-[mhddfs](https://github.com/trapexit/mhddfs) trys to handle being run as `root` by calling [getuid()](https://github.com/trapexit/mhddfs/blob/cae96e6251dd91e2bdc24800b4a18a74044f6672/src/main.c#L319) and if it returns `0` then it will [chown](http://linux.die.net/man/1/chown) the file. Not only is that a race condition but it doesn't handle many other situtations. Rather than attempting to simulate POSIX ACL behaviors the proper behavior is to use [seteuid](http://linux.die.net/man/2/seteuid) and [setegid](http://linux.die.net/man/2/setegid), become the user making the original call and perform the action as them. This is how [mergerfs](https://github.com/trapexit/mergerfs) handles things.
+mhddfs is no longer maintained and has some known stability and security issues (see below).
 
-If you are familiar with POSIX standards you'll know that this behavior poses a problem. `seteuid` and `setegid` affect the whole process and `libfuse` is multithreaded by default. We'd need to lock access to `seteuid` and `setegid` with a mutex so that the several threads aren't stepping on one another and files end up with weird permissions and ownership. This however wouldn't scale well. With lots of calls the contention on that mutex would be extremely high. Thankfully on Linux and OSX we have a better solution.
+#### Why use mergerfs over aufs?
 
-OSX has a [non-portable pthread extension](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html) for per-thread user and group impersonation. When building on OSX mergerfs will use this without any mutexes.
+While aufs can offer better peak performance mergerfs offers more configurability and is generally easier to use. mergerfs however doesn't offer the overlay features which tends to result in whiteout files being left around the underlying filesystems.
 
-Linux does not support [pthread_setugid_np](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html) but user and group IDs are a per-thread attribute though documention on that fact or how to manipulate them is not well distributed. From the `4.00` release of the Linux man-pages project for [setuid](http://man7.org/linux/man-pages/man2/setuid.2.html)
+#### Why use mergerfs over LVM/ZFS/BTRFS/RAID0 drive concatenation / striping?
+
+A single drive failure will lead to full pool failure without additional redundancy. mergerfs performs a similar behavior without the catastrophic failure and lack of recovery. Drives can fail and all other data will continue to be accessable.
+
+#### It's mentioned that there are some security issues with mhddfs. What are they? How does mergerfs address them?
+
+[mhddfs](https://github.com/trapexit/mhddfs) tries to handle being run as **root** by calling [getuid()](https://github.com/trapexit/mhddfs/blob/cae96e6251dd91e2bdc24800b4a18a74044f6672/src/main.c#L319) and if it returns **0** then it will [chown](http://linux.die.net/man/1/chown) the file. Not only is that a race condition but it doesn't handle many other situations. Rather than attempting to simulate POSIX ACL behaviors the proper behavior is to use [seteuid](http://linux.die.net/man/2/seteuid) and [setegid](http://linux.die.net/man/2/setegid), become the user making the original call and perform the action as them. This is how [mergerfs](https://github.com/trapexit/mergerfs) handles things.
+
+If you are familiar with POSIX standards you'll know that this behavior poses a problem. **seteuid** and **setegid** affect the whole process and **libfuse** is multithreaded by default. We'd need to lock access to **seteuid** and **setegid** with a mutex so that the several threads aren't stepping on one anofther and files end up with weird permissions and ownership. This however wouldn't scale well. With lots of calls the contention on that mutex would be extremely high. Thankfully on Linux and OSX we have a better solution.
+
+OSX has a [non-portable pthread extension](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html) for per-thread user and group impersonation.
+
+Linux does not support [pthread_setugid_np](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html) but user and group IDs are a per-thread attribute though documentation on that fact or how to manipulate them is not well distributed. From the **4.00** release of the Linux man-pages project for [setuid](http://man7.org/linux/man-pages/man2/setuid.2.html).
 
 > At the kernel level, user IDs and group IDs are a per-thread attribute.  However, POSIX requires that all threads in a process share the same credentials.  The NPTL threading implementation handles the POSIX requirements by providing wrapper functions for the various system calls that change process UIDs and GIDs.  These wrapper functions (including the one for setuid()) employ a signal-based technique to ensure that when one thread changes credentials, all of the other threads in the process also change their credentials.  For details, see nptl(7).
 
-Turns out the setreuid syscalls apply only to the thread. GLIBC hides this away using RT signals and other tricks. Taking after Samba mergerfs uses `syscall(SYS_setreuid,...)` to set the callers credentials for that thread only. Jumping back to `root` as necessary should escalated privilages be needed (for instance: to clone paths).
+Turns out the setreuid syscalls apply only to the thread. GLIBC hides this away using RT signals to inform all threads to change credentials. Taking after **Samba** mergerfs uses **syscall(SYS_setreuid,...)** to set the callers credentials for that thread only. Jumping back to **root** as necessary should escalated privileges be needed (for instance: to clone paths).
 
+For non-Linux systems mergerfs uses a read-write lock and changes credentials only when necessary. If multiple threads are to be user X then only the first one will need to change the processes credentials. So long as the other threads need to be user X they will take a readlock allow multiple threads to share the credentials. Once a request comes in to run as user Y that thread will attempt a write lock and change to Y's credentials when it can. If the ability to give writers priority is supported then that flag will be used so threads trying to change credentials don't starve. This isn't the best solution but should work reasonably well. As new platforms are supported if they offer per thread credentials those APIs will be adopted.
 
+# SUPPORT
+
+#### Issues with the software
+* github.com: https://github.com/trapexit/mergerfs/issues
+* email: trapexit@spawn.link
+
+#### Support development
+* Gratipay: https://gratipay.com/~trapexit
+* BitCoin: 12CdMhEPQVmjz3SSynkAEuD5q9JmhTDCZA

debian/copyright

@@ -4,28 +4,22 @@ Source: http://github.com/trapexit/mergerfs
 
 Files: *
 Copyright: 2014 Antonio SJ Musumeci <trapexit@spawn.link>
-License: MIT
+License: ISC
 
 Files: debian/*
 Copyright: 2014 Antonio SJ Musumeci <trapexit@spawn.link>
-License: MIT
+License: ISC
 
-License: MIT
- Permission is hereby granted, free of charge, to any person obtaining a
- copy of this software and associated documentation files (the "Software"),
- to deal in the Software without restriction, including without limitation
- the rights to use, copy, modify, merge, publish, distribute, sublicense,
- and/or sell copies of the Software, and to permit persons to whom the
- Software is furnished to do so, subject to the following conditions:
- .
- The above copyright notice and this permission notice shall be included
- in all copies or substantial portions of the Software.
- .
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
- OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-n
+License: ISC
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+  .
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+n

debian/rules

@@ -6,3 +6,6 @@
 
 %:
 	dh $@
+
+override_dh_auto_install:
+	$(MAKE) DESTDIR=$(CURDIR)/debian/mergerfs PREFIX=/usr install

man/mergerfs.1

@@ -0,0 +1,857 @@
+.\"t
+.TH "mergerfs" "1" "2016\-02\-21" "mergerfs user manual" ""
+.SH NAME
+.PP
+mergerfs \- another (FUSE based) union filesystem
+.SH SYNOPSIS
+.PP
+mergerfs \-o<options> <srcmounts> <mountpoint>
+.SH DESCRIPTION
+.PP
+\f[B]mergerfs\f[] is a union filesystem geared towards simplifing
+storage and management of files across numerous commodity storage
+devices.
+It is similar to \f[B]mhddfs\f[], \f[B]unionfs\f[], and \f[B]aufs\f[].
+.SH FEATURES
+.IP \[bu] 2
+Runs in userspace (FUSE)
+.IP \[bu] 2
+Configurable behaviors
+.IP \[bu] 2
+Support for extended attributes (xattrs)
+.IP \[bu] 2
+Support for file attributes (chattr)
+.IP \[bu] 2
+Runtime configurable (via xattrs)
+.IP \[bu] 2
+Safe to run as root
+.IP \[bu] 2
+Opportunistic credential caching
+.IP \[bu] 2
+Works with heterogeneous filesystem types
+.IP \[bu] 2
+Handling of writes to full drives
+.IP \[bu] 2
+Handles pool of readonly and read/write drives
+.SH OPTIONS
+.SS options
+.IP \[bu] 2
+\f[B]defaults\f[]: a shortcut for FUSE\[aq]s \f[B]atomic_o_trunc\f[],
+\f[B]auto_cache\f[], \f[B]big_writes\f[], \f[B]default_permissions\f[],
+\f[B]splice_move\f[], \f[B]splice_read\f[], and \f[B]splice_write\f[].
+These options seem to provide the best performance.
+.IP \[bu] 2
+\f[B]direct_io\f[]: causes FUSE to bypass an addition caching step which
+can increase write speeds at the detriment of read speed.
+.IP \[bu] 2
+\f[B]minfreespace\f[]: the minimum space value used for creation
+policies.
+Understands \[aq]K\[aq], \[aq]M\[aq], and \[aq]G\[aq] to represent
+kilobyte, megabyte, and gigabyte respectively.
+(default: 4G)
+.IP \[bu] 2
+\f[B]moveonenospc\f[]: when enabled (set to \f[B]true\f[]) if a
+\f[B]write\f[] fails with \f[B]ENOSPC\f[] a scan of all drives will be
+done looking for the drive with most free space which is at least the
+size of the file plus the amount which failed to write.
+An attempt to move the file to that drive will occur (keeping all
+metadata possible) and if successful the original is unlinked and the
+write retried.
+(default: false)
+.IP \[bu] 2
+\f[B]func.<func>=<policy>\f[]: sets the specific FUSE function\[aq]s
+policy.
+See below for the list of value types.
+Example: \f[B]func.getattr=newest\f[]
+.IP \[bu] 2
+\f[B]category.<category>=<policy>\f[]: Sets policy of all FUSE functions
+in the provided category.
+Example: \f[B]category.create=mfs\f[]
+.PP
+\f[B]NOTE:\f[] Options are evaluated in the order listed so if the
+options are \f[B]func.rmdir=rand,category.action=ff\f[] the
+\f[B]action\f[] category setting will override the \f[B]rmdir\f[]
+setting.
+.SS srcmounts
+.PP
+The source mounts argument is a colon (\[aq]:\[aq]) delimited list of
+paths.
+To make it simpler to include multiple source mounts without having to
+modify your fstab (http://linux.die.net/man/5/fstab) we also support
+globbing (http://linux.die.net/man/7/glob).
+\f[B]The globbing tokens MUST be escaped when using via the shell else
+the shell itself will probably expand it.\f[]
+.IP
+.nf
+\f[C]
+$\ mergerfs\ /mnt/disk\\*:/mnt/cdrom\ /media/drives
+\f[]
+.fi
+.PP
+The above line will use all mount points in /mnt prefixed with
+\f[I]disk\f[] and the directory \f[I]cdrom\f[].
+.PP
+In /etc/fstab it\[aq]d look like the following:
+.IP
+.nf
+\f[C]
+#\ <file\ system>\ \ \ \ \ \ \ \ <mount\ point>\ \ <type>\ \ \ \ \ \ \ \ \ <options>\ \ \ \ \ \ \ \ \ \ \ \ \ <dump>\ \ <pass>
+/mnt/disk*:/mnt/cdrom\ \ /media/drives\ \ fuse.mergerfs\ \ defaults,allow_other\ \ 0\ \ \ \ \ \ \ 0
+\f[]
+.fi
+.PP
+\f[B]NOTE:\f[] the globbing is done at mount or xattr update time.
+If a new directory is added matching the glob after the fact it will not
+be included.
+.SH FUNCTIONS / POLICIES / CATEGORIES
+.PP
+The filesystem has a number of functions.
+Those functions are grouped into 3 categories: \f[B]action\f[],
+\f[B]create\f[], \f[B]search\f[].
+These functions and categories can be assigned a policy which dictates
+how \f[B]mergerfs\f[] behaves.
+Any policy can be assigned to a function or category though some are not
+very practical.
+For instance: \f[B]rand\f[] (Random) may be useful for file creation
+(create) but could lead to very odd behavior if used for \f[C]chmod\f[].
+.PP
+All policies when used to create will ignore drives which are mounted
+readonly.
+This allows for read/write and readonly drives to be mixed together.
+.SS Function / Category classifications
+.PP
+.TS
+tab(@);
+l l.
+T{
+Category
+T}@T{
+FUSE Functions
+T}
+_
+T{
+action
+T}@T{
+chmod, chown, link, removexattr, rename, rmdir, setxattr, truncate,
+unlink, utimens
+T}
+T{
+create
+T}@T{
+create, mkdir, mknod, symlink
+T}
+T{
+search
+T}@T{
+access, getattr, getxattr, ioctl, listxattr, open, readlink
+T}
+T{
+N/A
+T}@T{
+fallocate, fgetattr, fsync, ftruncate, ioctl, read, readdir, release,
+statfs, write
+T}
+.TE
+.PP
+Due to FUSE limitations \f[B]ioctl\f[] behaves differently if its acting
+on a directory.
+It\[aq]ll use the \f[B]getattr\f[] policy to find and open the directory
+before issuing the \f[B]ioctl\f[].
+In other cases where something may be searched (to confirm a directory
+exists across all source mounts) then \f[B]getattr\f[] will be used.
+.SS Policy descriptions
+.PP
+Most policies when called to create will filter out drives which are
+readonly or have less than \f[B]minfreespace\f[].
+.PP
+.TS
+tab(@);
+l l.
+T{
+Policy
+T}@T{
+Description
+T}
+_
+T{
+all
+T}@T{
+Search category: acts like \f[B]ff\f[].
+Action category: apply to all found.
+Create category: for \f[B]mkdir\f[], \f[B]mknod\f[], and
+\f[B]symlink\f[] perform on all read/write drives with
+\f[B]minfreespace\f[].
+\f[B]create\f[] filters the same way but acts like \f[B]ff\f[].
+T}
+T{
+eplfs (existing path, least free space)
+T}@T{
+If the path exists on multiple drives use the one with the least free
+space.
+Falls back to \f[B]lfs\f[].
+T}
+T{
+epmfs (existing path, most free space)
+T}@T{
+If the path exists on multiple drives use the one with the most free
+space.
+Falls back to \f[B]mfs\f[].
+T}
+T{
+erofs
+T}@T{
+Exclusively return \f[B]\-1\f[] with \f[B]errno\f[] set to
+\f[B]EROFS\f[].
+By setting \f[B]create\f[] functions to this you can in effect turn the
+filesystem readonly.
+T}
+T{
+ff (first found)
+T}@T{
+Given the order of the drives, as defined at mount time or when
+configured via xattr interface, act on the first one found.
+T}
+T{
+lfs (least free space)
+T}@T{
+Pick the drive with the least available free space but more than
+\f[B]minfreespace\f[].
+Falls back to \f[B]mfs\f[].
+T}
+T{
+mfs (most free space)
+T}@T{
+Use the drive with the most available free space.
+Falls back to \f[B]ff\f[].
+T}
+T{
+newest (newest file)
+T}@T{
+Pick the file / directory with the largest mtime.
+T}
+T{
+rand (random)
+T}@T{
+Calls \f[B]all\f[] and then randomizes.
+T}
+.TE
+.SS Defaults
+.PP
+.TS
+tab(@);
+l l.
+T{
+Category
+T}@T{
+Policy
+T}
+_
+T{
+action
+T}@T{
+all
+T}
+T{
+create
+T}@T{
+epmfs
+T}
+T{
+search
+T}@T{
+ff
+T}
+.TE
+.SS rename & link
+.PP
+rename (http://man7.org/linux/man-pages/man2/rename.2.html) is a tricky
+function in a merged system.
+Normally if a rename can\[aq]t be done atomically due to the source and
+destination paths existing on different mount points it will return
+\f[C]\-1\f[] with \f[C]errno\ =\ EXDEV\f[].
+The atomic rename is most critical for replacing files in place
+atomically (such as securing writing to a temp file and then replacing a
+target).
+The problem is that by merging multiple paths you can have N instances
+of the source and destinations on different drives.
+This can lead to several undesirable situtations with or without errors
+and it\[aq]s not entirely obvious what to do when an error occurs.
+.PP
+Originally mergerfs would return EXDEV whenever a rename was requested
+which was cross directory in any way.
+This made the code simple and was technically complient with POSIX
+requirements.
+However, many applications fail to handle EXDEV at all and treat it as a
+normal error or they only partially support EXDEV (don\[aq]t respond the
+same as \f[C]mv\f[] would).
+Such apps include: gvfsd\-fuse v1.20.3 and prior, Finder / CIFS/SMB
+client in Apple OSX 10.9+, NZBGet, Samba\[aq]s recycling bin feature.
+.IP \[bu] 2
+If using a policy which tries to preserve directories (epmfs,eplfs)
+.IP \[bu] 2
+Using the \f[C]rename\f[] policy get the list of files to rename
+.IP \[bu] 2
+For each file attempt rename:
+.RS 2
+.IP \[bu] 2
+If failure with ENOENT run \f[C]create\f[] policy
+.IP \[bu] 2
+If create policy returns the same drive as currently evaluating then
+clone the path
+.IP \[bu] 2
+Re\-attempt rename
+.RE
+.IP \[bu] 2
+If \f[B]any\f[] of the renames succeed the higher level rename is
+considered a success
+.IP \[bu] 2
+If \f[B]no\f[] renames succeed the first error encountered will be
+returned
+.IP \[bu] 2
+On success:
+.RS 2
+.IP \[bu] 2
+Remove the target from all drives with no source file
+.IP \[bu] 2
+Remove the source from all drives which failed to rename
+.RE
+.IP \[bu] 2
+If using a policy which does \f[B]not\f[] try to preserve directories
+.IP \[bu] 2
+Using the \f[C]rename\f[] policy get the list of files to rename
+.IP \[bu] 2
+Using the \f[C]getattr\f[] policy get the target path
+.IP \[bu] 2
+For each file attempt rename:
+.RS 2
+.IP \[bu] 2
+If the source drive != target drive:
+.IP \[bu] 2
+Clone target path from target drive to source drive
+.IP \[bu] 2
+Rename
+.RE
+.IP \[bu] 2
+If \f[B]any\f[] of the renames succeed the higher level rename is
+considered a success
+.IP \[bu] 2
+If \f[B]no\f[] renames succeed the first error encountered will be
+returned
+.IP \[bu] 2
+On success:
+.RS 2
+.IP \[bu] 2
+Remove the target from all drives with no source file
+.IP \[bu] 2
+Remove the source from all drives which failed to rename
+.RE
+.PP
+The the removals are subject to normal entitlement checks.
+.PP
+The above behavior will help minimize the likelihood of EXDEV being
+returned but it will still be possible.
+To remove the possibility all together mergerfs would need to perform
+the as \f[C]mv\f[] does when it receives EXDEV normally.
+.PP
+\f[C]link\f[] uses the same basic strategy.
+.SS readdir
+.PP
+readdir (http://linux.die.net/man/3/readdir) is different from all other
+filesystem functions.
+It certainly could have it\[aq]s own set of policies to tweak its
+behavior.
+At this time it provides a simple \f[B]first found\f[] merging of
+directories and files found.
+That is: only the first file or directory found for a directory is
+returned.
+Given how FUSE works though the data representing the returned entry
+comes from \f[B]getattr\f[].
+.PP
+It could be extended to offer the ability to see all files found.
+Perhaps concatenating \f[B]#\f[] and a number to the name.
+But to really be useful you\[aq]d need to be able to access them which
+would complicate file lookup.
+.SS statvfs
+.PP
+statvfs (http://linux.die.net/man/2/statvfs) normalizes the source
+drives based on the fragment size and sums the number of adjusted blocks
+and inodes.
+This means you will see the combined space of all sources.
+Total, used, and free.
+The sources however are dedupped based on the drive so multiple sources
+on the same drive will not result in double counting it\[aq]s space.
+.SH BUILDING
+.PP
+\f[B]NOTE:\f[] Prebuilt packages can be found at:
+https://github.com/trapexit/mergerfs/releases
+.PP
+First get the code from github (http://github.com/trapexit/mergerfs).
+.IP
+.nf
+\f[C]
+$\ git\ clone\ https://github.com/trapexit/mergerfs.git
+$\ #\ or
+$\ wget\ https://github.com/trapexit/mergerfs/archive/master.zip
+\f[]
+.fi
+.SS Debian / Ubuntu
+.IP
+.nf
+\f[C]
+$\ sudo\ apt\-get\ install\ g++\ pkg\-config\ git\ git\-buildpackage\ pandoc\ debhelper\ libfuse\-dev\ libattr1\-dev\ python
+$\ cd\ mergerfs
+$\ make\ deb
+$\ sudo\ dpkg\ \-i\ ../mergerfs_version_arch.deb
+\f[]
+.fi
+.SS Fedora
+.IP
+.nf
+\f[C]
+$\ su\ \-
+#\ dnf\ install\ rpm\-build\ fuse\-devel\ libattr\-devel\ pandoc\ gcc\-c++\ git\ make\ which\ python
+#\ cd\ mergerfs
+#\ make\ rpm
+#\ rpm\ \-i\ rpmbuild/RPMS/<arch>/mergerfs\-<verion>.<arch>.rpm
+\f[]
+.fi
+.SS Generically
+.PP
+Have git, python, pkg\-config, pandoc, libfuse, libattr1 installed.
+.IP
+.nf
+\f[C]
+$\ cd\ mergerfs
+$\ make
+$\ make\ man
+$\ sudo\ make\ install
+\f[]
+.fi
+.SH RUNTIME
+.SS \&.mergerfs pseudo file
+.IP
+.nf
+\f[C]
+<mountpoint>/.mergerfs
+\f[]
+.fi
+.PP
+There is a pseudo file available at the mount point which allows for the
+runtime modification of certain \f[B]mergerfs\f[] options.
+The file will not show up in \f[B]readdir\f[] but can be
+\f[B]stat\f[]\[aq]ed and manipulated via
+{list,get,set}xattrs (http://linux.die.net/man/2/listxattr) calls.
+.PP
+Even if xattrs are disabled the
+{list,get,set}xattrs (http://linux.die.net/man/2/listxattr) calls will
+still work.
+.SS Keys
+.PP
+Use \f[C]xattr\ \-l\ /mount/point/.mergerfs\f[] to see all supported
+keys.
+.SS user.mergerfs.srcmounts
+.PP
+For \f[B]user.mergerfs.srcmounts\f[] there are several instructions
+available for manipulating the list.
+The value provided is just as the value used at mount time.
+A colon (\[aq]:\[aq]) delimited list of full path globs.
+.PP
+.TS
+tab(@);
+l l.
+T{
+Instruction
+T}@T{
+Description
+T}
+_
+T{
+[list]
+T}@T{
+set
+T}
+T{
++<[list]
+T}@T{
+prepend
+T}
+T{
++>[list]
+T}@T{
+append
+T}
+T{
+\-[list]
+T}@T{
+remove all values provided
+T}
+T{
+\-<
+T}@T{
+remove first in list
+T}
+T{
+\->
+T}@T{
+remove last in list
+T}
+.TE
+.SS minfreespace
+.PP
+Input: interger with an optional multiplier suffix.
+\f[B]K\f[], \f[B]M\f[], or \f[B]G\f[].
+.PP
+Output: value in bytes
+.SS moveonenospc
+.PP
+Input: \f[B]true\f[] and \f[B]false\f[]
+.PP
+Ouput: \f[B]true\f[] or \f[B]false\f[]
+.SS categories / funcs
+.PP
+Input: short policy string as described elsewhere in this document
+.PP
+Output: the policy string except for categories where its funcs have
+multiple types.
+In that case it will be a comma separated list
+.SS Example
+.IP
+.nf
+\f[C]
+[trapexit:/tmp/mount]\ $\ xattr\ \-l\ .mergerfs
+user.mergerfs.srcmounts:\ /tmp/a:/tmp/b
+user.mergerfs.minfreespace:\ 4294967295
+user.mergerfs.moveonenospc:\ false
+\&...
+
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.category.search\ .mergerfs
+ff
+
+[trapexit:/tmp/mount]\ $\ xattr\ \-w\ user.mergerfs.category.search\ newest\ .mergerfs
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.category.search\ .mergerfs
+newest
+
+[trapexit:/tmp/mount]\ $\ xattr\ \-w\ user.mergerfs.srcmounts\ +/tmp/c\ .mergerfs
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.srcmounts\ .mergerfs
+/tmp/a:/tmp/b:/tmp/c
+
+[trapexit:/tmp/mount]\ $\ xattr\ \-w\ user.mergerfs.srcmounts\ =/tmp/c\ .mergerfs
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.srcmounts\ .mergerfs
+/tmp/c
+
+[trapexit:/tmp/mount]\ $\ xattr\ \-w\ user.mergerfs.srcmounts\ \[aq]+</tmp/a:/tmp/b\[aq]\ .mergerfs
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.srcmounts\ .mergerfs
+/tmp/a:/tmp/b:/tmp/c
+\f[]
+.fi
+.SS mergerfs file xattrs
+.PP
+While they won\[aq]t show up when using
+listxattr (http://linux.die.net/man/2/listxattr) \f[B]mergerfs\f[]
+offers a number of special xattrs to query information about the files
+served.
+To access the values you will need to issue a
+getxattr (http://linux.die.net/man/2/getxattr) for one of the following:
+.IP \[bu] 2
+\f[B]user.mergerfs.basepath:\f[] the base mount point for the file given
+the current getattr policy
+.IP \[bu] 2
+\f[B]user.mergerfs.relpath:\f[] the relative path of the file from the
+perspective of the mount point
+.IP \[bu] 2
+\f[B]user.mergerfs.fullpath:\f[] the full path of the original file
+given the getattr policy
+.IP \[bu] 2
+\f[B]user.mergerfs.allpaths:\f[] a NUL (\[aq]\[aq]) separated list of
+full paths to all files found
+.IP
+.nf
+\f[C]
+[trapexit:/tmp/mount]\ $\ ls
+A\ B\ C
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.fullpath\ A
+/mnt/a/full/path/to/A
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.basepath\ A
+/mnt/a
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.relpath\ A
+/full/path/to/A
+[trapexit:/tmp/mount]\ $\ xattr\ \-p\ user.mergerfs.allpaths\ A\ |\ tr\ \[aq]\\0\[aq]\ \[aq]\\n\[aq]
+/mnt/a/full/path/to/A
+/mnt/b/full/path/to/A
+\f[]
+.fi
+.SH TOOLING
+.PP
+Find tooling to help with managing \f[C]mergerfs\f[] at:
+https://github.com/trapexit/mergerfs\-tools
+.IP \[bu] 2
+fsck.mergerfs: Provides permissions and ownership auditing and the
+ability to fix them
+.IP \[bu] 2
+mergerfs.mktrash: Creates FreeDesktop.org Trash specification compatible
+directories on a mergerfs mount
+.SH TIPS / NOTES
+.IP \[bu] 2
+If you don\[aq]t see some directories / files you expect in a merged
+point be sure the user has permission to all the underlying directories.
+If \f[C]/drive0/a\f[] has is owned by \f[C]root:root\f[] with ACLs set
+to \f[C]0700\f[] and \f[C]/drive1/a\f[] is \f[C]root:root\f[] and
+\f[C]0755\f[] you\[aq]ll see only \f[C]/drive1/a\f[].
+Use \f[C]fsck.mergerfs\f[] to audit the drive for out of sync
+permissions.
+.IP \[bu] 2
+Since POSIX gives you only error or success on calls its difficult to
+determine the proper behavior when applying the behavior to multiple
+targets.
+\f[B]mergerfs\f[] will return an error only if all attempts of an action
+fail.
+Any success will lead to a success returned.
+.IP \[bu] 2
+The recommended options are \f[B]defaults,allow_other\f[].
+The \f[B]allow_other\f[] is to allow users who are not the one which
+executed mergerfs access to the mountpoint.
+\f[B]defaults\f[] is described above and should offer the best
+performance.
+It\[aq]s possible that if you\[aq]re running on an older platform the
+\f[B]splice\f[] features aren\[aq]t available and could error.
+In that case simply use the other options manually.
+.IP \[bu] 2
+If write performance is valued more than read it may be useful to enable
+\f[B]direct_io\f[].
+Best to benchmark with and without and choose appropriately.
+.IP \[bu] 2
+Remember: some policies mixed with some functions may result in strange
+behaviors.
+Not that some of these behaviors and race conditions couldn\[aq]t happen
+outside \f[B]mergerfs\f[] but that they are far more likely to occur on
+account of attempt to merge together multiple sources of data which
+could be out of sync due to the different policies.
+.IP \[bu] 2
+An example: Kodi (http://kodi.tv) and Plex (http://plex.tv) can use
+directory mtime (http://linux.die.net/man/2/stat) to more efficiently
+determine whether to scan for new content rather than simply performing
+a full scan.
+If using the current default \f[B]getattr\f[] policy of \f[B]ff\f[] its
+possible \f[B]Kodi\f[] will miss an update on account of it returning
+the first directory found\[aq]s \f[B]stat\f[] info and its a later
+directory on another mount which had the \f[B]mtime\f[] recently
+updated.
+To fix this you will want to set \f[B]func.getattr=newest\f[].
+Remember though that this is just \f[B]stat\f[].
+If the file is later \f[B]open\f[]\[aq]ed or \f[B]unlink\f[]\[aq]ed and
+the policy is different for those then a completely different file or
+directory could be acted on.
+.IP \[bu] 2
+Due to previously mentioned issues its generally best to set
+\f[B]category\f[] wide policies rather than individual
+\f[B]func\f[]\[aq]s.
+This will help limit the confusion of tools such as
+rsync (http://linux.die.net/man/1/rsync).
+.SH KNOWN ISSUES / BUGS
+.SS Trashing files occasionally fails
+.PP
+This is the same issue as with Samba.
+\f[C]rename\f[] returns \f[C]EXDEV\f[] (in our case that will really
+only happen with path preserving policies like \f[C]epmfs\f[]) and the
+software doesn\[aq]t handle the situtation well.
+This is unfortunately a common failure of software which moves files
+around.
+The standard indicates that an implementation \f[C]MAY\f[] choose to
+support non\-user home directory trashing of files (which is a
+\f[C]MUST\f[]).
+The implementation \f[C]MAY\f[] also support "top directory trashes"
+which many probably do.
+.PP
+To create a \f[C]$topdir/.Trash\f[] directory as defined in the standard
+use the mergerfs\-tools (https://github.com/trapexit/mergerfs-tools)
+tool \f[C]mergerfs.mktrash\f[].
+.SS Samba: Moving files / directories fails
+.PP
+Workaround: Copy the file/directory and then remove the original rather
+than move.
+.PP
+This isn\[aq]t an issue with Samba but some SMB clients.
+GVFS\-fuse v1.20.3 and prior (found in Ubuntu 14.04 among others) failed
+to handle certain error codes correctly.
+Particularly \f[B]STATUS_NOT_SAME_DEVICE\f[] which comes from the
+\f[B]EXDEV\f[] which is returned by \f[B]rename\f[] when the call is
+crossing mount points.
+When a program gets an \f[B]EXDEV\f[] it needs to explicitly take an
+alternate action to accomplish it\[aq]s goal.
+In the case of \f[B]mv\f[] or similar it tries \f[B]rename\f[] and on
+\f[B]EXDEV\f[] falls back to a manual copying of data between the two
+locations and unlinking the source.
+In these older versions of GVFS\-fuse if it received \f[B]EXDEV\f[] it
+would translate that into \f[B]EIO\f[].
+This would cause \f[B]mv\f[] or most any application attempting to move
+files around on that SMB share to fail with a IO error.
+.PP
+GVFS\-fuse v1.22.0 (https://bugzilla.gnome.org/show_bug.cgi?id=734568)
+and above fixed this issue but a large number of systems use the older
+release.
+On Ubuntu the version can be checked by issuing
+\f[C]apt\-cache\ showpkg\ gvfs\-fuse\f[].
+Most distros released in 2015 seem to have the updated release and will
+work fine but older systems may not.
+Upgrading gvfs\-fuse or the distro in general will address the problem.
+.PP
+In Apple\[aq]s MacOSX 10.9 they replaced Samba (client and server) with
+their own product.
+It appears their new client does not handle \f[B]EXDEV\f[] either and
+responds similar to older release of gvfs on Linux.
+.SS Supplemental user groups
+.PP
+Due to the overhead of
+getgroups/setgroups (http://linux.die.net/man/2/setgroups) mergerfs
+utilizes a cache.
+This cache is opportunistic and per thread.
+Each thread will query the supplemental groups for a user when that
+particular thread needs to change credentials and will keep that data
+for the lifetime of the thread.
+This means that if a user is added to a group it may not be picked up
+without the restart of mergerfs.
+However, since the high level FUSE API\[aq]s (at least the standard
+version) thread pool dynamically grows and shrinks it\[aq]s possible
+that over time a thread will be killed and later a new thread with no
+cache will start and query the new data.
+.PP
+The gid cache uses fixed storage to simplify the design and be
+compatible with older systems which may not have C++11 compilers.
+There is enough storage for 256 users\[aq] supplemental groups.
+Each user is allowed upto 32 supplemental groups.
+Linux >= 2.6.3 allows upto 65535 groups per user but most other *nixs
+allow far less.
+NFS allowing only 16.
+The system does handle overflow gracefully.
+If the user has more than 32 supplemental groups only the first 32 will
+be used.
+If more than 256 users are using the system when an uncached user is
+found it will evict an existing user\[aq]s cache at random.
+So long as there aren\[aq]t more than 256 active users this should be
+fine.
+If either value is too low for your needs you will have to modify
+\f[C]gidcache.hpp\f[] to increase the values.
+Note that doing so will increase the memory needed by each thread.
+.SS mergerfs or libfuse crashing
+.PP
+If suddenly the mergerfs mount point disappears and
+\f[C]Transport\ endpoint\ is\ not\ connected\f[] is returned when
+attempting to perform actions within the mount directory \f[B]and\f[]
+the version of libfuse (use \f[C]mergerfs\ \-v\f[] to find the version)
+is older than \f[C]2.9.4\f[] its likely due to a bug in libfuse.
+Affected versions of libfuse can be found in Debian Wheezy, Ubuntu
+Precise and others.
+.PP
+In order to fix this please install newer versions of libfuse.
+If using a Debian based distro (Debian,Ubuntu,Mint) you can likely just
+install newer versions of
+libfuse (https://packages.debian.org/unstable/libfuse2) and
+fuse (https://packages.debian.org/unstable/fuse) from the repo of a
+newer release.
+.SH FAQ
+.SS Why use mergerfs over mhddfs?
+.PP
+mhddfs is no longer maintained and has some known stability and security
+issues (see below).
+.SS Why use mergerfs over aufs?
+.PP
+While aufs can offer better peak performance mergerfs offers more
+configurability and is generally easier to use.
+mergerfs however doesn\[aq]t offer the overlay features which tends to
+result in whiteout files being left around the underlying filesystems.
+.SS Why use mergerfs over LVM/ZFS/BTRFS/RAID0 drive concatenation /
+striping?
+.PP
+A single drive failure will lead to full pool failure without additional
+redundancy.
+mergerfs performs a similar behavior without the catastrophic failure
+and lack of recovery.
+Drives can fail and all other data will continue to be accessable.
+.SS It\[aq]s mentioned that there are some security issues with mhddfs.
+What are they? How does mergerfs address them?
+.PP
+mhddfs (https://github.com/trapexit/mhddfs) tries to handle being run as
+\f[B]root\f[] by calling
+getuid() (https://github.com/trapexit/mhddfs/blob/cae96e6251dd91e2bdc24800b4a18a74044f6672/src/main.c#L319)
+and if it returns \f[B]0\f[] then it will
+chown (http://linux.die.net/man/1/chown) the file.
+Not only is that a race condition but it doesn\[aq]t handle many other
+situations.
+Rather than attempting to simulate POSIX ACL behaviors the proper
+behavior is to use seteuid (http://linux.die.net/man/2/seteuid) and
+setegid (http://linux.die.net/man/2/setegid), become the user making the
+original call and perform the action as them.
+This is how mergerfs (https://github.com/trapexit/mergerfs) handles
+things.
+.PP
+If you are familiar with POSIX standards you\[aq]ll know that this
+behavior poses a problem.
+\f[B]seteuid\f[] and \f[B]setegid\f[] affect the whole process and
+\f[B]libfuse\f[] is multithreaded by default.
+We\[aq]d need to lock access to \f[B]seteuid\f[] and \f[B]setegid\f[]
+with a mutex so that the several threads aren\[aq]t stepping on one
+another and files end up with weird permissions and ownership.
+This however wouldn\[aq]t scale well.
+With lots of calls the contention on that mutex would be extremely high.
+Thankfully on Linux and OSX we have a better solution.
+.PP
+OSX has a non\-portable pthread
+extension (https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html)
+for per\-thread user and group impersonation.
+.PP
+Linux does not support
+pthread_setugid_np (https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html)
+but user and group IDs are a per\-thread attribute though documentation
+on that fact or how to manipulate them is not well distributed.
+From the \f[B]4.00\f[] release of the Linux man\-pages project for
+setuid (http://man7.org/linux/man-pages/man2/setuid.2.html).
+.RS
+.PP
+At the kernel level, user IDs and group IDs are a per\-thread attribute.
+However, POSIX requires that all threads in a process share the same
+credentials.
+The NPTL threading implementation handles the POSIX requirements by
+providing wrapper functions for the various system calls that change
+process UIDs and GIDs.
+These wrapper functions (including the one for setuid()) employ a
+signal\-based technique to ensure that when one thread changes
+credentials, all of the other threads in the process also change their
+credentials.
+For details, see nptl(7).
+.RE
+.PP
+Turns out the setreuid syscalls apply only to the thread.
+GLIBC hides this away using RT signals to inform all threads to change
+credentials.
+Taking after \f[B]Samba\f[] mergerfs uses
+\f[B]syscall(SYS_setreuid,...)\f[] to set the callers credentials for
+that thread only.
+Jumping back to \f[B]root\f[] as necessary should escalated privileges
+be needed (for instance: to clone paths).
+.PP
+For non\-Linux systems mergerfs uses a read\-write lock and changes
+credentials only when necessary.
+If multiple threads are to be user X then only the first one will need
+to change the processes credentials.
+So long as the other threads need to be user X they will take a readlock
+allow multiple threads to share the credentials.
+Once a request comes in to run as user Y that thread will attempt a
+write lock and change to Y\[aq]s credentials when it can.
+If the ability to give writers priority is supported then that flag will
+be used so threads trying to change credentials don\[aq]t starve.
+This isn\[aq]t the best solution but should work reasonably well.
+As new platforms are supported if they offer per thread credentials
+those APIs will be adopted.
+.SH SUPPORT
+.SS Issues with the software
+.IP \[bu] 2
+github.com: https://github.com/trapexit/mergerfs/issues
+.IP \[bu] 2
+email: trapexit\@spawn.link
+.SS Support development
+.IP \[bu] 2
+Gratipay: https://gratipay.com/~trapexit
+.IP \[bu] 2
+BitCoin: 12CdMhEPQVmjz3SSynkAEuD5q9JmhTDCZA
+.SH AUTHORS
+Antonio SJ Musumeci <trapexit@spawn.link>.

mergerfs.spec

@@ -0,0 +1,51 @@
+Name:		mergerfs
+Version:	__VERSION__
+Release:	1%{?dist}
+Summary:	A FUSE union filesystem
+
+Group:		Applications/System
+License:	ISC
+URL:		https://github.com/trapexit/mergerfs
+
+Source:		mergerfs-%{version}.tar.gz
+
+BuildRequires:	gcc-c++
+BuildRequires:	libattr-devel
+BuildRequires:	fuse-devel
+# rpmbuild driven by the Makefile uses git to generate a version number
+BuildRequires:	git
+
+Requires:	fuse
+
+%prep
+%setup -q
+
+%description
+mergerfs is similar to mhddfs, unionfs, and aufs. Like mhddfs in that it too
+uses FUSE. Like aufs in that it provides multiple policies for how to handle
+behavior.
+
+%build
+make %{?_smp_mflags}
+
+%install
+make install PREFIX=%{_prefix} DESTDIR=%{buildroot}
+
+%files
+%{_bindir}/*
+%doc %{_mandir}/*
+
+%changelog
+* Mon Jan 25 2016 Antonio SJ Musumeci <trapexit@spawn.link>
+- Remove sbin files
+
+* Sat Sep 05 2015 Antonio SJ Musumeci <trapexit@spawn.link>
+- Include PREFIX to install
+
+* Mon Dec 29 2014 Joe Lawrence <joe.lawrence@stratus.com>
+- Tweak rpmbuild to archive current git HEAD into a tarball, then (re)build in
+  the rpmbuild directory -- more complicated but seemingly better suited to
+  generate source and debug rpms.
+
+* Fri Jun 20 2014 Joe Lawrence <joe.lawrence@stratus.com>
+- Initial rpm spec file.

src/access.cpp

@@ -1,82 +1,74 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#include <fuse.h>
-
 #include <string>
 #include <vector>
 
 #include <unistd.h>
 #include <errno.h>
 
-#include "ugid.hpp"
-#include "fs.hpp"
 #include "config.hpp"
+#include "fs_path.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
 using mergerfs::Policy;
+using mergerfs::Category;
 
 static
 int
-_access(const fs::find::Func  searchFunc,
+_access(Policy::Func::Search  searchFunc,
         const vector<string> &srcmounts,
-        const string         &fusepath,
+        const size_t          minfreespace,
+        const char           *fusepath,
         const int             mask)
 {
   int rv;
-  fs::Paths paths;
+  string fullpath;
+  vector<const string*> basepaths;
 
-  rv = searchFunc(srcmounts,fusepath,paths,1);
+  rv = searchFunc(srcmounts,fusepath,minfreespace,basepaths);
   if(rv == -1)
     return -errno;
 
-  rv = ::eaccess(paths[0].full.c_str(),mask);
+  fs::path::make(basepaths[0],fusepath,fullpath);
+
+  rv = ::eaccess(fullpath.c_str(),mask);
 
   return ((rv == -1) ? -errno : 0);
 }
 
 namespace mergerfs
 {
-  namespace access
+  namespace fuse
   {
     int
     access(const char *fusepath,
            int         mask)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _access(*config.access,
+      return _access(config.access,
                      config.srcmounts,
+                     config.minfreespace,
                      fusepath,
                      mask);
     }

src/access.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace access
+  namespace fuse
   {
     int
     access(const char *fusepath,

src/assert.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #define STATIC_ASSERT(cond) assert::StaticAssert< (cond) >()

src/buildmap.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <algorithm>

src/buildvector.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <algorithm>

src/category.cpp

@@ -1,25 +1,17 @@
 /*
-  The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-  Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <string>

src/category.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #ifndef __CATEGORY_HPP__

src/chmod.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -28,10 +20,11 @@
 #include <string>
 #include <vector>
 
-#include "ugid.hpp"
-#include "fs.hpp"
 #include "config.hpp"
+#include "fs_path.hpp"
+#include "rv.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
@@ -39,46 +32,72 @@ using mergerfs::Policy;
 
 static
 int
-_chmod(const fs::find::Func  actionFunc,
-       const vector<string> &srcmounts,
-       const string         &fusepath,
-       const mode_t          mode)
+_chmod_loop_core(const string *basepath,
+                 const char   *fusepath,
+                 const mode_t  mode,
+                 const int     error)
 {
   int rv;
+  string fullpath;
+
+  fs::path::make(basepath,fusepath,fullpath);
+
+  rv = ::chmod(fullpath.c_str(),mode);
+
+  return calc_error(rv,error,errno);
+}
+
+static
+int
+_chmod_loop(const vector<const string*> &basepaths,
+            const char                  *fusepath,
+            const mode_t                 mode)
+{
   int error;
-  fs::Paths paths;
 
-  rv = actionFunc(srcmounts,fusepath,paths,-1);
-  if(rv == -1)
-    return -errno;
-
-  error = 0;
-  for(fs::Paths::const_iterator
-        i = paths.begin(), ei = paths.end(); i != ei; ++i)
+  error = -1;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
     {
-      rv = ::chmod(i->full.c_str(),mode);
-      if(rv == -1)
-        error = errno;
+      error = _chmod_loop_core(basepaths[i],fusepath,mode,error);
     }
 
   return -error;
 }
 
+static
+int
+_chmod(Policy::Func::Action  actionFunc,
+       const vector<string> &srcmounts,
+       const size_t          minfreespace,
+       const char           *fusepath,
+       const mode_t          mode)
+{
+  int rv;
+  vector<const string*> basepaths;
+
+  rv = actionFunc(srcmounts,fusepath,minfreespace,basepaths);
+  if(rv == -1)
+    return -errno;
+
+  return _chmod_loop(basepaths,fusepath,mode);
+}
+
 namespace mergerfs
 {
-  namespace chmod
+  namespace fuse
   {
     int
     chmod(const char *fusepath,
           mode_t      mode)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const config::Config      &config = config::get();
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _chmod(*config.chmod,
+      return _chmod(config.chmod,
                     config.srcmounts,
+                    config.minfreespace,
                     fusepath,
                     mode);
     }

src/chmod.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace chmod
+  namespace fuse
   {
     int
     chmod(const char *fusepath,

src/chown.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -29,59 +21,89 @@
 #include <string>
 #include <vector>
 
-#include "ugid.hpp"
-#include "fs.hpp"
 #include "config.hpp"
+#include "fs_path.hpp"
+#include "rv.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
 using mergerfs::Policy;
+using mergerfs::Config;
 
 static
 int
-_chown(const fs::find::Func  actionFunc,
-       const vector<string> &srcmounts,
-       const string         &fusepath,
-       const uid_t           uid,
-       const gid_t           gid)
+_chown_loop_core(const string *basepath,
+                 const char   *fusepath,
+                 const uid_t   uid,
+                 const gid_t   gid,
+                 const int     error)
 {
   int rv;
+  string fullpath;
+
+  fs::path::make(basepath,fusepath,fullpath);
+
+  rv = ::lchown(fullpath.c_str(),uid,gid);
+
+  return calc_error(rv,error,errno);
+}
+
+static
+int
+_chown_loop(const vector<const string*> &basepaths,
+            const char                  *fusepath,
+            const uid_t                  uid,
+            const gid_t                  gid)
+{
   int error;
-  fs::Paths paths;
 
-  rv = actionFunc(srcmounts,fusepath,paths,-1);
-  if(rv == -1)
-    return -errno;
-
-  error = 0;
-  for(fs::Paths::const_iterator
-        i = paths.begin(), ei = paths.end(); i != ei; ++i)
+  error = -1;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
     {
-      rv = ::lchown(i->full.c_str(),uid,gid);
-      if(rv == -1)
-        error = errno;
+      error = _chown_loop_core(basepaths[i],fusepath,uid,gid,error);
     }
 
   return -error;
 }
 
+static
+int
+_chown(Policy::Func::Action  actionFunc,
+       const vector<string> &srcmounts,
+       const size_t          minfreespace,
+       const char           *fusepath,
+       const uid_t           uid,
+       const gid_t           gid)
+{
+  int rv;
+  vector<const string*> basepaths;
+
+  rv = actionFunc(srcmounts,fusepath,minfreespace,basepaths);
+  if(rv == -1)
+    return -errno;
+
+  return _chown_loop(basepaths,fusepath,uid,gid);
+}
+
 namespace mergerfs
 {
-  namespace chown
+  namespace fuse
   {
     int
     chown(const char *fusepath,
           uid_t       uid,
           gid_t       gid)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _chown(*config.chown,
+      return _chown(config.chown,
                     config.srcmounts,
+                    config.minfreespace,
                     fusepath,
                     uid,
                     gid);

src/chown.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace chown
+  namespace fuse
   {
     int
     chown(const char *fusepath,

src/clone.cpp

@@ -0,0 +1,61 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <iostream>
+
+#include "fs.hpp"
+#include "fs_clonefile.hpp"
+#include "fs_clonepath.hpp"
+
+namespace clonetool
+{
+  static
+  void
+  print_usage_and__exit(void)
+  {
+    std::cerr << "usage: clone "
+              << "[path <sourcedir> <destdir> <relativepath>]"
+              << " | "
+              << "[file <source> <dest>]"
+              << std::endl;
+    _exit(1);
+  }
+
+  int
+  main(const int    argc,
+       char * const argv[])
+  {
+    int rv = 0;
+
+    if(argc == 4 && !strcmp(argv[1],"file"))
+      rv = fs::clonefile(argv[2],argv[3]);
+    else if(argc == 5 && !strcmp(argv[1],"path"))
+      rv = fs::clonepath(argv[2],argv[3],argv[4]);
+    else
+      print_usage_and__exit();
+
+    if(rv == -1)
+      std::cerr << "error: "
+                << strerror(errno)
+                << std::endl;
+
+    return 0;
+  }
+}

src/clone.hpp

@@ -0,0 +1,22 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+namespace clonetool
+{
+  int
+  main(const int     argc,
+       char * const *argv);
+}

src/clonepath.cpp

@@ -1,54 +0,0 @@
-/*
-   The MIT License (MIT)
-
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
- */
-
-#include <unistd.h>
-
-#include <iostream>
-
-#include "fs.hpp"
-
-namespace clonepath
-{
-  static
-  void
-  print_usage_and__exit(void)
-  {
-    std::cerr << "usage: clonepath "
-              << "<sourcedir> <destdir> <relativepath>"
-              << std::endl;
-    _exit(1);
-  }
-
-  int
-  main(const int    argc,
-       char * const argv[])
-  {
-    if(argc != 4)
-      print_usage_and__exit();
-
-    return fs::clonepath(argv[1],
-                         argv[2],
-                         argv[3]);
-  }
-}

src/clonepath.hpp

@@ -1,30 +0,0 @@
-/*
-   The MIT License (MIT)
-
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
- */
-
-namespace clonepath
-{
-  int
-  main(const int     argc,
-       char * const *argv);
-}

src/config.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <string>
@@ -33,6 +25,7 @@
 #include "rwlock.hpp"
 #include "fs.hpp"
 
+#define MINFREESPACE_DEFAULT (4294967295ULL)
 #define POLICYINIT(X) X(policies[FuseFunc::Enum::X])
 
 using std::string;
@@ -40,101 +33,82 @@ using std::vector;
 
 namespace mergerfs
 {
-  namespace config
+  Config::Config()
+    : destmount(),
+      srcmounts(),
+      srcmountslock(),
+      minfreespace(MINFREESPACE_DEFAULT),
+      moveonenospc(false),
+      POLICYINIT(access),
+      POLICYINIT(chmod),
+      POLICYINIT(chown),
+      POLICYINIT(create),
+      POLICYINIT(getattr),
+      POLICYINIT(getxattr),
+      POLICYINIT(link),
+      POLICYINIT(listxattr),
+      POLICYINIT(mkdir),
+      POLICYINIT(mknod),
+      POLICYINIT(open),
+      POLICYINIT(readlink),
+      POLICYINIT(removexattr),
+      POLICYINIT(rename),
+      POLICYINIT(rmdir),
+      POLICYINIT(setxattr),
+      POLICYINIT(symlink),
+      POLICYINIT(truncate),
+      POLICYINIT(unlink),
+      POLICYINIT(utimens),
+      controlfile("/.mergerfs")
   {
-    Config::Config()
-      : destmount(),
-        srcmounts(),
-        srcmountslock(),
-        POLICYINIT(access),
-        POLICYINIT(chmod),
-        POLICYINIT(chown),
-        POLICYINIT(create),
-        POLICYINIT(getattr),
-        POLICYINIT(getxattr),
-        POLICYINIT(link),
-        POLICYINIT(listxattr),
-        POLICYINIT(mkdir),
-        POLICYINIT(mknod),
-        POLICYINIT(open),
-        POLICYINIT(readlink),
-        POLICYINIT(removexattr),
-        POLICYINIT(rename),
-        POLICYINIT(rmdir),
-        POLICYINIT(setxattr),
-        POLICYINIT(symlink),
-        POLICYINIT(truncate),
-        POLICYINIT(unlink),
-        POLICYINIT(utimens),
-        controlfile("/.mergerfs")
-    {
-      pthread_rwlock_init(&srcmountslock,NULL);
+    pthread_rwlock_init(&srcmountslock,NULL);
 
-      set_category_policy("action","all");
-      set_category_policy("create","epmfs");
-      set_category_policy("search","ff");
-    }
+    set_category_policy("action","all");
+    set_category_policy("create","epmfs");
+    set_category_policy("search","ff");
+  }
 
-    int
-    Config::set_func_policy(const string &fusefunc_,
-                            const string &policy_)
-    {
-      const Policy   *policy;
-      const FuseFunc *fusefunc;
+  int
+  Config::set_func_policy(const string &fusefunc_,
+                          const string &policy_)
+  {
+    const Policy   *policy;
+    const FuseFunc *fusefunc;
 
-      fusefunc = FuseFunc::find(fusefunc_);
-      if(fusefunc == FuseFunc::invalid)
-        return (errno=ENODATA,-1);
+    fusefunc = FuseFunc::find(fusefunc_);
+    if(fusefunc == FuseFunc::invalid)
+      return (errno=ENODATA,-1);
 
-      policy = Policy::find(policy_);
-      if(policy == Policy::invalid)
-        return (errno=EINVAL,-1);
+    policy = Policy::find(policy_);
+    if(policy == Policy::invalid)
+      return (errno=EINVAL,-1);
 
-      policies[(FuseFunc::Enum::Type)*fusefunc] = policy;
+    policies[(FuseFunc::Enum::Type)*fusefunc] = policy;
 
-      return 0;
-    }
+    return 0;
+  }
 
-    int
-    Config::set_category_policy(const string &category_,
-                                const string &policy_)
-    {
-      const Policy   *policy;
-      const Category *category;
+  int
+  Config::set_category_policy(const string &category_,
+                              const string &policy_)
+  {
+    const Policy   *policy;
+    const Category *category;
 
-      category = Category::find(category_);
-      if(category == Category::invalid)
-        return (errno=ENODATA,-1);
+    category = Category::find(category_);
+    if(category == Category::invalid)
+      return (errno=ENODATA,-1);
 
-      policy = Policy::find(policy_);
-      if(policy == Policy::invalid)
-        return (errno=EINVAL,-1);
+    policy = Policy::find(policy_);
+    if(policy == Policy::invalid)
+      return (errno=EINVAL,-1);
 
-      for(int i = 0; i < FuseFunc::Enum::END; i++)
-        {
-          if(FuseFunc::fusefuncs[i] == (Category::Enum::Type)*category)
-            policies[(FuseFunc::Enum::Type)FuseFunc::fusefuncs[i]] = policy;
-        }
+    for(int i = 0; i < FuseFunc::Enum::END; i++)
+      {
+        if(FuseFunc::fusefuncs[i] == (Category::Enum::Type)*category)
+          policies[(FuseFunc::Enum::Type)FuseFunc::fusefuncs[i]] = policy;
+      }
 
-      return 0;
-    }
-
-    const Config&
-    get(const struct fuse_context *fc)
-    {
-      return *((Config*)fc->private_data);
-    }
-
-    const Config&
-    get(void)
-    {
-      return get(fuse_get_context());
-    }
-
-    Config&
-    get_writable(void)
-    {
-      return (*((Config*)fuse_get_context()->private_data));
-    }
+    return 0;
   }
 }

src/config.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #ifndef __CONFIG_HPP__
@@ -28,6 +20,7 @@
 #include <fuse.h>
 
 #include <sys/stat.h>
+#include <stdint.h>
 
 #include <string>
 #include <vector>
@@ -37,55 +30,65 @@
 
 namespace mergerfs
 {
-  namespace config
+  class Config
   {
-    class Config
+  public:
+    Config();
+
+  public:
+    int set_func_policy(const std::string &fusefunc_,
+                        const std::string &policy_);
+    int set_category_policy(const std::string &category,
+                            const std::string &policy);
+
+  public:
+    std::string              destmount;
+    std::vector<std::string> srcmounts;
+    mutable pthread_rwlock_t srcmountslock;
+    size_t                   minfreespace;
+    bool                     moveonenospc;
+
+  public:
+    const Policy  *policies[FuseFunc::Enum::END];
+    const Policy *&access;
+    const Policy *&chmod;
+    const Policy *&chown;
+    const Policy *&create;
+    const Policy *&getattr;
+    const Policy *&getxattr;
+    const Policy *&link;
+    const Policy *&listxattr;
+    const Policy *&mkdir;
+    const Policy *&mknod;
+    const Policy *&open;
+    const Policy *&readlink;
+    const Policy *&removexattr;
+    const Policy *&rename;
+    const Policy *&rmdir;
+    const Policy *&setxattr;
+    const Policy *&symlink;
+    const Policy *&truncate;
+    const Policy *&unlink;
+    const Policy *&utimens;
+
+  public:
+    const std::string controlfile;
+
+  public:
+    static
+    const Config &
+    get(const fuse_context *fc)
     {
-    public:
-      Config();
+      return *((Config*)fc->private_data);
+    }
 
-    public:
-      int set_func_policy(const std::string &fusefunc_,
-                          const std::string &policy_);
-      int set_category_policy(const std::string &category,
-                              const std::string &policy);
-
-    public:
-      std::string              destmount;
-      std::vector<std::string> srcmounts;
-      mutable pthread_rwlock_t srcmountslock;
-
-    public:
-      const Policy  *policies[FuseFunc::Enum::END];
-      const Policy *&access;
-      const Policy *&chmod;
-      const Policy *&chown;
-      const Policy *&create;
-      const Policy *&getattr;
-      const Policy *&getxattr;
-      const Policy *&link;
-      const Policy *&listxattr;
-      const Policy *&mkdir;
-      const Policy *&mknod;
-      const Policy *&open;
-      const Policy *&readlink;
-      const Policy *&removexattr;
-      const Policy *&rename;
-      const Policy *&rmdir;
-      const Policy *&setxattr;
-      const Policy *&symlink;
-      const Policy *&truncate;
-      const Policy *&unlink;
-      const Policy *&utimens;
-
-    public:
-      const std::string controlfile;
-    };
-
-    const Config &get(const struct fuse_context *fc);
-    const Config &get(void);
-    Config       &get_writable(void);
-  }
+    static
+    Config &
+    get_writable(void)
+    {
+      return (*((Config*)fuse_get_context()->private_data));
+    }
+  };
 }
 
 #endif

src/create.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -33,78 +25,104 @@
 #include <vector>
 
 #include "config.hpp"
-#include "ugid.hpp"
-#include "fs.hpp"
+#include "fileinfo.hpp"
+#include "fs_path.hpp"
+#include "fs_clonepath.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
 using mergerfs::Policy;
+using namespace mergerfs;
 
 static
 int
-_create(const fs::find::Func  searchFunc,
-        const fs::find::Func  createFunc,
-        const vector<string> &srcmounts,
-        const string         &fusepath,
-        const mode_t          mode,
-        const int             flags,
-        uint64_t             &fh)
+_create_core(const string &existingpath,
+             const string &createpath,
+             const char   *fusepath,
+             const char   *fusedirpath,
+             const mode_t  mode,
+             const int     flags,
+             uint64_t     &fh)
 {
   int fd;
-  int rv;
-  string path;
-  string dirname;
-  fs::Paths createpath;
-  fs::Paths existingpath;
+  string fullpath;
 
-  dirname = fs::dirname(fusepath);
-  rv = searchFunc(srcmounts,dirname,existingpath,1);
-  if(rv == -1)
-    return -errno;
-
-  rv = createFunc(srcmounts,dirname,createpath,1);
-  if(rv == -1)
-    return -errno;
-
-  if(createpath[0].base != existingpath[0].base)
+  if(createpath != existingpath)
     {
-      const mergerfs::ugid::SetResetGuard ugid(0,0);
-      fs::clonepath(existingpath[0].base,createpath[0].base,dirname);
+      const ugid::SetRootGuard ugidGuard;
+      fs::clonepath(existingpath,createpath,fusedirpath);
     }
 
-  path = fs::make_path(createpath[0].base,fusepath);
+  fs::path::make(&createpath,fusepath,fullpath);
 
-  fd = ::open(path.c_str(),flags,mode);
+  fd = ::open(fullpath.c_str(),flags,mode);
   if(fd == -1)
     return -errno;
 
-  fh = fd;
+  fh = reinterpret_cast<uint64_t>(new FileInfo(fd));
 
   return 0;
 }
 
+static
+int
+_create(Policy::Func::Search  searchFunc,
+        Policy::Func::Create  createFunc,
+        const vector<string> &srcmounts,
+        const size_t          minfreespace,
+        const char           *fusepath,
+        const mode_t          mode,
+        const int             flags,
+        uint64_t             &fh)
+{
+  int rv;
+  string fullpath;
+  string fusedirpath;
+  const char *fusedirpathcstr;
+  vector<const string*> createpaths;
+  vector<const string*> existingpaths;
+
+  fusedirpath = fusepath;
+  fs::path::dirname(fusedirpath);
+  fusedirpathcstr = fusedirpath.c_str();
+
+  rv = searchFunc(srcmounts,fusedirpathcstr,minfreespace,existingpaths);
+  if(rv == -1)
+    return -errno;
+
+  rv = createFunc(srcmounts,fusedirpathcstr,minfreespace,createpaths);
+  if(rv == -1)
+    return -errno;
+
+  return _create_core(*existingpaths[0],*createpaths[0],
+                      fusepath,fusedirpathcstr,
+                      mode,flags,fh);
+}
+
 namespace mergerfs
 {
-  namespace create
+  namespace fuse
   {
     int
-    create(const char            *fusepath,
-           mode_t                 mode,
-           struct fuse_file_info *fileinfo)
+    create(const char     *fusepath,
+           mode_t          mode,
+           fuse_file_info *ffi)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _create(*config.getattr,
-                     *config.create,
+      return _create(config.getattr,
+                     config.create,
                      config.srcmounts,
+                     config.minfreespace,
                      fusepath,
                      (mode & ~fc->umask),
-                     fileinfo->flags,
-                     fileinfo->fh);
+                     ffi->flags,
+                     ffi->fh);
     }
   }
 }

src/create.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <sys/types.h>
@@ -27,11 +19,11 @@
 
 namespace mergerfs
 {
-  namespace create
+  namespace fuse
   {
     int
-    create(const char            *fusepath,
-           mode_t                 mode,
-           struct fuse_file_info *fileinfo);
+    create(const char     *fusepath,
+           mode_t          mode,
+           fuse_file_info *ffi);
   }
 }

src/destroy.cpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace destroy
+  namespace fuse
   {
     void
     destroy(void *)

src/destroy.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace destroy
+  namespace fuse
   {
     void
     destroy(void *);

src/fallocate.cpp

@@ -1,38 +1,28 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #if FALLOCATE
 
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
 #include <fuse.h>
 
 #include <errno.h>
 #include <fcntl.h>
 
+#include "fileinfo.hpp"
+
 static
 int
 _fallocate(const int   fd,
@@ -64,16 +54,18 @@ _fallocate(const int   fd,
 
 namespace mergerfs
 {
-  namespace fallocate
+  namespace fuse
   {
     int
-    fallocate(const char            *fusepath,
-              int                    mode,
-              off_t                  offset,
-              off_t                  len,
-              struct fuse_file_info *ffi)
+    fallocate(const char     *fusepath,
+              int             mode,
+              off_t           offset,
+              off_t           len,
+              fuse_file_info *ffi)
     {
-      return _fallocate(ffi->fh,
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
+
+      return _fallocate(fi->fd,
                         mode,
                         offset,
                         len);

src/fallocate.hpp

@@ -1,36 +1,28 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace fallocate
+  namespace fuse
   {
     int
-    fallocate(const char            *fusepath,
-              int                    mode,
-              off_t                  offset,
-              off_t                  len,
-              struct fuse_file_info *fi);
+    fallocate(const char     *fusepath,
+              int             mode,
+              off_t           offset,
+              off_t           len,
+              fuse_file_info *fi);
   }
 }

src/fgetattr.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -29,6 +21,8 @@
 #include <unistd.h>
 #include <errno.h>
 
+#include "fileinfo.hpp"
+
 static
 int
 _fgetattr(const int    fd,
@@ -43,14 +37,16 @@ _fgetattr(const int    fd,
 
 namespace mergerfs
 {
-  namespace fgetattr
+  namespace fuse
   {
     int
-    fgetattr(const char            *fusepath,
-             struct stat           *st,
-             struct fuse_file_info *ffi)
+    fgetattr(const char     *fusepath,
+             struct stat    *st,
+             fuse_file_info *ffi)
     {
-      return _fgetattr(ffi->fh,
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
+
+      return _fgetattr(fi->fd,
                        *st);
     }
   }

src/fgetattr.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <sys/types.h>
@@ -28,11 +20,11 @@
 
 namespace mergerfs
 {
-  namespace fgetattr
+  namespace fuse
   {
     int
-    fgetattr(const char            *fusepath,
-             struct stat           *st,
-             struct fuse_file_info *fileinfo);
+    fgetattr(const char     *fusepath,
+             struct stat    *st,
+             fuse_file_info *fileinfo);
   }
 }

src/fileinfo.hpp

@@ -0,0 +1,32 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef __FILEINFO_HPP__
+#define __FILEINFO_HPP__
+
+class FileInfo
+{
+public:
+  FileInfo(int _fd) :
+    fd(_fd)
+  {
+  }
+
+public:
+  int fd;
+};
+
+#endif

src/flush.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -27,30 +19,34 @@
 #include <unistd.h>
 #include <errno.h>
 
+#include "fileinfo.hpp"
+
 static
 int
 _flush(const int fd)
 {
   int rv;
 
-  rv = dup(fd);
+  rv = ::dup(fd);
   if(rv == -1)
     errno = EIO;
   else
-    rv = close(rv);
+    rv = ::close(rv);
 
   return ((rv == -1) ? -errno : 0);
 }
 
 namespace mergerfs
 {
-  namespace flush
+  namespace fuse
   {
     int
-    flush(const char            *fusepath,
-          struct fuse_file_info *ffi)
+    flush(const char     *fusepath,
+          fuse_file_info *ffi)
     {
-      return _flush(ffi->fh);
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
+
+      return _flush(fi->fd);
     }
   }
 }

src/flush.hpp

@@ -1,33 +1,25 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace flush
+  namespace fuse
   {
     int
-    flush(const char            *path,
-          struct fuse_file_info *fi);
+    flush(const char     *path,
+          fuse_file_info *fi);
   }
 }

src/fs.cpp

@@ -1,498 +1,169 @@
 /*
-  The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-  Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <string>
 #include <vector>
-#include <map>
-#include <sstream>
-#include <cstdlib>
-#include <iterator>
-#include <algorithm>
 
-#include <dirent.h>
 #include <errno.h>
 #include <fcntl.h>
-#include <linux/fs.h>
-#include <sys/ioctl.h>
+#include <fcntl.h>
+#include <glob.h>
+#include <limits.h>
+#include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
 #include <unistd.h>
-#include <glob.h>
 
-#include "fs.hpp"
-#include "xattr.hpp"
+#include "fs_attr.hpp"
+#include "fs_path.hpp"
+#include "fs_xattr.hpp"
+#include "statvfs_util.hpp"
 #include "str.hpp"
+#include "success_fail.hpp"
 
 using std::string;
 using std::vector;
-using std::map;
-using std::istringstream;
-
-template <typename Iter>
-Iter
-random_element(Iter begin,
-               Iter end)
-{
-  const unsigned long n = std::distance(begin, end);
-
-  std::advance(begin, (std::rand() % n));
-
-  return begin;
-}
 
 namespace fs
 {
-  string
-  dirname(const string &path)
+  bool
+  exists(const string &path,
+         struct stat  &st)
   {
-    string parent = path;
-    string::reverse_iterator i;
-    string::reverse_iterator bi;
+    int rv;
 
-    bi = parent.rend();
-    i  = parent.rbegin();
-    while(*i == '/' && i != bi)
-      i++;
+    rv = ::lstat(path.c_str(),&st);
 
-    while(*i != '/' && i != bi)
-      i++;
-
-    while(*i == '/' && i != bi)
-      i++;
-
-    parent.erase(i.base(),parent.end());
-
-    return parent;
-  }
-
-  string
-  basename(const string &path)
-  {
-    return path.substr(path.find_last_of('/')+1);
+    return LSTAT_SUCCEEDED(rv);
   }
 
   bool
-  dir_is_empty(const string &path)
+  exists(const string &path)
   {
-    DIR           *dir;
-    struct dirent *de;
+    struct stat st;
 
-    dir = ::opendir(path.c_str());
-    if(!dir)
-      return false;
+    return exists(path,st);
+  }
 
-    while((de = ::readdir(dir)))
+  bool
+  statvfs(const string   &path,
+          struct statvfs &st)
+  {
+    int rv;
+
+    rv = ::statvfs(path.c_str(),&st);
+
+    return STATVFS_SUCCEEDED(rv);
+  }
+
+  bool
+  info(const string &path,
+       bool         &readonly,
+       size_t       &spaceavail)
+  {
+    bool rv;
+    struct statvfs st;
+
+    rv = fs::statvfs(path,st);
+    if(rv)
       {
-        const char *d_name = de->d_name;
-
-        if(d_name[0] == '.'     &&
-           ((d_name[1] == '\0') ||
-            (d_name[1] == '.' && d_name[2] == '\0')))
-          continue;
-
-        ::closedir(dir);
-
-        return false;
+        readonly   = StatVFS::readonly(st);
+        spaceavail = StatVFS::spaceavail(st);
       }
 
-    ::closedir(dir);
-
-    return true;
-  }
-
-  string
-  make_path(const string &base,
-            const string &suffix)
-  {
-    if(suffix[0]      == '/' ||
-       *base.rbegin() == '/')
-      return base + suffix;
-    return base + '/' + suffix;
+    return rv;
   }
 
   bool
-  path_exists(vector<string>::const_iterator  begin,
-              vector<string>::const_iterator  end,
-              const string                   &fusepath)
+  readonly(const string &path)
   {
-    for(vector<string>::const_iterator
-          iter = begin; iter != end; ++iter)
-      {
-        int         rv;
-        string      path;
-        struct stat st;
+    bool rv;
+    struct statvfs st;
 
-        path = fs::make_path(*iter,fusepath);
-        rv   = ::lstat(path.c_str(),&st);
-        if(rv == 0)
-          return true;
-      }
+    rv = fs::statvfs(path,st);
 
-    return false;
+    return (rv && StatVFS::readonly(st));
   }
 
   bool
-  path_exists(const vector<string> &srcmounts,
-              const string         &fusepath)
+  spaceavail(const string &path,
+             size_t       &spaceavail)
   {
-    return path_exists(srcmounts.begin(),
-                       srcmounts.end(),
-                       fusepath);
+    bool rv;
+    struct statvfs st;
+
+    rv = fs::statvfs(path,st);
+    if(rv)
+      spaceavail = StatVFS::spaceavail(st);
+
+    return rv;
   }
 
   void
   findallfiles(const vector<string> &srcmounts,
-               const string         &fusepath,
+               const char           *fusepath,
                vector<string>       &paths)
   {
-    for(vector<string>::const_iterator
-          iter = srcmounts.begin(), eiter = srcmounts.end();
-        iter != eiter;
-        ++iter)
-      {
-        int rv;
-        string fullpath;
-        struct stat st;
+    string fullpath;
 
-        fullpath = fs::make_path(*iter,fusepath);
-        rv = ::lstat(fullpath.c_str(),&st);
-        if(rv == 0)
-          paths.push_back(fullpath);
+    for(size_t i = 0, ei = srcmounts.size(); i != ei; i++)
+      {
+        fs::path::make(&srcmounts[i],fusepath,fullpath);
+
+        if(!fs::exists(fullpath))
+          continue;
+
+        paths.push_back(fullpath);
       }
   }
 
   int
-  listxattr(const string &path,
-            vector<char> &attrs)
-  {
-#ifndef WITHOUT_XATTR
-    int rv;
-    int size;
-
-    rv    = -1;
-    errno = ERANGE;
-    while(rv == -1 && errno == ERANGE)
-      {
-        size = ::listxattr(path.c_str(),NULL,0);
-        attrs.resize(size);
-        rv   = ::listxattr(path.c_str(),&attrs[0],size);
-      }
-
-    return rv;
-#else
-    errno = ENOTSUP;
-    return -1;
-#endif
-  }
-
-  int
-  listxattr(const string   &path,
-            vector<string> &attrvector)
+  findonfs(const vector<string> &srcmounts,
+           const char           *fusepath,
+           const int             fd,
+           string               &basepath)
   {
     int rv;
-    vector<char> attrs;
-
-    rv = listxattr(path,attrs);
-    if(rv != -1)
-      {
-        string tmp(attrs.begin(),attrs.end());
-        str::split(attrvector,tmp,'\0');
-      }
-
-    return rv;
-  }
-
-  int
-  listxattr(const string &path,
-            string       &attrstr)
-  {
-    int rv;
-    vector<char> attrs;
-
-    rv = listxattr(path,attrs);
-    if(rv != -1)
-      attrstr = string(attrs.begin(),attrs.end());
-
-    return rv;
-  }
-
-  int
-  getxattr(const string &path,
-           const string &attr,
-           vector<char> &value)
-  {
-#ifndef WITHOUT_XATTR
-    int rv;
-    int size;
-
-    rv    = -1;
-    errno = ERANGE;
-    while(rv == -1 && errno == ERANGE)
-      {
-        size = ::getxattr(path.c_str(),attr.c_str(),NULL,0);
-        value.resize(size);
-        rv   = ::getxattr(path.c_str(),attr.c_str(),&value[0],size);
-      }
-
-    return rv;
-#else
-    errno = ENOTSUP;
-    return -1;
-#endif
-  }
-
-  int
-  getxattr(const string &path,
-           const string &attr,
-           string       &value)
-  {
-    int          rv;
-    vector<char> tmpvalue;
-
-    rv = getxattr(path,attr,tmpvalue);
-    if(rv != -1)
-      value = string(tmpvalue.begin(),tmpvalue.end());
-
-    return rv;
-  }
-
-
-  int
-  getxattrs(const string       &path,
-            map<string,string> &attrs)
-  {
-    int rv;
-    string attrstr;
-
-    rv = listxattr(path,attrstr);
-    if(rv == -1)
-      return -1;
-
-    {
-      string key;
-      istringstream ss(attrstr);
-
-      while(getline(ss,key,'\0'))
-        {
-          string value;
-
-          rv = getxattr(path,key,value);
-          if(rv != -1)
-            attrs[key] = value;
-        }
-    }
-
-    return 0;
-  }
-
-  int
-  setxattr(const string &path,
-           const string &key,
-           const string &value,
-           const int     flags)
-  {
-#ifndef WITHOUT_XATTR
-    return ::setxattr(path.c_str(),
-                      key.c_str(),
-                      value.data(),
-                      value.size(),
-                      flags);
-#else
-    errno = ENOTSUP;
-    return -1;
-#endif
-  }
-
-  int
-  setxattr(const int     fd,
-           const string &key,
-           const string &value,
-           const int     flags)
-  {
-#ifndef WITHOUT_XATTR
-    return ::fsetxattr(fd,
-                       key.c_str(),
-                       value.data(),
-                       value.size(),
-                       flags);
-#else
-    errno = ENOTSUP;
-    return -1;
-#endif
-  }
-
-  int
-  setxattrs(const string             &path,
-            const map<string,string> &attrs)
-  {
-    int fd;
-
-    fd = ::open(path.c_str(),O_RDONLY|O_NONBLOCK);
-    if(fd == -1)
-      return -1;
-
-    for(map<string,string>::const_iterator
-          i = attrs.begin(), ei = attrs.end(); i != ei; ++i)
-      {
-        setxattr(fd,i->first,i->second,0);
-      }
-
-    return ::close(fd);
-  }
-
-  int
-  copyxattrs(const string &from,
-             const string &to)
-  {
-    int rv;
-    map<string,string> attrs;
-
-    rv = getxattrs(from,attrs);
-    if(rv == -1)
-      return -1;
-
-    return setxattrs(to,attrs);
-  }
-
-  static
-  int
-  get_fs_ioc_flags(const string &file,
-                   int          &flags)
-  {
-    int fd;
-    int rv;
-    const int openflags = O_RDONLY|O_NONBLOCK;
-
-    fd = ::open(file.c_str(),openflags);
-    if(fd == -1)
-      return -1;
-
-    rv = ::ioctl(fd,FS_IOC_GETFLAGS,&flags);
-    if(rv == -1)
-      {
-        int error = errno;
-        ::close(fd);
-        errno = error;
-        return -1;
-      }
-
-    return ::close(fd);
-  }
-
-  static
-  int
-  set_fs_ioc_flags(const string &file,
-                   const int     flags)
-  {
-    int fd;
-    int rv;
-    const int openflags = O_RDONLY|O_NONBLOCK;
-
-    fd = ::open(file.c_str(),openflags);
-    if(fd == -1)
-      return -1;
-
-    rv = ::ioctl(fd,FS_IOC_SETFLAGS,&flags);
-    if(rv == -1)
-      {
-        int error = errno;
-        ::close(fd);
-        errno = error;
-        return -1;
-      }
-
-    return ::close(fd);
-  }
-
-  int
-  copyattr(const string &from,
-           const string &to)
-  {
-    int rv;
-    int flags;
-
-    rv = get_fs_ioc_flags(from,flags);
-    if(rv == -1)
-      return -1;
-
-    return set_fs_ioc_flags(to,flags);
-  }
-
-  int
-  clonepath(const string &fromsrc,
-            const string &tosrc,
-            const string &relative)
-  {
-    int         rv;
+    dev_t dev;
+    string fullpath;
     struct stat st;
-    string      topath;
-    string      frompath;
-    string      dirname;
 
-    dirname = fs::dirname(relative);
-    if(!dirname.empty())
+    rv = ::fstat(fd,&st);
+    if(FSTAT_FAILED(rv))
+      return -1;
+
+    dev = st.st_dev;
+    for(int i = 0, ei = srcmounts.size(); i != ei; i++)
       {
-        rv = clonepath(fromsrc,tosrc,dirname);
-        if(rv == -1)
-          return -1;
+        fs::path::make(&srcmounts[i],fusepath,fullpath);
+
+        rv = ::lstat(fullpath.c_str(),&st);
+        if(FSTAT_FAILED(rv))
+          continue;
+
+        if(st.st_dev != dev)
+          continue;
+
+        basepath = srcmounts[i];
+
+        return 0;
       }
 
-    frompath = fs::make_path(fromsrc,relative);
-
-    rv = ::stat(frompath.c_str(),&st);
-    if(rv == -1)
-      return -1;
-    else if(!S_ISDIR(st.st_mode))
-      return (errno = ENOTDIR,-1);
-
-    topath = fs::make_path(tosrc,relative);
-    rv = ::mkdir(topath.c_str(),st.st_mode);
-    if(rv == -1)
-      {
-        if(errno != EEXIST)
-          return -1;
-
-        rv = ::chmod(topath.c_str(),st.st_mode);
-        if(rv == -1)
-          return -1;
-      }
-
-    rv = ::chown(topath.c_str(),st.st_uid,st.st_gid);
-    if(rv == -1)
-      return -1;
-
-    // It may not support it... it's fine...
-    rv = copyattr(frompath,topath);
-    if(rv == -1 && errno != ENOTTY)
-      return -1;
-
-    rv = copyxattrs(frompath,topath);
-    if(rv == -1 && errno != ENOTTY)
-      return -1;
-
-    return 0;
+    return (errno=ENOENT,-1);
   }
 
   void
@@ -500,14 +171,19 @@ namespace fs
        vector<string>       &strs)
   {
     int flags;
-    glob_t gbuf;
+    size_t veclen;
+    glob_t gbuf = {0};
+
+    veclen = patterns.size();
+    if(veclen == 0)
+      return;
 
     flags = 0;
-    for(size_t i = 0; i < patterns.size(); i++)
-      {
-        glob(patterns[i].c_str(),flags,NULL,&gbuf);
-        flags = GLOB_APPEND;
-      }
+    glob(patterns[0].c_str(),flags,NULL,&gbuf);
+
+    flags = GLOB_APPEND;
+    for(size_t i = 1; i < veclen; i++)
+      glob(patterns[i].c_str(),flags,NULL,&gbuf);
 
     for(size_t i = 0; i < gbuf.gl_pathc; ++i)
       strs.push_back(gbuf.gl_pathv[i]);
@@ -515,270 +191,60 @@ namespace fs
     globfree(&gbuf);
   }
 
-  namespace find
+  void
+  realpathize(vector<string> &strs)
   {
-    int
-    invalid(const vector<string> &basepaths,
-            const string         &fusepath,
-            Paths                &rv,
-            size_t                count)
-    {
-      return (errno = EINVAL,-1);
-    }
+    char *rv;
+    char buf[PATH_MAX];
 
-    int
-    ff(const vector<string> &basepaths,
-       const string         &fusepath,
-       Paths                &paths,
-       size_t                count)
-    {
-      errno = ENOENT;
-      for(vector<string>::const_iterator
-            iter = basepaths.begin(), eiter = basepaths.end();
-          iter != eiter;
-          ++iter)
-        {
-          int         rv;
-          struct stat st;
-          string      fullpath;
+    for(size_t i = 0; i < strs.size(); i++)
+      {
+        rv = ::realpath(strs[i].c_str(),buf);
+        if(rv == NULL)
+          continue;
 
-          fullpath = fs::make_path(*iter,fusepath);
+        strs[i] = buf;
+      }
+  }
 
-          rv = ::lstat(fullpath.c_str(),&st);
-          if(rv == 0)
-            {
-              paths.push_back(Path(*iter,fullpath));
-              return 0;
-            }
-        }
+  int
+  getfl(const int fd)
+  {
+    return ::fcntl(fd,F_GETFL,0);
+  }
 
-      return -1;
-    }
+  int
+  mfs(const vector<string> &basepaths,
+      const size_t          minfreespace,
+      string               &path)
+  {
+    fsblkcnt_t mfs;
+    const string *mfsbasepath;
 
-    int
-    ffwp(const vector<string> &basepaths,
-         const string         &fusepath,
-         Paths                &paths,
-         size_t                count)
-    {
-      Path fallback;
+    mfs = 0;
+    mfsbasepath = NULL;
+    for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+      {
+        size_t spaceavail;
+        const string &basepath = basepaths[i];
 
-      errno = ENOENT;
-      for(vector<string>::const_iterator
-            iter = basepaths.begin(), eiter = basepaths.end();
-          iter != eiter;
-          ++iter)
-        {
-          int         rv;
-          struct stat st;
-          string      fullpath;
+        if(!fs::spaceavail(basepath,spaceavail))
+          continue;
 
-          fullpath = fs::make_path(*iter,fusepath);
+        if(spaceavail < minfreespace)
+          continue;
+        if(spaceavail <= mfs)
+          continue;
 
-          rv = ::lstat(fullpath.c_str(),&st);
-          if(rv == 0)
-            {
-              paths.push_back(Path(*iter,fullpath));
-              return 0;
-            }
-          else if(errno == EACCES)
-            {
-              fallback.base = *iter;
-              fallback.full = fullpath;
-            }
-        }
+        mfs         = spaceavail;
+        mfsbasepath = &basepaths[i];
+      }
 
-      if(!fallback.base.empty())
-        return (paths.push_back(fallback),0);
+    if(mfsbasepath == NULL)
+      return (errno=ENOENT,-1);
 
-      return -1;
-    }
+    path = *mfsbasepath;
 
-    int
-    newest(const vector<string> &basepaths,
-           const string         &fusepath,
-           Paths                &paths,
-           size_t                count)
-    {
-      time_t newest;
-      string npath;
-      vector<string>::const_iterator niter;
-
-      newest = 0;
-      errno  = ENOENT;
-      for(vector<string>::const_iterator
-            iter = basepaths.begin(), eiter = basepaths.end();
-          iter != eiter;
-          ++iter)
-        {
-          int         rv;
-          struct stat st;
-          string      fullpath;
-
-          fullpath = fs::make_path(*iter,fusepath);
-
-          rv  = ::lstat(fullpath.c_str(),&st);
-          if(rv == 0 && st.st_mtime > newest)
-            {
-              newest = st.st_mtime;
-              niter  = iter;
-              npath  = fullpath;
-            }
-        }
-
-      if(newest)
-        return (paths.push_back(Path(*niter,npath)),0);
-
-      return -1;
-    }
-
-    int
-    mfs(const vector<string> &basepaths,
-        const string         &fusepath,
-        Paths                &paths,
-        size_t                count)
-    {
-      fsblkcnt_t mfs;
-      size_t     mfsidx;
-
-      mfs = 0;
-      for(size_t i = 0, size = basepaths.size();
-          i != size;
-          i++)
-        {
-          int rv;
-          struct statvfs fsstats;
-
-          rv = ::statvfs(basepaths[i].c_str(),&fsstats);
-          if(rv == 0)
-            {
-              fsblkcnt_t  spaceavail;
-
-              spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
-              if(spaceavail > mfs)
-                {
-                  mfs    = spaceavail;
-                  mfsidx = i;
-                }
-            }
-        }
-
-      if(mfs == 0)
-        return (errno=ENOENT,-1);
-
-      paths.push_back(Path(basepaths[mfsidx],
-                           fs::make_path(basepaths[mfsidx],fusepath)));
-
-      return 0;
-    }
-
-    int
-    epmfs(const vector<string> &basepaths,
-          const string         &fusepath,
-          Paths                &paths,
-          size_t                count)
-    {
-      fsblkcnt_t existingmfs = 0;
-      fsblkcnt_t generalmfs  = 0;
-      string     fullpath;
-      string     generalmfspath;
-      string     existingmfspath;
-      vector<string>::const_iterator iter  = basepaths.begin();
-      vector<string>::const_iterator eiter = basepaths.end();
-
-      if(iter == eiter)
-        return (errno = ENOENT,-1);
-
-      do
-        {
-          int rv;
-          struct statvfs  fsstats;
-          const string   &mountpoint = *iter;
-
-          rv = ::statvfs(mountpoint.c_str(),&fsstats);
-          if(rv == 0)
-            {
-              fsblkcnt_t  spaceavail;
-              struct stat st;
-
-              spaceavail = (fsstats.f_frsize * fsstats.f_bavail);
-              if(spaceavail > generalmfs)
-                {
-                  generalmfs     = spaceavail;
-                  generalmfspath = mountpoint;
-                }
-
-              fullpath = fs::make_path(mountpoint,fusepath);
-              rv = ::lstat(fullpath.c_str(),&st);
-              if(rv == 0)
-                {
-                  if(spaceavail > existingmfs)
-                    {
-                      existingmfs     = spaceavail;
-                      existingmfspath = mountpoint;
-                    }
-                }
-            }
-
-          ++iter;
-        }
-      while(iter != eiter);
-
-      if(existingmfspath.empty())
-        existingmfspath = generalmfspath;
-
-      paths.push_back(Path(existingmfspath,
-                           fullpath));
-
-      return 0;
-    }
-
-    int
-    all(const vector<string> &basepaths,
-        const string         &fusepath,
-        Paths                &paths,
-        size_t                count)
-    {
-      int rv;
-      struct stat st;
-      string fullpath;
-
-      for(vector<string>::const_iterator
-            iter = basepaths.begin(), eiter = basepaths.end();
-          iter != eiter && count;
-          ++iter)
-        {
-          fullpath = fs::make_path(*iter,fusepath);
-
-          rv = ::lstat(fullpath.c_str(),&st);
-          if(rv == 0)
-            {
-              paths.push_back(Path(*iter,fullpath));
-              count--;
-            }
-        }
-
-      return paths.empty() ? (errno=ENOENT,-1) : 0;
-    }
-
-    int
-    rand(const vector<string> &basepaths,
-         const string         &fusepath,
-         Paths                &paths,
-         size_t                count)
-    {
-      int rv;
-
-      rv = all(basepaths,fusepath,paths,-1);
-      if(rv == -1)
-        return -1;
-
-      std::random_shuffle(paths.begin(),paths.end());
-
-      if(paths.size() > count)
-        paths.resize(count);
-
-      return 0;
-    }
+    return 0;
   }
 };

src/fs.hpp

@@ -1,25 +1,17 @@
 /*
-  The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-  Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #ifndef __FS_HPP__
@@ -27,127 +19,48 @@
 
 #include <string>
 #include <vector>
-#include <map>
 
 namespace fs
 {
   using std::size_t;
   using std::string;
   using std::vector;
-  using std::map;
 
-  struct Path
-  {
-    Path() {}
-    Path(const string &b,
-         const string &f)
-      : base(b),
-        full(f)
-    {}
+  bool exists(const string &path,
+              struct stat  &st);
+  bool exists(const string &path);
 
-    string base;
-    string full;
-  };
+  bool statvfs(const string   &path,
+               struct statvfs &st);
 
-  typedef vector<Path> Paths;
+  bool info(const string &path,
+            bool         &readonly,
+            size_t       &spaceavail);
 
-  string dirname(const string &path);
-  string basename(const string &path);
+  bool readonly(const string &path);
 
-  bool dir_is_empty(const string &path);
-
-  string make_path(const string &base,
-                   const string &suffix);
-
-  bool path_exists(vector<string>::const_iterator  begin,
-                   vector<string>::const_iterator  end,
-                   const string                   &fusepath);
-  bool path_exists(const vector<string>           &srcmounts,
-                   const string                   &fusepath);
+  bool spaceavail(const string &path,
+                  size_t       &spaceavail);
 
   void findallfiles(const vector<string> &srcmounts,
-                    const string         &fusepath,
+                    const char           *fusepath,
                     vector<string>       &paths);
 
-  int clonepath(const string &srcfrom,
-                const string &srcto,
-                const string &relative);
-
-  int listxattr(const string   &path,
-                vector<char>   &attrs);
-  int listxattr(const string   &path,
-                string         &attrs);
-  int listxattr(const string   &path,
-                vector<string> &attrs);
-
-  int getxattr(const string &path,
-               const string &attr,
-               vector<char> &value);
-  int getxattr(const string &path,
-               const string &attr,
-               string       &value);
-
-  int getxattrs(const string       &path,
-                map<string,string> &attrs);
-
-  int setxattr(const string &path,
-               const string &key,
-               const string &value,
-               const int     flags);
-  int setxattr(const int     fd,
-               const string &key,
-               const string &value,
-               const int     flags);
-
-  int setxattrs(const string             &path,
-                const map<string,string> &attrs);
-
-  int copyxattrs(const string &from,
-                 const string &to);
-
-  int copyattr(const string &from,
-               const string &to);
+  int findonfs(const vector<string> &srcmounts,
+               const char           *fusepath,
+               const int             fd,
+               string               &basepath);
 
   void glob(const vector<string> &patterns,
             vector<string>       &strs);
 
-  namespace find
-  {
-    typedef int (*Func)(const vector<string>&,const string&,Paths&,size_t);
+  void realpathize(vector<string> &strs);
 
-    int invalid(const vector<string> &basepaths,
-                const string         &fusepath,
-                Paths                &path,
-                size_t                max);
-    int all(const vector<string> &basepaths,
-            const string         &fusepath,
-            Paths                &path,
-            size_t                max);
-    int ff(const vector<string>      &basepaths,
-           const string              &fusepath,
-           Paths                     &path,
-           size_t                     max);
-    int ffwp(const vector<string>    &paths,
-             const string            &fusepath,
-             Paths                   &path,
-             size_t                   max);
-    int newest(const vector<string>  &paths,
-               const string          &fusepath,
-               Paths                 &path,
-               size_t                 max);
-    int mfs(const vector<string>     &paths,
-            const string             &fusepath,
-            Paths                    &path,
-            size_t                    max);
-    int epmfs(const vector<string>   &paths,
-              const string           &fusepath,
-              Paths                  &path,
-              size_t                  max);
-    int rand(const vector<string>    &paths,
-             const string            &fusepath,
-             Paths                   &path,
-             size_t                   max);
-  }
+  int getfl(const int fd);
+
+  int mfs(const vector<string> &srcs,
+          const size_t          minfreespace,
+          string               &path);
 };
 
 #endif // __FS_HPP__

src/fs_attr.cpp

@@ -0,0 +1,127 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+#include <fcntl.h>
+#include <linux/fs.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+
+using std::string;
+
+namespace fs
+{
+  namespace attr
+  {
+    static
+    int
+    get_fs_ioc_flags(const int  fd,
+                     int       &flags)
+    {
+      return ::ioctl(fd,FS_IOC_GETFLAGS,&flags);
+    }
+
+    static
+    int
+    get_fs_ioc_flags(const string &file,
+                     int          &flags)
+    {
+      int fd;
+      int rv;
+      const int openflags = O_RDONLY|O_NONBLOCK;
+
+      fd = ::open(file.c_str(),openflags);
+      if(fd == -1)
+        return -1;
+
+      rv = get_fs_ioc_flags(fd,flags);
+      if(rv == -1)
+        {
+          int error = errno;
+          ::close(fd);
+          errno = error;
+          return -1;
+        }
+
+      return ::close(fd);
+    }
+
+    static
+    int
+    set_fs_ioc_flags(const int fd,
+                     const int flags)
+    {
+      return ::ioctl(fd,FS_IOC_SETFLAGS,&flags);
+    }
+
+    static
+    int
+    set_fs_ioc_flags(const string &file,
+                     const int     flags)
+    {
+      int fd;
+      int rv;
+      const int openflags = O_RDONLY|O_NONBLOCK;
+
+      fd = ::open(file.c_str(),openflags);
+      if(fd == -1)
+        return -1;
+
+      rv = set_fs_ioc_flags(fd,flags);
+      if(rv == -1)
+        {
+          int error = errno;
+          ::close(fd);
+          errno = error;
+          return -1;
+        }
+
+      return ::close(fd);
+    }
+
+    int
+    copy(const int fdin,
+         const int fdout)
+    {
+      int rv;
+      int flags;
+
+      rv = get_fs_ioc_flags(fdin,flags);
+      if(rv == -1)
+        return -1;
+
+      return set_fs_ioc_flags(fdout,flags);
+    }
+
+    int
+    copy(const string &from,
+         const string &to)
+    {
+      int rv;
+      int flags;
+
+      rv = get_fs_ioc_flags(from,flags);
+      if(rv == -1)
+        return -1;
+
+      return set_fs_ioc_flags(to,flags);
+    }
+  }
+}

src/fs_attr.hpp

@@ -0,0 +1,35 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef __FS_ATTR_HPP__
+#define __FS_ATTR_HPP__
+
+#include <string>
+
+namespace fs
+{
+  namespace attr
+  {
+    using std::string;
+
+    int copy(const int fdin,
+             const int fdout);
+    int copy(const string &from,
+             const string &to);
+  }
+}
+
+#endif // __FS_ATTR_HPP__

src/fs_clonefile.cpp

@@ -0,0 +1,223 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#ifdef __linux__
+#include <sys/sendfile.h>
+#endif
+
+#include <string>
+#include <vector>
+
+#include "fs_attr.hpp"
+#include "fs_xattr.hpp"
+
+using std::string;
+using std::vector;
+
+namespace fs
+{
+  static
+  ssize_t
+  sendfile(const int    fdin,
+           const int    fdout,
+           const size_t count)
+  {
+#if defined __linux__
+    off_t offset = 0;
+    return ::sendfile(fdout,fdin,&offset,count);
+#else
+    return (errno=EINVAL,-1);
+#endif
+  }
+
+  int
+  writen(const int     fd,
+         const char   *buf,
+         const size_t  count)
+  {
+    size_t nleft;
+    ssize_t nwritten;
+
+    nleft = count;
+    while(nleft > 0)
+      {
+        nwritten = ::write(fd,buf,nleft);
+        if(nwritten == -1)
+          {
+            if(errno == EINTR)
+              continue;
+            return -1;
+          }
+
+        nleft -= nwritten;
+        buf += nwritten;
+      }
+
+    return count;
+  }
+
+  static
+  int
+  copyfile_rw(const int    fdin,
+              const int    fdout,
+              const size_t count,
+              const size_t blocksize)
+  {
+    ssize_t nr;
+    ssize_t nw;
+    ssize_t bufsize;
+    size_t  totalwritten;
+    vector<char> buf;
+
+    bufsize = (blocksize * 16);
+    buf.resize(bufsize);
+
+    totalwritten = 0;
+    while(totalwritten < count)
+      {
+        nr = ::read(fdin,&buf[0],bufsize);
+        if(nr == -1)
+          {
+            if(errno == EINTR)
+              continue;
+            else
+              return -1;
+          }
+
+        nw = writen(fdout,&buf[0],nr);
+        if(nw == -1)
+          return -1;
+
+        totalwritten += nw;
+      }
+
+    return count;
+  }
+
+  static
+  int
+  copydata(const int    fdin,
+           const int    fdout,
+           const size_t count,
+           const size_t blocksize)
+  {
+    int rv;
+
+    ::posix_fadvise(fdin,0,count,POSIX_FADV_WILLNEED);
+    ::posix_fadvise(fdin,0,count,POSIX_FADV_SEQUENTIAL);
+
+    ::posix_fallocate(fdout,0,count);
+
+    rv = fs::sendfile(fdin,fdout,count);
+    if((rv == -1) && ((errno == EINVAL) || (errno == ENOSYS)))
+      return fs::copyfile_rw(fdin,fdout,count,blocksize);
+
+    return rv;
+  }
+
+  static
+  bool
+  ignorable_error(const int err)
+  {
+    switch(err)
+      {
+      case ENOTTY:
+      case ENOTSUP:
+#if ENOTSUP != EOPNOTSUPP
+      case EOPNOTSUPP:
+#endif
+        return true;
+      }
+
+    return false;
+  }
+
+  int
+  clonefile(const int fdin,
+            const int fdout)
+  {
+    int rv;
+    struct stat stin;
+
+    rv = ::fstat(fdin,&stin);
+    if(rv == -1)
+      return -1;
+
+    rv = copydata(fdin,fdout,stin.st_size,stin.st_blksize);
+    if(rv == -1)
+      return -1;
+
+    rv = fs::attr::copy(fdin,fdout);
+    if(rv == -1 && !ignorable_error(errno))
+      return -1;
+
+    rv = fs::xattr::copy(fdin,fdout);
+    if(rv == -1 && !ignorable_error(errno))
+      return -1;
+
+    rv = ::fchown(fdout,stin.st_uid,stin.st_gid);
+    if(rv == -1)
+      return -1;
+
+    rv = ::fchmod(fdout,stin.st_mode);
+    if(rv == -1)
+      return -1;
+
+    struct timespec times[2];
+    times[0] = stin.st_atim;
+    times[1] = stin.st_mtim;
+    rv = ::futimens(fdout,times);
+    if(rv == -1)
+      return -1;
+
+    return 0;
+  }
+
+  int
+  clonefile(const string &in,
+            const string &out)
+  {
+    int rv;
+    int fdin;
+    int fdout;
+    int error;
+
+    fdin = ::open(in.c_str(),O_RDONLY|O_NOFOLLOW);
+    if(fdin == -1)
+      return -1;
+
+    const int flags = O_CREAT|O_LARGEFILE|O_NOATIME|O_NOFOLLOW|O_TRUNC|O_WRONLY;
+    const int mode  = S_IWUSR;
+    fdout = ::open(out.c_str(),flags,mode);
+    if(fdout == -1)
+      return -1;
+
+    rv = fs::clonefile(fdin,fdout);
+    error = errno;
+
+    ::close(fdin);
+    ::close(fdout);
+
+    errno = error;
+    return rv;
+  }
+}

src/fs_clonefile.hpp

@@ -0,0 +1,25 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <string>
+
+namespace fs
+{
+  int clonefile(const int fdin,
+                const int fdout);
+  int clonefile(const std::string &from,
+                const std::string &to);
+}

src/fs_clonepath.cpp

@@ -0,0 +1,110 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <string>
+
+#include "fs_path.hpp"
+#include "fs_attr.hpp"
+#include "fs_xattr.hpp"
+
+using std::string;
+
+namespace fs
+{
+  static
+  bool
+  ignorable_error(const int err)
+  {
+    switch(err)
+      {
+      case ENOTTY:
+      case ENOTSUP:
+#if ENOTSUP != EOPNOTSUPP
+      case EOPNOTSUPP:
+#endif
+        return true;
+      }
+
+    return false;
+  }
+
+  int
+  clonepath(const string &fromsrc,
+            const string &tosrc,
+            const char   *relative)
+  {
+    int         rv;
+    struct stat st;
+    string      topath;
+    string      frompath;
+    string      dirname;
+
+    dirname = relative;
+    fs::path::dirname(dirname);
+    if(!dirname.empty())
+      {
+        rv = clonepath(fromsrc,tosrc,dirname.c_str());
+        if(rv == -1)
+          return -1;
+      }
+
+    fs::path::make(&fromsrc,relative,frompath);
+    rv = ::stat(frompath.c_str(),&st);
+    if(rv == -1)
+      return -1;
+    else if(!S_ISDIR(st.st_mode))
+      return (errno = ENOTDIR,-1);
+
+    fs::path::make(&tosrc,relative,topath);
+    rv = ::mkdir(topath.c_str(),st.st_mode);
+    if(rv == -1)
+      {
+        if(errno != EEXIST)
+          return -1;
+
+        rv = ::chmod(topath.c_str(),st.st_mode);
+        if(rv == -1)
+          return -1;
+      }
+
+    // It may not support it... it's fine...
+    rv = fs::attr::copy(frompath,topath);
+    if(rv == -1 && !ignorable_error(errno))
+      return -1;
+
+    rv = fs::xattr::copy(frompath,topath);
+    if(rv == -1 && !ignorable_error(errno))
+      return -1;
+
+    rv = ::chown(topath.c_str(),st.st_uid,st.st_gid);
+    if(rv == -1)
+      return -1;
+
+    struct timespec times[2];
+    times[0] = st.st_atim;
+    times[1] = st.st_mtim;
+    rv = ::utimensat(-1,topath.c_str(),times,0);
+    if(rv == -1)
+      return -1;
+
+    return 0;
+  }
+}

src/fs_clonepath.hpp

@@ -0,0 +1,24 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <string>
+
+namespace fs
+{
+  int clonepath(const std::string &from,
+                const std::string &to,
+                const char        *relative);
+}

src/fs_movefile.cpp

@@ -0,0 +1,110 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <fcntl.h>
+
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "fs_clonepath.hpp"
+#include "fs_clonefile.hpp"
+
+using std::string;
+using std::vector;
+
+namespace fs
+{
+  int
+  movefile(const vector<string> &basepaths,
+           const char           *fusepath,
+           const size_t          additional_size,
+           int                  &origfd)
+  {
+    int rv;
+    int fdin;
+    int fdout;
+    int fdin_flags;
+    string fusedir;
+    string fdin_path;
+    string fdout_path;
+    struct stat fdin_st;
+
+    fdin = origfd;
+
+    rv = fstat(fdin,&fdin_st);
+    if(rv == -1)
+      return -1;
+
+    fdin_flags = fs::getfl(fdin);
+    if(rv == -1)
+      return -1;
+
+    rv = fs::findonfs(basepaths,fusepath,fdin,fdin_path);
+    if(rv == -1)
+      return -1;
+
+    fdin_st.st_size += additional_size;
+    rv = fs::mfs(basepaths,fdin_st.st_size,fdout_path);
+    if(rv == -1)
+      return -1;
+
+    fusedir = fusepath;
+    fs::path::dirname(fusedir);
+    rv = fs::clonepath(fdin_path,fdout_path,fusedir.c_str());
+    if(rv == -1)
+      return -1;
+
+    fs::path::append(fdin_path,fusepath);
+    fdin = ::open(fdin_path.c_str(),O_RDONLY);
+    if(fdin == -1)
+      return -1;
+
+    fs::path::append(fdout_path,fusepath);
+    fdout = ::open(fdout_path.c_str(),fdin_flags|O_CREAT,fdin_st.st_mode);
+    if(fdout == -1)
+      return -1;
+
+    rv = fs::clonefile(fdin,fdout);
+    if(rv == -1)
+      {
+        ::close(fdin);
+        ::close(fdout);
+        ::unlink(fdout_path.c_str());
+        return -1;
+      }
+
+    rv = ::unlink(fdin_path.c_str());
+    if(rv == -1)
+      {
+        ::close(fdin);
+        ::close(fdout);
+        ::unlink(fdout_path.c_str());
+        return -1;
+      }
+
+    ::close(fdin);
+    ::close(origfd);
+
+    origfd = fdout;
+
+    return 0;
+  }
+}

src/fs_movefile.hpp

@@ -0,0 +1,32 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef __FS_MOVEFILE_HPP__
+#define __FS_MOVEFILE_HPP__
+
+#include <string>
+#include <vector>
+
+namespace fs
+{
+  int
+  movefile(const vector<string> &basepaths,
+           const char           *fusepath,
+           const size_t          additional_size,
+           int                  &origfd);
+}
+
+#endif

src/fs_path.cpp

@@ -0,0 +1,58 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+
+#include "fs_path.hpp"
+
+using std::string;
+
+namespace fs
+{
+  namespace path
+  {
+    void
+    dirname(string &path)
+    {
+      string::reverse_iterator i;
+      string::reverse_iterator bi;
+
+      bi = path.rend();
+      i  = path.rbegin();
+      while(*i == '/' && i != bi)
+        i++;
+
+      while(*i != '/' && i != bi)
+        i++;
+
+      while(*i == '/' && i != bi)
+        i++;
+
+      path.erase(i.base(),path.end());
+    }
+
+    string
+    basename(const string &path)
+    {
+      return path.substr(path.find_last_of('/')+1);
+    }
+  }
+}

src/fs_path.hpp

@@ -0,0 +1,53 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef __FS_PATH_HPP__
+#define __FS_PATH_HPP__
+
+#include <string>
+#include <vector>
+
+namespace fs
+{
+  namespace path
+  {
+    using std::string;
+
+    void dirname(string &path);
+
+    string basename(const string &path);
+
+    inline
+    void
+    append(string     &base,
+           const char *suffix)
+    {
+      base += suffix;
+    }
+
+    inline
+    void
+    make(const string *base,
+         const char   *suffix,
+         string       &output)
+    {
+      output  = *base;
+      output += suffix;
+    }
+  }
+};
+
+#endif // __FS_PATH_HPP__

src/fs_xattr.cpp

@@ -0,0 +1,391 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <string>
+#include <vector>
+#include <map>
+#include <sstream>
+
+#include "str.hpp"
+#include "xattr.hpp"
+
+using std::string;
+using std::vector;
+using std::map;
+using std::istringstream;
+
+namespace fs
+{
+  namespace xattr
+  {
+    int
+    list(const int     fd,
+         vector<char> &attrs)
+    {
+#ifndef WITHOUT_XATTR
+      ssize_t rv;
+      ssize_t size;
+
+      rv    = -1;
+      errno = ERANGE;
+      while(rv == -1 && errno == ERANGE)
+        {
+          size = ::flistxattr(fd,NULL,0);
+          attrs.resize(size);
+          if(size == 0)
+            return 0;
+          rv = ::flistxattr(fd,&attrs[0],size);
+        }
+
+      return rv;
+#else
+      errno = ENOTSUP;
+      return -1;
+#endif
+    }
+
+    int
+    list(const string &path,
+         vector<char> &attrs)
+    {
+#ifndef WITHOUT_XATTR
+      int rv;
+      int size;
+
+      rv    = -1;
+      errno = ERANGE;
+      while(rv == -1 && errno == ERANGE)
+        {
+          size = ::listxattr(path.c_str(),NULL,0);
+          attrs.resize(size);
+          if(size == 0)
+            return 0;
+          rv = ::listxattr(path.c_str(),&attrs[0],size);
+        }
+
+      return rv;
+#else
+      errno = ENOTSUP;
+      return -1;
+#endif
+    }
+
+    int
+    list(const int        fd,
+          vector<string> &attrvector)
+    {
+      int rv;
+      vector<char> attrs;
+
+      rv = list(fd,attrs);
+      if(rv != -1)
+        {
+          string tmp(attrs.begin(),attrs.end());
+          str::split(attrvector,tmp,'\0');
+        }
+
+      return rv;
+    }
+
+    int
+    list(const string   &path,
+         vector<string> &attrvector)
+    {
+      int rv;
+      vector<char> attrs;
+
+      rv = list(path,attrs);
+      if(rv != -1)
+        {
+          string tmp(attrs.begin(),attrs.end());
+          str::split(attrvector,tmp,'\0');
+        }
+
+      return rv;
+    }
+
+    int
+    list(const int  fd,
+          string   &attrstr)
+    {
+      int rv;
+      vector<char> attrs;
+
+      rv = list(fd,attrs);
+      if(rv != -1)
+        attrstr = string(attrs.begin(),attrs.end());
+
+      return rv;
+    }
+
+    int
+    list(const string &path,
+         string       &attrstr)
+    {
+      int rv;
+      vector<char> attrs;
+
+      rv = list(path,attrs);
+      if(rv != -1)
+        attrstr = string(attrs.begin(),attrs.end());
+
+      return rv;
+    }
+
+    int
+    get(const int     fd,
+        const string &attr,
+        vector<char> &value)
+    {
+#ifndef WITHOUT_XATTR
+      int rv;
+      int size;
+
+      rv    = -1;
+      errno = ERANGE;
+      while(rv == -1 && errno == ERANGE)
+        {
+          size = ::fgetxattr(fd,attr.c_str(),NULL,0);
+          value.resize(size);
+          if(size == 0)
+            return 0;
+          rv = ::fgetxattr(fd,attr.c_str(),&value[0],size);
+        }
+
+      return rv;
+#else
+      errno = ENOTSUP;
+      return -1;
+#endif
+    }
+
+    int
+    get(const string &path,
+        const string &attr,
+        vector<char> &value)
+    {
+#ifndef WITHOUT_XATTR
+      int rv;
+      int size;
+
+      rv    = -1;
+      errno = ERANGE;
+      while(rv == -1 && errno == ERANGE)
+        {
+          size = ::getxattr(path.c_str(),attr.c_str(),NULL,0);
+          value.resize(size);
+          if(size == 0)
+            return 0;
+          rv = ::getxattr(path.c_str(),attr.c_str(),&value[0],size);
+        }
+
+      return rv;
+#else
+      errno = ENOTSUP;
+      return -1;
+#endif
+    }
+
+    int
+    get(const int     fd,
+        const string &attr,
+        string       &value)
+    {
+      int          rv;
+      vector<char> tmpvalue;
+
+      rv = get(fd,attr,tmpvalue);
+      if(rv != -1)
+        value = string(tmpvalue.begin(),tmpvalue.end());
+
+      return rv;
+    }
+
+    int
+    get(const string &path,
+        const string &attr,
+        string       &value)
+    {
+      int          rv;
+      vector<char> tmpvalue;
+
+      rv = get(path,attr,tmpvalue);
+      if(rv != -1)
+        value = string(tmpvalue.begin(),tmpvalue.end());
+
+      return rv;
+    }
+
+    int
+    get(const int           fd,
+        map<string,string> &attrs)
+    {
+      int rv;
+      string attrstr;
+
+      rv = list(fd,attrstr);
+      if(rv == -1)
+        return -1;
+
+      {
+        string key;
+        istringstream ss(attrstr);
+
+        while(getline(ss,key,'\0'))
+          {
+            string value;
+
+            rv = get(fd,key,value);
+            if(rv != -1)
+              attrs[key] = value;
+          }
+      }
+
+      return 0;
+    }
+
+    int
+    get(const string       &path,
+        map<string,string> &attrs)
+    {
+      int rv;
+      string attrstr;
+
+      rv = list(path,attrstr);
+      if(rv == -1)
+        return -1;
+
+      {
+        string key;
+        istringstream ss(attrstr);
+
+        while(getline(ss,key,'\0'))
+          {
+            string value;
+
+            rv = get(path,key,value);
+            if(rv != -1)
+              attrs[key] = value;
+          }
+      }
+
+      return 0;
+    }
+
+    int
+    set(const int     fd,
+        const string &key,
+        const string &value,
+        const int     flags)
+    {
+#ifndef WITHOUT_XATTR
+      return ::fsetxattr(fd,
+                         key.c_str(),
+                         value.data(),
+                         value.size(),
+                         flags);
+#else
+      errno = ENOTSUP;
+      return -1;
+#endif
+    }
+
+    int
+    set(const string &path,
+        const string &key,
+        const string &value,
+        const int     flags)
+    {
+#ifndef WITHOUT_XATTR
+      return ::setxattr(path.c_str(),
+                        key.c_str(),
+                        value.data(),
+                        value.size(),
+                        flags);
+#else
+      errno = ENOTSUP;
+      return -1;
+#endif
+    }
+
+    int
+    set(const int                 fd,
+        const map<string,string> &attrs)
+    {
+      int rv;
+
+      for(map<string,string>::const_iterator
+            i = attrs.begin(), ei = attrs.end(); i != ei; ++i)
+        {
+          rv = set(fd,i->first,i->second,0);
+          if(rv == -1)
+            return -1;
+        }
+
+      return 0;
+    }
+
+    int
+    set(const string             &path,
+        const map<string,string> &attrs)
+    {
+      int fd;
+
+      fd = ::open(path.c_str(),O_RDONLY|O_NONBLOCK);
+      if(fd == -1)
+        return -1;
+
+      set(fd,attrs);
+
+      return ::close(fd);
+    }
+
+    int
+    copy(const int fdin,
+         const int fdout)
+    {
+      int rv;
+      map<string,string> attrs;
+
+      rv = get(fdin,attrs);
+      if(rv == -1)
+        return -1;
+
+      return set(fdout,attrs);
+    }
+
+    int
+    copy(const string &from,
+         const string &to)
+    {
+      int rv;
+      map<string,string> attrs;
+
+      rv = get(from,attrs);
+      if(rv == -1)
+        return -1;
+
+      return set(to,attrs);
+    }
+  }
+}

src/fs_xattr.hpp

@@ -0,0 +1,70 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef __FS_XATTR_HPP__
+#define __FS_XATTR_HPP__
+
+#include <string>
+#include <vector>
+#include <map>
+
+namespace fs
+{
+  namespace xattr
+  {
+    using std::size_t;
+    using std::string;
+    using std::vector;
+    using std::map;
+
+
+    int list(const string   &path,
+             vector<char>   &attrs);
+    int list(const string   &path,
+             string         &attrs);
+    int list(const string   &path,
+             vector<string> &attrs);
+
+    int get(const string &path,
+            const string &attr,
+            vector<char> &value);
+    int get(const string &path,
+            const string &attr,
+            string       &value);
+
+    int get(const string       &path,
+            map<string,string> &attrs);
+
+    int set(const string &path,
+            const string &key,
+            const string &value,
+            const int     flags);
+    int set(const int     fd,
+            const string &key,
+            const string &value,
+            const int     flags);
+
+    int set(const string             &path,
+            const map<string,string> &attrs);
+
+    int copy(const int fdin,
+             const int fdout);
+    int copy(const string &from,
+             const string &to);
+  }
+}
+
+#endif // __FS_HPP__

src/fsync.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #ifndef _GNU_SOURCE
@@ -34,6 +26,8 @@
 #include <unistd.h>
 #include <errno.h>
 
+#include "fileinfo.hpp"
+
 static
 int
 _fsync(const int fd,
@@ -50,14 +44,16 @@ _fsync(const int fd,
 
 namespace mergerfs
 {
-  namespace fsync
+  namespace fuse
   {
     int
-    fsync(const char            *fusepath,
-          int                    isdatasync,
-          struct fuse_file_info *ffi)
+    fsync(const char     *fusepath,
+          int             isdatasync,
+          fuse_file_info *ffi)
     {
-      return _fsync(ffi->fh,
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
+
+      return _fsync(fi->fd,
                     isdatasync);
     }
   }

src/fsync.hpp

@@ -1,36 +1,28 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
 
 namespace mergerfs
 {
-  namespace fsync
+  namespace fuse
   {
     int
-    fsync(const char            *fusepath,
-          int                    isdatasync,
-          struct fuse_file_info *fi);
+    fsync(const char     *fusepath,
+          int             isdatasync,
+          fuse_file_info *fi);
   }
 }

src/ftruncate.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -28,6 +20,8 @@
 #include <sys/types.h>
 #include <errno.h>
 
+#include "fileinfo.hpp"
+
 static
 int
 _ftruncate(const int   fd,
@@ -42,14 +36,16 @@ _ftruncate(const int   fd,
 
 namespace mergerfs
 {
-  namespace ftruncate
+  namespace fuse
   {
     int
-    ftruncate(const char            *fusepath,
-              off_t                  size,
-              struct fuse_file_info *ffi)
+    ftruncate(const char     *fusepath,
+              off_t           size,
+              fuse_file_info *ffi)
     {
-      return _ftruncate(ffi->fh,
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
+
+      return _ftruncate(fi->fd,
                         size);
     }
   }

src/ftruncate.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -29,11 +21,11 @@
 
 namespace mergerfs
 {
-  namespace ftruncate
+  namespace fuse
   {
     int
-    ftruncate(const char            *fusepath,
-              off_t                  size,
-              struct fuse_file_info *fi);
+    ftruncate(const char     *fusepath,
+              off_t           size,
+              fuse_file_info *fi);
   }
 }

src/fusefunc.cpp

@@ -1,25 +1,17 @@
 /*
-  The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-  Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <string>

src/fusefunc.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #ifndef __FUSEFUNC_HPP__

src/getattr.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -33,25 +25,28 @@
 #include <errno.h>
 
 #include "config.hpp"
-#include "fs.hpp"
-#include "ugid.hpp"
+#include "fs_path.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
+using mergerfs::Policy;
 
 static
 int
 _getattr_controlfile(struct stat &buf)
 {
-  time_t now = time(NULL);
+  static const uid_t  uid = ::getuid();
+  static const gid_t  gid = ::getgid();
+  static const time_t now = ::time(NULL);
 
   buf.st_dev     = 0;
   buf.st_ino     = 0;
   buf.st_mode    = (S_IFREG|S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH);
   buf.st_nlink   = 1;
-  buf.st_uid     = ::getuid();
-  buf.st_gid     = ::getgid();
+  buf.st_uid     = uid;
+  buf.st_gid     = gid;
   buf.st_rdev    = 0;
   buf.st_size    = 0;
   buf.st_blksize = 1024;
@@ -65,42 +60,47 @@ _getattr_controlfile(struct stat &buf)
 
 static
 int
-_getattr(const fs::find::Func  searchFunc,
+_getattr(Policy::Func::Search  searchFunc,
          const vector<string> &srcmounts,
-         const string         &fusepath,
+         const size_t          minfreespace,
+         const char           *fusepath,
          struct stat          &buf)
 {
   int rv;
-  fs::Paths path;
+  string fullpath;
+  vector<const string*> basepaths;
 
-  rv = searchFunc(srcmounts,fusepath,path,1);
+  rv = searchFunc(srcmounts,fusepath,minfreespace,basepaths);
   if(rv == -1)
     return -errno;
 
-  rv = ::lstat(path[0].full.c_str(),&buf);
+  fs::path::make(basepaths[0],fusepath,fullpath);
+
+  rv = ::lstat(fullpath.c_str(),&buf);
 
   return ((rv == -1) ? -errno : 0);
 }
 
 namespace mergerfs
 {
-  namespace getattr
+  namespace fuse
   {
     int
     getattr(const char  *fusepath,
             struct stat *st)
     {
-      const config::Config &config = config::get();
+      const fuse_context *fc     = fuse_get_context();
+      const Config       &config = Config::get(fc);
 
       if(fusepath == config.controlfile)
         return _getattr_controlfile(*st);
 
-      const struct fuse_context *fc = fuse_get_context();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const ugid::Set         ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard readlock(&config.srcmountslock);
 
-      return _getattr(*config.getattr,
+      return _getattr(config.getattr,
                       config.srcmounts,
+                      config.minfreespace,
                       fusepath,
                       *st);
     }

src/getattr.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <sys/types.h>
@@ -28,7 +20,7 @@
 
 namespace mergerfs
 {
-  namespace getattr
+  namespace fuse
   {
     int
     getattr(const char  *fusepath,

src/getxattr.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -30,31 +22,51 @@
 #include <algorithm>
 
 #include <errno.h>
-#include <sys/types.h>
+#include <stdio.h>
 #include <string.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include "config.hpp"
-#include "fs.hpp"
-#include "ugid.hpp"
+#include "fs_path.hpp"
 #include "rwlock.hpp"
-#include "xattr.hpp"
 #include "str.hpp"
+#include "ugid.hpp"
+#include "version.hpp"
+#include "xattr.hpp"
 
 using std::string;
 using std::vector;
 using std::set;
 using namespace mergerfs;
-using namespace mergerfs::config;
+
+static
+int
+_lgetxattr(const string &path,
+           const char   *attrname,
+           void         *value,
+           const size_t  size)
+{
+#ifndef WITHOUT_XATTR
+  int rv;
+
+  rv = ::lgetxattr(path.c_str(),attrname,value,size);
+
+  return ((rv == -1) ? -errno : rv);
+#else
+  return -ENOTSUP;
+#endif
+}
 
 static
 void
 _getxattr_controlfile_fusefunc_policy(const Config &config,
-                                      const char   *attrbasename,
+                                      const string &attr,
                                       string       &attrvalue)
 {
   FuseFunc fusefunc;
 
-  fusefunc = FuseFunc::find(attrbasename);
+  fusefunc = FuseFunc::find(attr);
   if(fusefunc != FuseFunc::invalid)
     attrvalue = (std::string)*config.policies[(FuseFunc::Enum::Type)*fusefunc];
 }
@@ -62,12 +74,12 @@ _getxattr_controlfile_fusefunc_policy(const Config &config,
 static
 void
 _getxattr_controlfile_category_policy(const Config &config,
-                                      const char   *attrbasename,
+                                      const string &attr,
                                       string       &attrvalue)
 {
   Category cat;
 
-  cat = Category::find(attrbasename);
+  cat = Category::find(attr);
   if(cat != Category::invalid)
     {
       vector<string> policies;
@@ -92,6 +104,60 @@ _getxattr_controlfile_srcmounts(const Config &config,
   attrvalue = str::join(config.srcmounts,':');
 }
 
+static
+void
+_getxattr_controlfile_minfreespace(const Config &config,
+                                   string       &attrvalue)
+{
+  char buf[64];
+  unsigned long long minfreespace;
+
+  minfreespace = (unsigned long long)config.minfreespace;
+  snprintf(buf,sizeof(buf),"%llu",minfreespace);
+
+  attrvalue = buf;
+}
+
+static
+void
+_getxattr_controlfile_moveonenospc(const Config &config,
+                                   string       &attrvalue)
+{
+  attrvalue = (config.moveonenospc ? "true" : "false");
+}
+
+static
+void
+_getxattr_controlfile_policies(const Config &config,
+                               string       &attrvalue)
+{
+  size_t i = Policy::Enum::begin();
+
+  attrvalue = (string)Policy::policies[i];
+  for(i++; i < Policy::Enum::end(); i++)
+    attrvalue += ',' + (string)Policy::policies[i];
+}
+
+static
+void
+_getxattr_controlfile_version(string &attrvalue)
+{
+  attrvalue = MERGERFS_VERSION;
+}
+
+static
+void
+_getxattr_pid(string &attrvalue)
+{
+  int pid;
+  char buf[32];
+
+  pid = getpid();
+  snprintf(buf,sizeof(buf),"%d",pid);
+
+  attrvalue = buf;
+}
+
 static
 int
 _getxattr_controlfile(const Config &config,
@@ -101,17 +167,36 @@ _getxattr_controlfile(const Config &config,
 {
   size_t len;
   string attrvalue;
-  const char *attrbasename = &attrname[sizeof("user.mergerfs.")-1];
+  vector<string> attr;
 
-  if(strncmp("user.mergerfs.",attrname,sizeof("user.mergerfs.")-1))
+  str::split(attr,attrname,'.');
+  if((attr[0] != "user") || (attr[1] != "mergerfs"))
     return -ENOATTR;
 
-  if(!strcmp("srcmounts",attrbasename))
-    _getxattr_controlfile_srcmounts(config,attrvalue);
-  else if(!strncmp("category.",attrbasename,sizeof("category.")-1))
-    _getxattr_controlfile_category_policy(config,&attrbasename[sizeof("category.")-1],attrvalue);
-  else if(!strncmp("func.",attrbasename,sizeof("func.")-1))
-    _getxattr_controlfile_fusefunc_policy(config,&attrbasename[sizeof("func.")-1],attrvalue);
+  switch(attr.size())
+    {
+    case 3:
+      if(attr[2] == "srcmounts")
+        _getxattr_controlfile_srcmounts(config,attrvalue);
+      else if(attr[2] == "minfreespace")
+        _getxattr_controlfile_minfreespace(config,attrvalue);
+      else if(attr[2] == "moveonenospc")
+        _getxattr_controlfile_moveonenospc(config,attrvalue);
+      else if(attr[2] == "policies")
+        _getxattr_controlfile_policies(config,attrvalue);
+      else if(attr[2] == "version")
+        _getxattr_controlfile_version(attrvalue);
+      else if(attr[2] == "pid")
+        _getxattr_pid(attrvalue);
+      break;
+
+    case 4:
+      if(attr[2] == "category")
+        _getxattr_controlfile_category_policy(config,attr[3],attrvalue);
+      else if(attr[2] == "func")
+        _getxattr_controlfile_fusefunc_policy(config,attr[3],attrvalue);
+      break;
+    }
 
   if(attrvalue.empty())
     return -ENOATTR;
@@ -141,7 +226,7 @@ _getxattr_from_string(char         *destbuf,
     return srcbufsize;
 
   if(srcbufsize > destbufsize)
-    return (errno = ERANGE, -1);
+    return -ERANGE;
 
   memcpy(destbuf,src.data(),srcbufsize);
 
@@ -151,7 +236,7 @@ _getxattr_from_string(char         *destbuf,
 static
 int
 _getxattr_user_mergerfs_allpaths(const vector<string> &srcmounts,
-                                 const string         &fusepath,
+                                 const char           *fusepath,
                                  char                 *buf,
                                  const size_t          count)
 {
@@ -162,63 +247,66 @@ _getxattr_user_mergerfs_allpaths(const vector<string> &srcmounts,
 
   concated = str::join(paths,'\0');
 
-  return ::_getxattr_from_string(buf,count,concated);
+  return _getxattr_from_string(buf,count,concated);
 }
 
 static
 int
-_getxattr_user_mergerfs(const fs::Path       &path,
+_getxattr_user_mergerfs(const string         &basepath,
+                        const char           *fusepath,
+                        const string         &fullpath,
                         const vector<string> &srcmounts,
-                        const string         &fusepath,
                         const char           *attrname,
                         char                 *buf,
                         const size_t          count)
 {
-  const char *attrbasename = &attrname[sizeof("user.mergerfs")];
+  vector<string> attr;
 
-  if(!strcmp(attrbasename,"basepath"))
-    return ::_getxattr_from_string(buf,count,path.base);
-  else if(!strcmp(attrbasename,"fullpath"))
-    return ::_getxattr_from_string(buf,count,path.full);
-  else if(!strcmp(attrbasename,"relpath"))
-    return ::_getxattr_from_string(buf,count,fusepath);
-  else if(!strcmp(attrbasename,"allpaths"))
-    return ::_getxattr_user_mergerfs_allpaths(srcmounts,fusepath,buf,count);
+  str::split(attr,attrname,'.');
 
-  return ::lgetxattr(path.full.c_str(),attrname,buf,count);
+  if(attr[2] == "basepath")
+    return _getxattr_from_string(buf,count,basepath);
+  else if(attr[2] ==  "relpath")
+    return _getxattr_from_string(buf,count,fusepath);
+  else if(attr[2] == "fullpath")
+    return _getxattr_from_string(buf,count,fullpath);
+  else if(attr[2] == "allpaths")
+    return _getxattr_user_mergerfs_allpaths(srcmounts,fusepath,buf,count);
+
+  return -ENOATTR;
 }
 
 static
 int
-_getxattr(const fs::find::Func  searchFunc,
+_getxattr(Policy::Func::Search  searchFunc,
           const vector<string> &srcmounts,
-          const string         &fusepath,
+          const size_t          minfreespace,
+          const char           *fusepath,
           const char           *attrname,
           char                 *buf,
           const size_t          count)
 {
-#ifndef WITHOUT_XATTR
   int rv;
-  fs::Paths path;
+  string fullpath;
+  vector<const string*> basepaths;
 
-  rv = searchFunc(srcmounts,fusepath,path,1);
+  rv = searchFunc(srcmounts,fusepath,minfreespace,basepaths);
   if(rv == -1)
     return -errno;
 
-  if(!strncmp("user.mergerfs.",attrname,sizeof("user.mergerfs.")-1))
-    rv = _getxattr_user_mergerfs(path[0],srcmounts,fusepath,attrname,buf,count);
-  else
-    rv = ::lgetxattr(path[0].full.c_str(),attrname,buf,count);
+  fs::path::make(basepaths[0],fusepath,fullpath);
 
-  return ((rv == -1) ? -errno : rv);
-#else
-  return -ENOTSUP;
-#endif
+  if(str::isprefix(attrname,"user.mergerfs."))
+    rv = _getxattr_user_mergerfs(*basepaths[0],fusepath,fullpath,srcmounts,attrname,buf,count);
+  else
+    rv = _lgetxattr(fullpath,attrname,buf,count);
+
+  return rv;
 }
 
 namespace mergerfs
 {
-  namespace getxattr
+  namespace fuse
   {
     int
     getxattr(const char *fusepath,
@@ -226,7 +314,8 @@ namespace mergerfs
              char       *buf,
              size_t      count)
     {
-      const config::Config &config = config::get();
+      const fuse_context *fc     = fuse_get_context();
+      const Config       &config = Config::get(fc);
 
       if(fusepath == config.controlfile)
         return _getxattr_controlfile(config,
@@ -234,12 +323,12 @@ namespace mergerfs
                                      buf,
                                      count);
 
-      const struct fuse_context *fc = fuse_get_context();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const ugid::Set         ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard readlock(&config.srcmountslock);
 
-      return _getxattr(*config.getxattr,
+      return _getxattr(config.getxattr,
                        config.srcmounts,
+                       config.minfreespace,
                        fusepath,
                        attrname,
                        buf,

src/getxattr.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace getxattr
+  namespace fuse
   {
     int
     getxattr(const char *fusepath,

src/gidcache.cpp

@@ -0,0 +1,155 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <pwd.h>
+#include <grp.h>
+#include <unistd.h>
+
+#if defined __linux__ and UGID_USE_RWLOCK == 0
+# include <sys/syscall.h>
+#endif
+
+#include <cstdlib>
+#include <algorithm>
+
+#include "gidcache.hpp"
+
+inline
+bool
+gid_t_rec::operator<(const struct gid_t_rec &b) const
+{
+  return uid < b.uid;
+}
+
+inline
+gid_t_rec *
+gid_t_cache::begin(void)
+{
+  return recs;
+}
+
+inline
+gid_t_rec *
+gid_t_cache::end(void)
+{
+  return recs + size;
+}
+
+inline
+gid_t_rec *
+gid_t_cache::allocrec(void)
+{
+  if(size == MAXRECS)
+    return &recs[rand() % MAXRECS];
+  else
+    return &recs[size++];
+}
+
+inline
+gid_t_rec *
+gid_t_cache::lower_bound(gid_t_rec   *begin,
+                         gid_t_rec   *end,
+                         const uid_t  uid)
+{
+  int step;
+  int count;
+  gid_t_rec *iter;
+
+  count = std::distance(begin,end);
+  while(count > 0)
+    {
+      iter = begin;
+      step = count / 2;
+      std::advance(iter,step);
+      if(iter->uid < uid)
+        {
+          begin  = ++iter;
+          count -= step + 1;
+        }
+      else
+        {
+          count = step;
+        }
+    }
+
+  return begin;
+}
+
+gid_t_rec *
+gid_t_cache::cache(const uid_t uid,
+                   const gid_t gid)
+{
+  int rv;
+  char buf[4096];
+  struct passwd pwd;
+  struct passwd *pwdrv;
+  gid_t_rec *rec;
+
+  rec = allocrec();
+
+  rec->uid = uid;
+  rv = ::getpwuid_r(uid,&pwd,buf,sizeof(buf),&pwdrv);
+  if(pwdrv != NULL && rv == 0)
+    {
+      rec->size = 0;
+      ::getgrouplist(pwd.pw_name,gid,NULL,&rec->size);
+      rec->size = std::min(MAXGIDS,rec->size);
+      rv = ::getgrouplist(pwd.pw_name,gid,rec->gids,&rec->size);
+      if(rv == -1)
+        {
+          rec->gids[0] = gid;
+          rec->size    = 1;
+        }
+    }
+
+  return rec;
+}
+
+static
+inline
+int
+setgroups(const gid_t_rec *rec)
+{
+#if defined __linux__ and UGID_USE_RWLOCK == 0
+  return ::syscall(SYS_setgroups,rec->size,rec->gids);
+#else
+  return ::setgroups(rec->size,rec->gids);
+#endif
+}
+
+int
+gid_t_cache::initgroups(const uid_t uid,
+                        const gid_t gid)
+{
+  int rv;
+  gid_t_rec *rec;
+
+  rec = lower_bound(begin(),end(),uid);
+  if(rec == end() || rec->uid != uid)
+    {
+      rec = cache(uid,gid);
+      rv = ::setgroups(rec);
+      std::sort(begin(),end());
+    }
+  else
+    {
+      rv = ::setgroups(rec);
+    }
+
+  return rv;
+}

src/gidcache.hpp

@@ -0,0 +1,58 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef __GIDCACHE_HPP__
+#define __GIDCACHE_HPP__
+
+#include <sys/types.h>
+#include <unistd.h>
+
+#define MAXGIDS 32
+#define MAXRECS 256
+
+struct gid_t_rec
+{
+  uid_t uid;
+  int   size;
+  gid_t gids[MAXGIDS];
+
+  bool
+  operator<(const struct gid_t_rec &b) const;
+};
+
+struct gid_t_cache
+{
+public:
+  size_t     size;
+  gid_t_rec  recs[MAXRECS];
+
+private:
+  gid_t_rec * begin(void);
+  gid_t_rec * end(void);
+  gid_t_rec * allocrec(void);
+  gid_t_rec * lower_bound(gid_t_rec   *begin,
+                          gid_t_rec   *end,
+                          const uid_t  uid);
+  gid_t_rec * cache(const uid_t uid,
+                    const gid_t gid);
+
+public:
+  int
+  initgroups(const uid_t uid,
+             const gid_t gid);
+};
+
+#endif

src/init.cpp

@@ -1,43 +1,38 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
 
 #include "config.hpp"
+#include "ugid.hpp"
 
 namespace mergerfs
 {
-  namespace init
+  namespace fuse
   {
     void *
-    init(struct fuse_conn_info *conn)
+    init(fuse_conn_info *conn)
     {
+      ugid::init();
+
 #ifdef FUSE_CAP_IOCTL_DIR
       conn->want |= FUSE_CAP_IOCTL_DIR;
 #endif
 
-      return &config::get_writable();
+      return &Config::get_writable();
     }
   }
 }

src/init.hpp

@@ -1,32 +1,24 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace init
+  namespace fuse
   {
     void *
-    init(struct fuse_conn_info *conn);
+    init(fuse_conn_info *conn);
   }
 }

src/ioctl.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -32,8 +24,10 @@
 #include <linux/fs.h>
 
 #include "config.hpp"
-#include "ugid.hpp"
+#include "fileinfo.hpp"
+#include "fs_path.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
@@ -41,122 +35,101 @@ using namespace mergerfs;
 
 static
 int
-_ioctl(const int           fd,
-       const int           cmd,
-       void               *arg,
-       const unsigned int  flags,
-       void               *data)
+_ioctl(const int  fd,
+       const int  cmd,
+       void      *data)
 {
   int rv;
 
-  switch(cmd)
-    {
-#ifdef FS_IOC_GETFLAGS
-    case FS_IOC_GETFLAGS:
-    case FS_IOC_SETFLAGS:
-#endif
-#ifdef FS_IOC32_GETFLAGS
-    case FS_IOC32_SETFLAGS:
-    case FS_IOC32_GETFLAGS:
-#endif
-#ifdef FS_IOC_GETVERSION
-    case FS_IOC_GETVERSION:
-    case FS_IOC_SETVERSION:
-#endif
-#ifdef FS_IOC32_GETVERSION
-    case FS_IOC32_GETVERSION:
-    case FS_IOC32_SETVERSION:
-#endif
-      rv = ::ioctl(fd,cmd,data);
-      break;
-
-    default:
-      rv = -1;
-      errno = ENOTTY;
-      break;
-    }
+  rv = ::ioctl(fd,cmd,data);
 
   return ((rv == -1) ? -errno : rv);
 }
 
 #ifdef FUSE_IOCTL_DIR
+
+#ifndef O_DIRECTORY
+#define O_DIRECTORY 0
+#endif
+
+#ifndef O_NOATIME
+#define O_NOATIME 0
+#endif
+
 static
 int
-_ioctl_dir_base(const fs::find::Func  searchFunc,
+_ioctl_dir_base(Policy::Func::Search  searchFunc,
                 const vector<string> &srcmounts,
-                const string         &fusepath,
+                const size_t          minfreespace,
+                const char           *fusepath,
                 const int             cmd,
-                void                 *arg,
-                const unsigned int    flags,
                 void                 *data)
 {
   int fd;
   int rv;
-  fs::Paths path;
+  string fullpath;
+  vector<const string*> basepaths;
 
-  rv = searchFunc(srcmounts,fusepath,path,1);
+  rv = searchFunc(srcmounts,fusepath,minfreespace,basepaths);
   if(rv == -1)
     return -errno;
 
-  fd = ::open(path[0].full.c_str(),flags);
+  fs::path::make(basepaths[0],fusepath,fullpath);
+
+  const int flags = O_RDWR | O_NOATIME | O_DIRECTORY;
+  fd = ::open(fullpath.c_str(),flags);
   if(fd == -1)
     return -errno;
 
-  rv = _ioctl(fd,cmd,arg,flags,data);
+  rv = _ioctl(fd,cmd,data);
 
-  close(fd);
+  ::close(fd);
 
   return rv;
 }
 
 static
 int
-_ioctl_dir(const string       &fusepath,
-           const int           cmd,
-           void               *arg,
-           const unsigned int  flags,
-           void               *data)
+_ioctl_dir(const char *fusepath,
+           const int   cmd,
+           void       *data)
 {
-  const struct fuse_context *fc     = fuse_get_context();
-  const config::Config      &config = config::get(fc);
-  const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-  const rwlock::ReadGuard    readlock(&config.srcmountslock);
+  const fuse_context      *fc     = fuse_get_context();
+  const Config            &config = Config::get(fc);
+  const ugid::Set          ugid(fc->uid,fc->gid);
+  const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-  return _ioctl_dir_base(*config.getattr,
+  return _ioctl_dir_base(config.getattr,
                          config.srcmounts,
+                         config.minfreespace,
                          fusepath,
                          cmd,
-                         arg,
-                         flags,
                          data);
 }
 #endif
 
 namespace mergerfs
 {
-  namespace ioctl
+  namespace fuse
   {
     int
-    ioctl(const char            *fusepath,
-          int                    cmd,
-          void                  *arg,
-          struct fuse_file_info *ffi,
-          unsigned int           flags,
-          void                  *data)
+    ioctl(const char     *fusepath,
+          int             cmd,
+          void           *arg,
+          fuse_file_info *ffi,
+          unsigned int    flags,
+          void           *data)
     {
 #ifdef FUSE_IOCTL_DIR
       if(flags & FUSE_IOCTL_DIR)
         return _ioctl_dir(fusepath,
                           cmd,
-                          arg,
-                          flags,
                           data);
 #endif
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
 
-      return _ioctl(ffi->fh,
+      return _ioctl(fi->fd,
                     cmd,
-                    arg,
-                    flags,
                     data);
     }
   }

src/ioctl.hpp

@@ -1,37 +1,29 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace ioctl
+  namespace fuse
   {
     int
-    ioctl(const char            *fusepath,
-          int                    cmd,
-          void                  *arg,
-          struct fuse_file_info *fi,
-          unsigned int           flags,
-          void                  *data);
+    ioctl(const char     *fusepath,
+          int             cmd,
+          void           *arg,
+          fuse_file_info *fi,
+          unsigned int    flags,
+          void           *data);
   }
 }

src/link.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -31,43 +23,131 @@
 #include <unistd.h>
 
 #include "config.hpp"
-#include "fs.hpp"
-#include "ugid.hpp"
+#include "fs_clonepath.hpp"
+#include "fs_path.hpp"
+#include "rv.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
 using mergerfs::Policy;
+using namespace mergerfs;
 
 static
 int
-_single_link(const fs::find::Func  searchFunc,
-             const vector<string> &srcmounts,
-             const string         &base,
-             const string         &oldpath,
-             const string         &newpath)
+_link_create_path_core(const string &oldbasepath,
+                       const string &newbasepath,
+                       const char   *oldfusepath,
+                       const char   *newfusepath,
+                       const string &newfusedirpath,
+                       const int     error)
 {
   int rv;
-  const string fulloldpath = fs::make_path(base,oldpath);
-  const string fullnewpath = fs::make_path(base,newpath);
+  string oldfullpath;
+  string newfullpath;
 
-  rv = ::link(fulloldpath.c_str(),fullnewpath.c_str());
-  if(rv == -1 && errno == ENOENT)
+  if(oldbasepath != newbasepath)
     {
-      string newpathdir;
-      fs::Paths foundpath;
+      const ugid::SetRootGuard ugidGuard;
+      fs::clonepath(newbasepath,oldbasepath,newfusedirpath.c_str());
+    }
 
-      newpathdir = fs::dirname(newpath);
-      rv = searchFunc(srcmounts,newpathdir,foundpath,1);
-      if(rv == -1)
-        return -1;
+  fs::path::make(&oldbasepath,oldfusepath,oldfullpath);
+  fs::path::make(&oldbasepath,newfusepath,newfullpath);
 
-      {
-        const mergerfs::ugid::SetResetGuard ugid(0,0);
-        fs::clonepath(foundpath[0].base,base,newpathdir);
-      }
+  rv = ::link(oldfullpath.c_str(),newfullpath.c_str());
 
-      rv = ::link(fulloldpath.c_str(),fullnewpath.c_str());
+  return calc_error(rv,error,errno);
+}
+
+static
+int
+_link_create_path_loop(const vector<const string*> &oldbasepaths,
+                       const string                &newbasepath,
+                       const char                  *oldfusepath,
+                       const char                  *newfusepath,
+                       const string                &newfusedirpath)
+{
+  int error;
+
+  error = -1;
+  for(size_t i = 0, ei = oldbasepaths.size(); i != ei; i++)
+    {
+      error = _link_create_path_core(*oldbasepaths[i],newbasepath,
+                                     oldfusepath,newfusepath,
+                                     newfusedirpath,
+                                     error);
+    }
+
+  return -error;
+}
+
+static
+int
+_link_create_path(Policy::Func::Search  searchFunc,
+                  Policy::Func::Action  actionFunc,
+                  const vector<string> &srcmounts,
+                  const size_t          minfreespace,
+                  const char           *oldfusepath,
+                  const char           *newfusepath)
+{
+  int rv;
+  string newfusedirpath;
+  vector<const string*> oldbasepaths;
+  vector<const string*> newbasepaths;
+
+  rv = actionFunc(srcmounts,oldfusepath,minfreespace,oldbasepaths);
+  if(rv == -1)
+    return -errno;
+
+  newfusedirpath = newfusepath;
+  fs::path::dirname(newfusedirpath);
+  rv = searchFunc(srcmounts,newfusedirpath.c_str(),minfreespace,newbasepaths);
+  if(rv == -1)
+    return -errno;
+
+  return _link_create_path_loop(oldbasepaths,*newbasepaths[0],
+                                oldfusepath,newfusepath,
+                                newfusedirpath);
+}
+
+static
+int
+_clonepath_if_would_create(Policy::Func::Search  searchFunc,
+                           Policy::Func::Create  createFunc,
+                           const vector<string> &srcmounts,
+                           const size_t          minfreespace,
+                           const string         &oldbasepath,
+                           const char           *oldfusepath,
+                           const char           *newfusepath)
+{
+  int rv;
+  string newfusedirpath;
+  const char *newfusedirpathcstr;
+  vector<const string*> newbasepath;
+
+  newfusedirpath = newfusepath;
+  fs::path::dirname(newfusedirpath);
+  newfusedirpathcstr = newfusedirpath.c_str();
+
+  rv = createFunc(srcmounts,newfusedirpathcstr,minfreespace,newbasepath);
+  if(rv != -1)
+    {
+      if(oldbasepath == *newbasepath[0])
+        {
+          rv = searchFunc(srcmounts,newfusedirpathcstr,minfreespace,newbasepath);
+          if(rv != -1)
+            {
+              const ugid::SetRootGuard ugidGuard;
+              fs::clonepath(*newbasepath[0],oldbasepath,newfusedirpathcstr);
+            }
+        }
+      else
+        {
+          rv = -1;
+          errno = EXDEV;
+        }
     }
 
   return rv;
@@ -75,50 +155,112 @@ _single_link(const fs::find::Func  searchFunc,
 
 static
 int
-_link(const fs::find::Func  searchFunc,
-      const fs::find::Func  actionFunc,
-      const vector<string> &srcmounts,
-      const string         &oldpath,
-      const string         &newpath)
+_link_preserve_path_core(Policy::Func::Search  searchFunc,
+                         Policy::Func::Create  createFunc,
+                         const vector<string> &srcmounts,
+                         const size_t          minfreespace,
+                         const string         &oldbasepath,
+                         const char           *oldfusepath,
+                         const char           *newfusepath,
+                         const int             error)
 {
   int rv;
-  int error;
-  fs::Paths oldpaths;
+  string oldfullpath;
+  string newfullpath;
 
-  rv = actionFunc(srcmounts,oldpath,oldpaths,-1);
-  if(rv == -1)
-    return -errno;
+  fs::path::make(&oldbasepath,oldfusepath,oldfullpath);
+  fs::path::make(&oldbasepath,newfusepath,newfullpath);
 
-  error = 0;
-  for(fs::Paths::const_iterator
-        i = oldpaths.begin(), ei = oldpaths.end(); i != ei; ++i)
+  rv = ::link(oldfullpath.c_str(),newfullpath.c_str());
+  if((rv == -1) && (errno == ENOENT))
     {
-      rv = _single_link(searchFunc,srcmounts,i->base,oldpath,newpath);
-      if(rv == -1)
-        error = errno;
+      rv = _clonepath_if_would_create(searchFunc,createFunc,
+                                      srcmounts,minfreespace,
+                                      oldbasepath,
+                                      oldfusepath,newfusepath);
+      if(rv != -1)
+        rv = ::link(oldfullpath.c_str(),newfullpath.c_str());
+    }
+
+  return calc_error(rv,error,errno);
+}
+
+static
+int
+_link_preserve_path_loop(Policy::Func::Search         searchFunc,
+                         Policy::Func::Create         createFunc,
+                         const vector<string>        &srcmounts,
+                         const size_t                 minfreespace,
+                         const char                  *oldfusepath,
+                         const char                  *newfusepath,
+                         const vector<const string*> &oldbasepaths)
+{
+  int error;
+
+  error = -1;
+  for(size_t i = 0, ei = oldbasepaths.size(); i != ei; i++)
+    {
+      error = _link_preserve_path_core(searchFunc,createFunc,
+                                       srcmounts,minfreespace,
+                                       *oldbasepaths[i],
+                                       oldfusepath,newfusepath,
+                                       error);
     }
 
   return -error;
 }
 
+static
+int
+_link_preserve_path(Policy::Func::Search  searchFunc,
+                    Policy::Func::Action  actionFunc,
+                    Policy::Func::Create  createFunc,
+                    const vector<string> &srcmounts,
+                    const size_t          minfreespace,
+                    const char          *oldfusepath,
+                    const char          *newfusepath)
+{
+  int rv;
+  vector<const string*> oldbasepaths;
+
+  rv = actionFunc(srcmounts,oldfusepath,minfreespace,oldbasepaths);
+  if(rv == -1)
+    return -errno;
+
+  return _link_preserve_path_loop(searchFunc,createFunc,
+                                  srcmounts,minfreespace,
+                                  oldfusepath,newfusepath,
+                                  oldbasepaths);
+}
+
 namespace mergerfs
 {
-  namespace link
+  namespace fuse
   {
     int
     link(const char *from,
          const char *to)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _link(*config.getattr,
-                   *config.link,
-                   config.srcmounts,
-                   from,
-                   to);
+      if(config.create->path_preserving())
+        return _link_preserve_path(config.getattr,
+                                   config.link,
+                                   config.create,
+                                   config.srcmounts,
+                                   config.minfreespace,
+                                   from,
+                                   to);
+
+      return _link_create_path(config.link,
+                               config.create,
+                               config.srcmounts,
+                               config.minfreespace,
+                               from,
+                               to);
     }
   }
 }

src/link.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace link
+  namespace fuse
   {
     int
     link(const char *from,

src/listxattr.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -31,11 +23,12 @@
 #include <errno.h>
 #include <string.h>
 
-#include "config.hpp"
+#include "buildvector.hpp"
 #include "category.hpp"
-#include "fs.hpp"
-#include "ugid.hpp"
+#include "config.hpp"
+#include "fs_path.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 #include "xattr.hpp"
 
 using std::string;
@@ -48,12 +41,21 @@ _listxattr_controlfile(char         *list,
                        const size_t  size)
 {
   string xattrs;
+  const vector<string> strs =
+    buildvector<string>
+    ("user.mergerfs.srcmounts")
+    ("user.mergerfs.minfreespace")
+    ("user.mergerfs.moveonenospc")
+    ("user.mergerfs.policies")
+    ("user.mergerfs.version")
+    ("user.mergerfs.pid");
 
-  xattrs.reserve(512);
-  xattrs.append("user.mergerfs.srcmounts",sizeof("user.mergerfs.srcmounts"));
-  for(int i = Category::Enum::BEGIN; i < Category::Enum::END; i++)
+  xattrs.reserve(1024);
+  for(size_t i = 0; i < strs.size(); i++)
+    xattrs += (strs[i] + '\0');
+  for(size_t i = Category::Enum::BEGIN; i < Category::Enum::END; i++)
     xattrs += ("user.mergerfs.category." + (std::string)*Category::categories[i] + '\0');
-  for(int i = FuseFunc::Enum::BEGIN; i < FuseFunc::Enum::END; i++)
+  for(size_t i = FuseFunc::Enum::BEGIN; i < FuseFunc::Enum::END; i++)
     xattrs += ("user.mergerfs.func." + (std::string)*FuseFunc::fusefuncs[i] + '\0');
 
   if(size == 0)
@@ -67,54 +69,60 @@ _listxattr_controlfile(char         *list,
   return xattrs.size();
 }
 
+#ifndef WITHOUT_XATTR
 static
 int
-_listxattr(const fs::find::Func  searchFunc,
+_listxattr(Policy::Func::Search  searchFunc,
            const vector<string> &srcmounts,
-           const string         &fusepath,
+           const size_t          minfreespace,
+           const char           *fusepath,
            char                 *list,
            const size_t          size)
 {
-#ifndef WITHOUT_XATTR
   int rv;
-  fs::Paths path;
+  string fullpath;
+  vector<const string*> basepaths;
 
-  rv = searchFunc(srcmounts,fusepath,path,1);
+  rv = searchFunc(srcmounts,fusepath,minfreespace,basepaths);
   if(rv == -1)
     return -errno;
 
-  rv = ::llistxattr(path[0].full.c_str(),list,size);
+  fs::path::make(basepaths[0],fusepath,fullpath);
+
+  rv = ::llistxattr(fullpath.c_str(),list,size);
 
   return ((rv == -1) ? -errno : rv);
-#else
-  return -ENOTSUP;
-#endif
 }
+#endif
 
 namespace mergerfs
 {
-  namespace listxattr
+  namespace fuse
   {
     int
     listxattr(const char *fusepath,
               char       *list,
               size_t      size)
     {
-      const config::Config &config = config::get();
+      const fuse_context *fc     = fuse_get_context();
+      const Config       &config = Config::get(fc);
 
       if(fusepath == config.controlfile)
-        return _listxattr_controlfile(list,
-                                      size);
+        return _listxattr_controlfile(list,size);
 
-      const struct fuse_context *fc = fuse_get_context();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+#ifndef WITHOUT_XATTR
+      const ugid::Set         ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard readlock(&config.srcmountslock);
 
-      return _listxattr(*config.listxattr,
+      return _listxattr(config.listxattr,
                         config.srcmounts,
+                        config.minfreespace,
                         fusepath,
                         list,
                         size);
+#else
+      return -ENOTSUP;
+#endif
     }
   }
 }

src/listxattr.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace listxattr
+  namespace fuse
   {
     int
     listxattr(const char *fusepath,

src/mergerfs.cpp

@@ -1,26 +1,18 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
- */
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
 
 #include <fuse.h>
 #include <string.h>
@@ -31,9 +23,9 @@
 #include "mergerfs.hpp"
 #include "option_parser.hpp"
 #include "resources.hpp"
-#include "fs.hpp"
+#include "fs_path.hpp"
 
-#include "clonepath.hpp"
+#include "clone.hpp"
 
 #include "access.hpp"
 #include "chmod.hpp"
@@ -80,7 +72,7 @@ namespace local
   getappname(const int     argc,
              char * const *argv)
   {
-    return fs::basename(argv[0]);
+    return fs::path::basename(argv[0]);
   }
 
   static
@@ -92,57 +84,57 @@ namespace local
 #endif
     ops.flag_nullpath_ok = false;
 
-    ops.access      = mergerfs::access::access;
+    ops.access      = mergerfs::fuse::access;
     ops.bmap        = NULL;
-    ops.chmod       = mergerfs::chmod::chmod;
-    ops.chown       = mergerfs::chown::chown;
-    ops.create      = mergerfs::create::create;
-    ops.destroy     = mergerfs::destroy::destroy;
+    ops.chmod       = mergerfs::fuse::chmod;
+    ops.chown       = mergerfs::fuse::chown;
+    ops.create      = mergerfs::fuse::create;
+    ops.destroy     = mergerfs::fuse::destroy;
 #if FALLOCATE
-    ops.fallocate   = mergerfs::fallocate::fallocate;
+    ops.fallocate   = mergerfs::fuse::fallocate;
 #endif
-    ops.fgetattr    = mergerfs::fgetattr::fgetattr;
+    ops.fgetattr    = mergerfs::fuse::fgetattr;
 #if FLOCK
     ops.flock       = NULL;
 #endif
-    ops.flush       = mergerfs::flush::flush;
-    ops.fsync       = mergerfs::fsync::fsync;
+    ops.flush       = mergerfs::fuse::flush;
+    ops.fsync       = mergerfs::fuse::fsync;
     ops.fsyncdir    = NULL;
-    ops.ftruncate   = mergerfs::ftruncate::ftruncate;
-    ops.getattr     = mergerfs::getattr::getattr;
+    ops.ftruncate   = mergerfs::fuse::ftruncate;
+    ops.getattr     = mergerfs::fuse::getattr;
     ops.getdir      = NULL;       /* deprecated; use readdir */
-    ops.getxattr    = mergerfs::getxattr::getxattr;
-    ops.init        = mergerfs::init::init;
-    ops.ioctl       = mergerfs::ioctl::ioctl;
-    ops.link        = mergerfs::link::link;
-    ops.listxattr   = mergerfs::listxattr::listxattr;
+    ops.getxattr    = mergerfs::fuse::getxattr;
+    ops.init        = mergerfs::fuse::init;
+    ops.ioctl       = mergerfs::fuse::ioctl;
+    ops.link        = mergerfs::fuse::link;
+    ops.listxattr   = mergerfs::fuse::listxattr;
     ops.lock        = NULL;
-    ops.mkdir       = mergerfs::mkdir::mkdir;
-    ops.mknod       = mergerfs::mknod::mknod;
-    ops.open        = mergerfs::open::open;
-    ops.opendir     = mergerfs::opendir::opendir;
+    ops.mkdir       = mergerfs::fuse::mkdir;
+    ops.mknod       = mergerfs::fuse::mknod;
+    ops.open        = mergerfs::fuse::open;
+    ops.opendir     = mergerfs::fuse::opendir;
     ops.poll        = NULL;
-    ops.read        = mergerfs::read::read;
+    ops.read        = mergerfs::fuse::read;
 #if READ_BUF
-    ops.read_buf    = mergerfs::read_buf::read_buf;
+    ops.read_buf    = mergerfs::fuse::read_buf;
 #endif
-    ops.readdir     = mergerfs::readdir::readdir;
-    ops.readlink    = mergerfs::readlink::readlink;
-    ops.release     = mergerfs::release::release;
-    ops.releasedir  = mergerfs::releasedir::releasedir;
-    ops.removexattr = mergerfs::removexattr::removexattr;
-    ops.rename      = mergerfs::rename::rename;
-    ops.rmdir       = mergerfs::rmdir::rmdir;
-    ops.setxattr    = mergerfs::setxattr::setxattr;
-    ops.statfs      = mergerfs::statfs::statfs;
-    ops.symlink     = mergerfs::symlink::symlink;
-    ops.truncate    = mergerfs::truncate::truncate;
-    ops.unlink      = mergerfs::unlink::unlink;
+    ops.readdir     = mergerfs::fuse::readdir;
+    ops.readlink    = mergerfs::fuse::readlink;
+    ops.release     = mergerfs::fuse::release;
+    ops.releasedir  = mergerfs::fuse::releasedir;
+    ops.removexattr = mergerfs::fuse::removexattr;
+    ops.rename      = mergerfs::fuse::rename;
+    ops.rmdir       = mergerfs::fuse::rmdir;
+    ops.setxattr    = mergerfs::fuse::setxattr;
+    ops.statfs      = mergerfs::fuse::statfs;
+    ops.symlink     = mergerfs::fuse::symlink;
+    ops.truncate    = mergerfs::fuse::truncate;
+    ops.unlink      = mergerfs::fuse::unlink;
     ops.utime       = NULL;       /* deprecated; use utimens() */
-    ops.utimens     = mergerfs::utimens::utimens;
-    ops.write       = mergerfs::write::write;
+    ops.utimens     = mergerfs::fuse::utimens;
+    ops.write       = mergerfs::fuse::write;
 #if WRITE_BUF
-    ops.write_buf   = mergerfs::write_buf::write_buf;
+    ops.write_buf   = mergerfs::fuse::write_buf;
 #endif
 
     return;
@@ -168,9 +160,9 @@ namespace mergerfs
   main(const int   argc,
        char      **argv)
   {
-    struct fuse_args         args;
-    struct fuse_operations   ops = {0};
-    mergerfs::config::Config config;
+    fuse_args       args;
+    fuse_operations ops = {0};
+    Config          config;
 
     args.argc      = argc;
     args.argv      = argv;
@@ -195,8 +187,8 @@ main(int    argc,
   std::string appname;
 
   appname = local::getappname(argc,argv);
-  if(appname == "clonepath")
-    return clonepath::main(argc,argv);
+  if(appname == "clone")
+    return clonetool::main(argc,argv);
 
   return mergerfs::main(argc,argv);
 }

src/mergerfs.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #ifndef __MERGER_HPP__

src/mkdir.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -31,74 +23,111 @@
 #include <string>
 #include <vector>
 
-#include "ugid.hpp"
-#include "fs.hpp"
 #include "config.hpp"
+#include "fs_clonepath.hpp"
+#include "fs_path.hpp"
+#include "rv.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
+using mergerfs::Policy;
+using namespace mergerfs;
 
 static
 int
-_mkdir(const fs::find::Func  searchFunc,
-       const fs::find::Func  createFunc,
-       const vector<string> &srcmounts,
-       const string         &fusepath,
-       const mode_t          mode)
+_mkdir_loop_core(const string &existingpath,
+                 const string &createpath,
+                 const char   *fusepath,
+                 const char   *fusedirpath,
+                 const mode_t  mode,
+                 const int     error)
 {
   int rv;
-  int error;
-  string dirname;
   string fullpath;
-  fs::Paths createpaths;
-  fs::Paths existingpath;
 
-  dirname = fs::dirname(fusepath);
-  rv = searchFunc(srcmounts,dirname,existingpath,1);
-  if(rv == -1)
-    return -errno;
-
-  rv = createFunc(srcmounts,dirname,createpaths,-1);
-  if(rv == -1)
-    return -errno;
-
-  error = 0;
-  for(fs::Paths::const_iterator
-        i = createpaths.begin(), ei = createpaths.end(); i != ei; ++i)
+  if(createpath != existingpath)
     {
-      if(i->base != existingpath[0].base)
-        {
-          const mergerfs::ugid::SetResetGuard ugid(0,0);
-          fs::clonepath(existingpath[0].base,i->base,dirname);
-        }
+      const ugid::SetRootGuard ugidGuard;
+      fs::clonepath(existingpath,createpath,fusedirpath);
+    }
 
-      fullpath = fs::make_path(i->base,fusepath);
+  fs::path::make(&createpath,fusepath,fullpath);
 
-      rv = ::mkdir(fullpath.c_str(),mode);
-      if(rv == -1)
-        error = errno;
+  rv = ::mkdir(fullpath.c_str(),mode);
+
+  return calc_error(rv,error,errno);
+}
+
+static
+int
+_mkdir_loop(const string                &existingpath,
+            const vector<const string*> &createpaths,
+            const char                  *fusepath,
+            const char                  *fusedirpath,
+            const mode_t                 mode)
+{
+  int error;
+
+  error = -1;
+  for(size_t i = 0, ei = createpaths.size(); i != ei; i++)
+    {
+      error = _mkdir_loop_core(existingpath,*createpaths[i],
+                               fusepath,fusedirpath,mode,error);
     }
 
   return -error;
 }
 
+static
+int
+_mkdir(Policy::Func::Search  searchFunc,
+       Policy::Func::Create  createFunc,
+       const vector<string> &srcmounts,
+       const size_t          minfreespace,
+       const char           *fusepath,
+       const mode_t          mode)
+{
+  int rv;
+  string fusedirpath;
+  const char *fusedirpathcstr;
+  vector<const string*> createpaths;
+  vector<const string*> existingpaths;
+
+  fusedirpath = fusepath;
+  fs::path::dirname(fusedirpath);
+  fusedirpathcstr = fusedirpath.c_str();
+
+  rv = searchFunc(srcmounts,fusedirpathcstr,minfreespace,existingpaths);
+  if(rv == -1)
+    return -errno;
+
+  rv = createFunc(srcmounts,fusedirpathcstr,minfreespace,createpaths);
+  if(rv == -1)
+    return -errno;
+
+  return _mkdir_loop(*existingpaths[0],createpaths,
+                     fusepath,fusedirpathcstr,mode);
+}
+
 namespace mergerfs
 {
-  namespace mkdir
+  namespace fuse
   {
     int
     mkdir(const char *fusepath,
           mode_t      mode)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _mkdir(*config.getattr,
-                    *config.mkdir,
+      return _mkdir(config.getattr,
+                    config.mkdir,
                     config.srcmounts,
+                    config.minfreespace,
                     fusepath,
                     (mode & ~fc->umask));
     }

src/mkdir.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace mkdir
+  namespace fuse
   {
     int
     mkdir(const char *fusepath,

src/mknod.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -33,76 +25,116 @@
 #include <fcntl.h>
 #include <unistd.h>
 
-#include "ugid.hpp"
-#include "fs.hpp"
 #include "config.hpp"
+#include "fs_clonepath.hpp"
+#include "fs_path.hpp"
+#include "rv.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
+using namespace mergerfs;
 
 static
 int
-_mknod(const fs::find::Func  searchFunc,
-       const fs::find::Func  createFunc,
-       const vector<string> &srcmounts,
-       const string         &fusepath,
-       const mode_t          mode,
-       const dev_t           dev)
+_mknod_loop_core(const string &existingpath,
+                 const string &createpath,
+                 const char   *fusepath,
+                 const char   *fusedirpath,
+                 const mode_t  mode,
+                 const dev_t   dev,
+                 const int     error)
 {
   int rv;
-  int error;
-  string dirname;
   string fullpath;
-  fs::Paths createpaths;
-  fs::Paths existingpath;
 
-  dirname = fs::dirname(fusepath);
-  rv = searchFunc(srcmounts,dirname,existingpath,1);
-  if(rv == -1)
-    return -errno;
-
-  rv = createFunc(srcmounts,dirname,createpaths,-1);
-  if(rv == -1)
-    return -errno;
-
-  error = 0;
-  for(fs::Paths::const_iterator
-        i = createpaths.begin(), ei = createpaths.end(); i != ei; ++i)
+  if(createpath != existingpath)
     {
-      if(i->base != existingpath[0].base)
-        {
-          const mergerfs::ugid::SetResetGuard ugid(0,0);
-          fs::clonepath(existingpath[0].base,i->base,dirname);
-        }
+      const ugid::SetRootGuard ugidGuard;
+      fs::clonepath(existingpath,createpath,fusedirpath);
+    }
 
-      fullpath = fs::make_path(i->base,fusepath);
+  fs::path::make(&createpath,fusepath,fullpath);
 
-      rv = ::mknod(fullpath.c_str(),mode,dev);
-      if(rv == -1)
-        error = errno;
+  rv = ::mknod(fullpath.c_str(),mode,dev);
+
+  return calc_error(rv,error,errno);
+}
+
+static
+int
+_mknod_loop(const string                &existingpath,
+            const vector<const string*> &createpaths,
+            const char                  *fusepath,
+            const char                  *fusedirpath,
+            const mode_t                 mode,
+            const dev_t                  dev)
+{
+  int error;
+
+  error = -1;
+  for(size_t i = 0, ei = createpaths.size(); i != ei; i++)
+    {
+      error = _mknod_loop_core(existingpath,*createpaths[i],
+                               fusepath,fusedirpath,
+                               mode,dev,error);
     }
 
   return -error;
 }
 
+static
+int
+_mknod(Policy::Func::Search  searchFunc,
+       Policy::Func::Create  createFunc,
+       const vector<string> &srcmounts,
+       const size_t          minfreespace,
+       const char           *fusepath,
+       const mode_t          mode,
+       const dev_t           dev)
+{
+  int rv;
+  string fusedirpath;
+  const char *fusedirpathcstr;
+  vector<const string*> createpaths;
+  vector<const string*> existingpaths;
+
+  fusedirpath = fusepath;
+  fs::path::dirname(fusedirpath);
+  fusedirpathcstr = fusedirpath.c_str();
+
+  rv = searchFunc(srcmounts,fusedirpathcstr,minfreespace,existingpaths);
+  if(rv == -1)
+    return -errno;
+
+  rv = createFunc(srcmounts,fusedirpathcstr,minfreespace,createpaths);
+  if(rv == -1)
+    return -errno;
+
+  return _mknod_loop(*existingpaths[0],createpaths,
+                     fusepath,fusedirpathcstr,
+                     mode,dev);
+}
+
 namespace mergerfs
 {
-  namespace mknod
+  namespace fuse
   {
     int
     mknod(const char *fusepath,
           mode_t      mode,
           dev_t       rdev)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _mknod(*config.getattr,
-                    *config.mknod,
+      return _mknod(config.getattr,
+                    config.mknod,
                     config.srcmounts,
+                    config.minfreespace,
                     fusepath,
                     (mode & ~fc->umask),
                     rdev);

src/mknod.hpp

@@ -1,30 +1,22 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace mknod
+  namespace fuse
   {
     int
     mknod(const char *fusepath,

src/num.cpp

@@ -0,0 +1,59 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <stdlib.h>
+
+#include <string>
+
+namespace num
+{
+  int
+  to_size_t(const std::string &str,
+            size_t            &value)
+  {
+    size_t  tmp;
+    char   *endptr;
+
+    tmp = strtoll(str.c_str(),&endptr,10);
+    switch(*endptr)
+      {
+      case 'k':
+      case 'K':
+        tmp *= 1024;
+        break;
+
+      case 'm':
+      case 'M':
+        tmp *= (1024 * 1024);
+        break;
+
+      case 'g':
+      case 'G':
+        tmp *= (1024 * 1024 * 1024);
+        break;
+
+      case '\0':
+        break;
+
+      default:
+        return -1;
+      }
+
+    value = tmp;
+
+    return 0;
+  }
+}

src/num.hpp

@@ -0,0 +1,22 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <string>
+
+namespace num
+{
+  int to_size_t(const std::string &str, size_t &value);
+}

src/open.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -31,57 +23,75 @@
 #include <string>
 #include <vector>
 
-#include "ugid.hpp"
-#include "fs.hpp"
 #include "config.hpp"
+#include "fileinfo.hpp"
+#include "fs_path.hpp"
 #include "rwlock.hpp"
+#include "ugid.hpp"
 
 using std::string;
 using std::vector;
+using mergerfs::Policy;
 
 static
 int
-_open(const fs::find::Func  searchFunc,
-      const vector<string> &srcmounts,
-      const string         &fusepath,
-      const int             flags,
-      uint64_t             &fh)
+_open_core(const string *basepath,
+           const char   *fusepath,
+           const int     flags,
+           uint64_t     &fh)
 {
   int fd;
-  int rv;
-  fs::Paths path;
+  string fullpath;
 
-  rv = searchFunc(srcmounts,fusepath,path,1);
-  if(rv == -1)
-    return -errno;
+  fs::path::make(basepath,fusepath,fullpath);
 
-  fd = ::open(path[0].full.c_str(),flags);
+  fd = ::open(fullpath.c_str(),flags);
   if(fd == -1)
     return -errno;
 
-  fh = fd;
+  fh = reinterpret_cast<uint64_t>(new FileInfo(fd));
 
   return 0;
 }
 
+static
+int
+_open(Policy::Func::Search  searchFunc,
+      const vector<string> &srcmounts,
+      const size_t          minfreespace,
+      const char           *fusepath,
+      const int             flags,
+      uint64_t             &fh)
+{
+  int rv;
+  vector<const string*> basepaths;
+
+  rv = searchFunc(srcmounts,fusepath,minfreespace,basepaths);
+  if(rv == -1)
+    return -errno;
+
+  return _open_core(basepaths[0],fusepath,flags,fh);
+}
+
 namespace mergerfs
 {
-  namespace open
+  namespace fuse
   {
     int
-    open(const char            *fusepath,
-         struct fuse_file_info *fileinfo)
+    open(const char     *fusepath,
+         fuse_file_info *ffi)
     {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
+      const fuse_context      *fc     = fuse_get_context();
+      const Config            &config = Config::get(fc);
+      const ugid::Set          ugid(fc->uid,fc->gid);
+      const rwlock::ReadGuard  readlock(&config.srcmountslock);
 
-      return _open(*config.open,
+      return _open(config.open,
                    config.srcmounts,
+                   config.minfreespace,
                    fusepath,
-                   fileinfo->flags,
-                   fileinfo->fh);
+                   ffi->flags,
+                   ffi->fh);
     }
   }
 }

src/open.hpp

@@ -1,35 +1,27 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
 
 namespace mergerfs
 {
-  namespace open
+  namespace fuse
   {
     int
-    open(const char            *fusepath,
-         struct fuse_file_info *fileinfo);
+    open(const char     *fusepath,
+         fuse_file_info *ffi);
   }
 }

src/opendir.cpp

@@ -1,36 +1,28 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
 
 namespace mergerfs
 {
-  namespace opendir
+  namespace fuse
   {
     int
-    opendir(const char            *fusepath,
-            struct fuse_file_info *ffi)
+    opendir(const char     *fusepath,
+            fuse_file_info *ffi)
     {
       ffi->fh = 0;
 

src/opendir.hpp

@@ -1,35 +1,27 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <vector>
 
 namespace mergerfs
 {
-  namespace opendir
+  namespace fuse
   {
     int
-    opendir(const char            *fusepath,
-            struct fuse_file_info *ffi);
+    opendir(const char     *fusepath,
+            fuse_file_info *ffi);
   }
 }

src/option_parser.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -27,23 +19,34 @@
 #include <stddef.h>
 #include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
 
 #include <string>
 #include <vector>
 #include <sstream>
 #include <iostream>
+#include <iomanip>
 
-#include "str.hpp"
 #include "config.hpp"
+#include "num.hpp"
 #include "policy.hpp"
+#include "str.hpp"
+#include "version.hpp"
 
 using std::string;
 using std::vector;
 using namespace mergerfs;
 
+enum
+  {
+    MERGERFS_OPT_HELP,
+    MERGERFS_OPT_VERSION
+  };
+
 static
 void
-set_option(struct fuse_args  &args,
+set_option(fuse_args         &args,
            const std::string &option_)
 {
   string option;
@@ -55,7 +58,7 @@ set_option(struct fuse_args  &args,
 
 static
 void
-set_kv_option(struct fuse_args  &args,
+set_kv_option(fuse_args         &args,
               const std::string &key,
               const std::string &value)
 {
@@ -68,7 +71,7 @@ set_kv_option(struct fuse_args  &args,
 
 static
 void
-set_fsname(struct fuse_args     &args,
+set_fsname(fuse_args            &args,
            const vector<string> &srcmounts)
 {
   if(srcmounts.size() > 0)
@@ -83,28 +86,58 @@ set_fsname(struct fuse_args     &args,
 
 static
 void
-set_subtype(struct fuse_args &args)
+set_subtype(fuse_args &args)
 {
   set_kv_option(args,"subtype","mergerfs");
 }
 
 static
 void
-set_default_options(struct fuse_args &args)
+set_default_options(fuse_args &args)
 {
+  set_option(args,"atomic_o_trunc");
+  set_option(args,"auto_cache");
   set_option(args,"big_writes");
+  set_option(args,"default_permissions");
+  set_option(args,"splice_move");
   set_option(args,"splice_read");
   set_option(args,"splice_write");
-  set_option(args,"splice_move");
-  set_option(args,"auto_cache");
-  set_option(args,"atomic_o_trunc");
 }
 
 static
 int
-parse_and_process_arg(config::Config    &config,
+parse_and_process_minfreespace(const std::string &value,
+                               size_t            &minfreespace)
+{
+  int rv;
+
+  rv = num::to_size_t(value,minfreespace);
+  if(rv == -1)
+    return 1;
+
+  return 0;
+}
+
+static
+int
+parse_and_process_moveonenospc(const std::string &value,
+                               bool              &moveonenospc)
+{
+  if(value == "false")
+    moveonenospc = false;
+  else if(value == "true")
+    moveonenospc = true;
+  else
+    return 1;
+
+  return 0;
+}
+
+static
+int
+parse_and_process_arg(Config            &config,
                       const std::string &arg,
-                      struct fuse_args  *outargs)
+                      fuse_args         *outargs)
 {
   if(arg == "defaults")
     {
@@ -117,23 +150,28 @@ parse_and_process_arg(config::Config    &config,
 
 static
 int
-parse_and_process_kv_arg(config::Config    &config,
+parse_and_process_kv_arg(Config            &config,
                          const std::string &key,
                          const std::string &value)
 {
-  int rv;
+  int rv = -1;
   std::vector<std::string> keypart;
 
   str::split(keypart,key,'.');
-  if(keypart.size() != 2)
-    return 1;
-
-  if(keypart[0] == "func")
-    rv = config.set_func_policy(keypart[1],value);
-  else if(keypart[0] == "category")
-    rv = config.set_category_policy(keypart[1],value);
+  if(keypart.size() == 2)
+    {
+      if(keypart[0] == "func")
+        rv = config.set_func_policy(keypart[1],value);
+      else if(keypart[0] == "category")
+        rv = config.set_category_policy(keypart[1],value);
+    }
   else
-    rv = -1;
+    {
+      if(key == "minfreespace")
+        rv = parse_and_process_minfreespace(value,config.minfreespace);
+      else if(key == "moveonenospc")
+        rv = parse_and_process_moveonenospc(value,config.moveonenospc);
+    }
 
   if(rv == -1)
     rv = 1;
@@ -143,14 +181,13 @@ parse_and_process_kv_arg(config::Config    &config,
 
 static
 int
-process_opt(config::Config    &config,
+process_opt(Config            &config,
             const std::string &arg,
-            struct fuse_args  *outargs)
+            fuse_args         *outargs)
 {
   int rv;
   std::vector<std::string> argvalue;
 
-  rv = 1;
   str::split(argvalue,arg,'=');
   switch(argvalue.size())
     {
@@ -172,8 +209,8 @@ process_opt(config::Config    &config,
 
 static
 int
-process_srcmounts(const char     *arg,
-                  config::Config &config)
+process_srcmounts(const char *arg,
+                  Config     &config)
 {
   vector<string> paths;
 
@@ -181,13 +218,15 @@ process_srcmounts(const char     *arg,
 
   fs::glob(paths,config.srcmounts);
 
+  fs::realpathize(config.srcmounts);
+
   return 0;
 }
 
 static
 int
-process_destmounts(const char     *arg,
-                   config::Config &config)
+process_destmounts(const char *arg,
+                   Config     &config)
 {
   config.destmount = arg;
 
@@ -195,14 +234,51 @@ process_destmounts(const char     *arg,
 }
 
 static
-int
-option_processor(void             *data,
-                 const char       *arg,
-                 int               key,
-                 struct fuse_args *outargs)
+void
+usage(void)
 {
-  int rv = 0;
-  config::Config &config = *(config::Config*)data;
+  std::cout <<
+    "Usage: mergerfs [options] <srcpaths> <destpath>\n"
+    "\n"
+    "    -o [opt,...]           mount options\n"
+    "    -h --help              print help\n"
+    "    -v --version           print version\n"
+    "\n"
+    "mergerfs options:\n"
+    "    <srcpaths>             ':' delimited list of directories. Supports\n"
+    "                           shell globbing (must be escaped in shell)\n"
+    "    -o defaults            default FUSE options which seem to provide the\n"
+    "                           best performance: atomic_o_trunc, auto_cache,\n"
+    "                           big_writes, default_permissions, splice_read,\n"
+    "                           splice_write, splice_move\n"
+    "    -o direct_io           bypass additional caching, increases write\n"
+    "                           speeds at the cost of reads\n"
+    "    -o minfreespace=<int>  minimum free space needed for certain policies:\n"
+    "                           default 4G\n"
+    "    -o moveonenospc=<bool> try to move file to another drive when ENOSPC\n"
+    "                           on write: default false\n"
+    "    -o func.<f>=<p>        set function <f> to policy <p>\n"
+    "    -o category.<c>=<p>    set functions in category <c> to <p>\n"
+            << std::endl;
+}
+
+static
+void
+version(void)
+{
+  std::cout << "mergerfs version: " << MERGERFS_VERSION
+            << std::endl;
+}
+
+static
+int
+option_processor(void       *data,
+                 const char *arg,
+                 int         key,
+                 fuse_args  *outargs)
+{
+  int     rv     = 0;
+  Config &config = *(Config*)data;
 
   switch(key)
     {
@@ -216,6 +292,18 @@ option_processor(void             *data,
         process_destmounts(arg,config);
       break;
 
+    case MERGERFS_OPT_HELP:
+      usage();
+      close(2);
+      dup(1);
+      fuse_opt_add_arg(outargs,"-ho");
+      break;
+
+    case MERGERFS_OPT_VERSION:
+      version();
+      fuse_opt_add_arg(outargs,"--version");
+      break;
+
     default:
       break;
     }
@@ -228,13 +316,23 @@ namespace mergerfs
   namespace options
   {
     void
-    parse(struct fuse_args &args,
-          config::Config   &config)
+    parse(fuse_args &args,
+          Config    &config)
     {
+      const struct fuse_opt opts[] =
+        {
+          FUSE_OPT_KEY("-h",MERGERFS_OPT_HELP),
+          FUSE_OPT_KEY("--help",MERGERFS_OPT_HELP),
+          FUSE_OPT_KEY("-v",MERGERFS_OPT_VERSION),
+          FUSE_OPT_KEY("-V",MERGERFS_OPT_VERSION),
+          FUSE_OPT_KEY("--version",MERGERFS_OPT_VERSION),
+          {NULL,-1U,0}
+        };
+
 
       fuse_opt_parse(&args,
                      &config,
-                     NULL,
+                     opts,
                      ::option_processor);
 
       set_fsname(args,config.srcmounts);

src/option_parser.hpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -31,7 +23,7 @@ namespace mergerfs
   namespace options
   {
     void
-    parse(struct fuse_args         &args,
-          mergerfs::config::Config &config);
+    parse(fuse_args &args,
+          Config    &config);
   }
 }

src/policy.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <vector>
@@ -28,31 +20,39 @@
 #include "fs.hpp"
 #include "buildvector.hpp"
 
-#define POLICY(X) (Policy(Policy::Enum::X,#X,fs::find::X))
+#define POLICY(X,PP) (Policy(Policy::Enum::X,#X,Policy::Func::X,PP))
+#define PRESERVES_PATH true
+#define DOESNT_PRESERVE_PATH false
 
 namespace mergerfs
 {
   const std::vector<Policy> Policy::_policies_ =
     buildvector<Policy,true>
-    (POLICY(invalid))
-    (POLICY(all))
-    (POLICY(epmfs))
-    (POLICY(ff))
-    (POLICY(ffwp))
-    (POLICY(mfs))
-    (POLICY(newest))
-    (POLICY(rand));
+    (POLICY(invalid,DOESNT_PRESERVE_PATH))
+    (POLICY(all,DOESNT_PRESERVE_PATH))
+    (POLICY(eplfs,PRESERVES_PATH))
+    (POLICY(epmfs,PRESERVES_PATH))
+    (POLICY(erofs,DOESNT_PRESERVE_PATH))
+    (POLICY(ff,DOESNT_PRESERVE_PATH))
+    (POLICY(lfs,DOESNT_PRESERVE_PATH))
+    (POLICY(mfs,DOESNT_PRESERVE_PATH))
+    (POLICY(newest,DOESNT_PRESERVE_PATH))
+    (POLICY(rand,DOESNT_PRESERVE_PATH));
 
   const Policy * const Policy::policies = &_policies_[1];
 
-  const Policy &Policy::invalid = Policy::policies[Policy::Enum::invalid];
-  const Policy &Policy::all     = Policy::policies[Policy::Enum::all];
-  const Policy &Policy::epmfs   = Policy::policies[Policy::Enum::epmfs];
-  const Policy &Policy::ff      = Policy::policies[Policy::Enum::ff];
-  const Policy &Policy::ffwp    = Policy::policies[Policy::Enum::ffwp];
-  const Policy &Policy::mfs     = Policy::policies[Policy::Enum::mfs];
-  const Policy &Policy::newest  = Policy::policies[Policy::Enum::newest];
-  const Policy &Policy::rand    = Policy::policies[Policy::Enum::rand];
+#define CONST_POLICY(X) const Policy &Policy::X = Policy::policies[Policy::Enum::X]
+
+  CONST_POLICY(invalid);
+  CONST_POLICY(all);
+  CONST_POLICY(eplfs);
+  CONST_POLICY(epmfs);
+  CONST_POLICY(erofs);
+  CONST_POLICY(ff);
+  CONST_POLICY(lfs);
+  CONST_POLICY(mfs);
+  CONST_POLICY(newest);
+  CONST_POLICY(rand);
 
   const Policy&
   Policy::find(const std::string &str)

src/policy.hpp

@@ -1,34 +1,35 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #ifndef __POLICY_HPP__
 #define __POLICY_HPP__
 
 #include <string>
+#include <vector>
 #include <map>
 
 #include "fs.hpp"
+#include "category.hpp"
+
+#define POLICY_SUCCESS 0
+#define POLICY_FAIL -1
+#define POLICY_SUCCEEDED(RV) ((RV) == POLICY_SUCCESS)
+#define POLICY_FAILED(RV) ((RV) == POLICY_FAIL)
+#define POLICY_FAIL_ERRNO(ERRNO) (errno=ERRNO,POLICY_FAIL)
+#define POLICY_FAIL_ENOENT POLICY_FAIL_ERRNO(ENOENT)
 
 namespace mergerfs
 {
@@ -42,49 +43,111 @@ namespace mergerfs
           invalid = -1,
           BEGIN   = 0,
           all     = BEGIN,
+          eplfs,
           epmfs,
+          erofs,
           ff,
-          ffwp,
+          lfs,
           mfs,
           newest,
           rand,
           END
         };
+
+      static size_t begin() { return BEGIN; }
+      static size_t end()   { return END; }
+    };
+
+    struct Func
+    {
+      typedef std::string string;
+      typedef std::size_t size_t;
+      typedef std::vector<string> strvec;
+      typedef std::vector<const string*> cstrptrvec;
+      typedef const string cstring;
+      typedef const size_t csize_t;
+      typedef const strvec cstrvec;
+      typedef const Category::Enum::Type CType;
+
+      typedef int (*Ptr)(CType,cstrvec &,const char *,csize_t,cstrptrvec &);
+
+      template <CType T>
+      class Base
+      {
+      public:
+        Base(const Policy *p)
+          : func(p->_func)
+        {}
+
+        int
+        operator()(cstrvec &b,const char *c,csize_t d,cstrptrvec &e)
+        {
+          return func(T,b,c,d,e);
+        }
+
+      private:
+        const Ptr func;
+      };
+
+      typedef Base<Category::Enum::action> Action;
+      typedef Base<Category::Enum::create> Create;
+      typedef Base<Category::Enum::search> Search;
+
+      static int invalid(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int all(CType,cstrvec&,const char*,csize_t,cstrptrvec&);
+      static int eplfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int epmfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int erofs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int ff(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int lfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int mfs(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int newest(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
+      static int rand(CType,cstrvec&,const char *,csize_t,cstrptrvec&);
     };
 
   private:
-    Enum::Type     _enum;
-    std::string    _str;
-    fs::find::Func _func;
+    Enum::Type  _enum;
+    std::string _str;
+    Func::Ptr   _func;
+    bool        _path_preserving;
 
   public:
     Policy()
       : _enum(invalid),
         _str(invalid),
-        _func(invalid)
+        _func(invalid),
+        _path_preserving(false)
     {
     }
 
-    Policy(const Enum::Type      enum_,
-           const std::string    &str_,
-           const fs::find::Func  func_)
+    Policy(const Enum::Type   enum_,
+           const std::string &str_,
+           const Func::Ptr    func_,
+           const bool         path_preserving_)
       : _enum(enum_),
         _str(str_),
-        _func(func_)
+        _func(func_),
+        _path_preserving(path_preserving_)
     {
     }
 
+    bool
+    path_preserving() const
+    {
+      return _path_preserving;
+    }
+
   public:
     operator const Enum::Type() const { return _enum; }
     operator const std::string&() const { return _str; }
-    operator const fs::find::Func() const { return _func; }
+    operator const Func::Ptr() const { return _func; }
     operator const Policy*() const { return this; }
 
     bool operator==(const Enum::Type enum_) const
     { return _enum == enum_; }
     bool operator==(const std::string &str_) const
     { return _str == str_; }
-    bool operator==(const fs::find::Func func_) const
+    bool operator==(const Func::Ptr func_) const
     { return _func == func_; }
 
     bool operator!=(const Policy &r) const
@@ -100,14 +163,17 @@ namespace mergerfs
   public:
     static const std::vector<Policy>  _policies_;
     static const Policy * const       policies;
-    static const Policy              &invalid;
-    static const Policy              &all;
-    static const Policy              &epmfs;
-    static const Policy              &ff;
-    static const Policy              &ffwp;
-    static const Policy              &mfs;
-    static const Policy              &newest;
-    static const Policy              &rand;
+
+    static const Policy &invalid;
+    static const Policy &all;
+    static const Policy &eplfs;
+    static const Policy &epmfs;
+    static const Policy &erofs;
+    static const Policy &ff;
+    static const Policy &lfs;
+    static const Policy &mfs;
+    static const Policy &newest;
+    static const Policy &rand;
   };
 }
 

src/policy_all.cpp

@@ -0,0 +1,98 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+
+static
+int
+_all_create(const vector<string>  &basepaths,
+            const size_t           minfreespace,
+            vector<const string*> &paths)
+{
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      if(!fs::info(*basepath,readonly,spaceavail))
+        continue;
+      if(readonly)
+        continue;
+      if(spaceavail < minfreespace)
+        continue;
+
+      paths.push_back(basepath);
+    }
+
+  if(paths.empty())
+    return POLICY_FAIL_ENOENT;
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_all_other(const vector<string>  &basepaths,
+           const char            *fusepath,
+           vector<const string*> &paths)
+{
+  string fullpath;
+
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+
+      paths.push_back(basepath);
+    }
+
+  if(paths.empty())
+    return POLICY_FAIL_ENOENT;
+
+  return POLICY_SUCCESS;
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::all(const Category::Enum::Type  type,
+                    const vector<string>       &basepaths,
+                    const char                 *fusepath,
+                    const size_t                minfreespace,
+                    vector<const string*>      &paths)
+  {
+    if(type == Category::Enum::create)
+      return _all_create(basepaths,minfreespace,paths);
+
+    return _all_other(basepaths,fusepath,paths);
+  }
+}

src/policy_eplfs.cpp

@@ -0,0 +1,145 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+using mergerfs::Category;
+
+static
+int
+_eplfs_create(const vector<string>  &basepaths,
+              const char            *fusepath,
+              const size_t           minfreespace,
+              vector<const string*> &paths)
+{
+  string fullpath;
+  size_t eplfs;
+  const string *eplfsbasepath;
+
+  eplfs = std::numeric_limits<size_t>::max();
+  eplfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::info(*basepath,readonly,spaceavail))
+        continue;
+      if(readonly)
+        continue;
+      if(spaceavail < minfreespace)
+        continue;
+      if(spaceavail > eplfs)
+        continue;
+
+      eplfs = spaceavail;
+      eplfsbasepath = basepath;
+    }
+
+  if(eplfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(eplfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_eplfs_other(const vector<string>  &basepaths,
+             const char            *fusepath,
+             vector<const string*> &paths)
+{
+  string fullpath;
+  size_t eplfs;
+  const string *eplfsbasepath;
+
+  eplfs = std::numeric_limits<size_t>::max();
+  eplfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::spaceavail(*basepath,spaceavail))
+        continue;
+      if(spaceavail > eplfs)
+        continue;
+
+      eplfs = spaceavail;
+      eplfsbasepath = basepath;
+    }
+
+  if(eplfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(eplfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_eplfs(const Category::Enum::Type type,
+       const vector<string>       &basepaths,
+       const char                 *fusepath,
+       const size_t                minfreespace,
+       vector<const string*>      &paths)
+{
+  if(type == Category::Enum::create)
+    return _eplfs_create(basepaths,fusepath,minfreespace,paths);
+
+  return _eplfs_other(basepaths,fusepath,paths);
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::eplfs(const Category::Enum::Type  type,
+                      const vector<string>       &basepaths,
+                      const char                 *fusepath,
+                      const size_t                minfreespace,
+                      vector<const string*>      &paths)
+  {
+    int rv;
+
+    rv = _eplfs(type,basepaths,fusepath,minfreespace,paths);
+    if(POLICY_FAILED(rv))
+      rv = Policy::Func::lfs(type,basepaths,fusepath,minfreespace,paths);
+
+    return rv;
+  }
+}

src/policy_epmfs.cpp

@@ -0,0 +1,145 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+using mergerfs::Category;
+
+static
+int
+_epmfs_create(const vector<string>  &basepaths,
+              const char            *fusepath,
+              const size_t           minfreespace,
+              vector<const string*> &paths)
+{
+  string fullpath;
+  size_t epmfs;
+  const string *epmfsbasepath;
+
+  epmfs = std::numeric_limits<size_t>::min();
+  epmfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::info(*basepath,readonly,spaceavail))
+        continue;
+      if(readonly)
+        continue;
+      if(spaceavail < minfreespace)
+        continue;
+      if(spaceavail < epmfs)
+        continue;
+
+      epmfs = spaceavail;
+      epmfsbasepath = basepath;
+    }
+
+  if(epmfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(epmfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_epmfs_other(const vector<string>  &basepaths,
+             const char            *fusepath,
+             vector<const string*> &paths)
+{
+  string fullpath;
+  size_t epmfs;
+  const string *epmfsbasepath;
+
+  epmfs = 0;
+  epmfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::spaceavail(*basepath,spaceavail))
+        continue;
+      if(spaceavail < epmfs)
+        continue;
+
+      epmfs = spaceavail;
+      epmfsbasepath = basepath;
+    }
+
+  if(epmfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(epmfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_epmfs(const Category::Enum::Type  type,
+       const vector<string>       &basepaths,
+       const char                 *fusepath,
+       const size_t                minfreespace,
+       vector<const string*>      &paths)
+{
+  if(type == Category::Enum::create)
+    return _epmfs_create(basepaths,fusepath,minfreespace,paths);
+
+  return _epmfs_other(basepaths,fusepath,paths);
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::epmfs(const Category::Enum::Type  type,
+                      const vector<string>       &basepaths,
+                      const char                 *fusepath,
+                      const size_t                minfreespace,
+                      vector<const string*>     &paths)
+  {
+    int rv;
+
+    rv = _epmfs(type,basepaths,fusepath,minfreespace,paths);
+    if(POLICY_FAILED(rv))
+      rv = Policy::Func::mfs(type,basepaths,fusepath,minfreespace,paths);
+
+    return rv;
+  }
+}

src/policy_erofs.cpp

@@ -0,0 +1,38 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <string>
+#include <vector>
+
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+
+namespace mergerfs
+{
+  int
+  Policy::Func::erofs(const Category::Enum::Type  type,
+                      const vector<string>       &basepaths,
+                      const char                 *fusepath,
+                      const size_t                minfreespace,
+                      vector<const string*>      &paths)
+  {
+    return POLICY_FAIL_ERRNO(EROFS);
+  }
+}

src/policy_ff.cpp

@@ -0,0 +1,106 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+
+static
+int
+_ff_create(const vector<string>  &basepaths,
+           const size_t           minfreespace,
+           vector<const string*> &paths)
+{
+  const string *fallback;
+
+  fallback = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      if(!fs::info(*basepath,readonly,spaceavail))
+        continue;
+      if(readonly)
+        continue;
+      if(fallback == NULL)
+        fallback = basepath;
+      if(spaceavail < minfreespace)
+        continue;
+
+      paths.push_back(basepath);
+
+      return POLICY_SUCCESS;
+    }
+
+  if(fallback == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(fallback);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_ff_other(const vector<string>  &basepaths,
+          const char            *fusepath,
+          vector<const string*> &paths)
+{
+  string fullpath;
+
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+
+      paths.push_back(basepath);
+
+      return POLICY_SUCCESS;
+    }
+
+  return POLICY_FAIL_ENOENT;
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::ff(const Category::Enum::Type  type,
+                   const vector<string>       &basepaths,
+                   const char                 *fusepath,
+                   const size_t                minfreespace,
+                   vector<const string*>      &paths)
+  {
+    if(type == Category::Enum::create)
+      return _ff_create(basepaths,minfreespace,paths);
+
+    return _ff_other(basepaths,fusepath,paths);
+  }
+}

src/policy_invalid.cpp

@@ -0,0 +1,39 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <string>
+#include <vector>
+
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+
+namespace mergerfs
+{
+  int
+  Policy::Func::invalid(const Category::Enum::Type  type,
+                        const vector<string>       &basepaths,
+                        const char                 *fusepath,
+                        const size_t                minfreespace,
+                        vector<const string*>      &paths)
+  {
+    return POLICY_FAIL_ERRNO(EINVAL);
+  }
+}

src/policy_lfs.cpp

@@ -0,0 +1,141 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <limits>
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+using mergerfs::Category;
+
+static
+int
+_lfs_create(const vector<string>  &basepaths,
+            const size_t           minfreespace,
+            vector<const string*> &paths)
+{
+  string fullpath;
+  size_t lfs;
+  const string *lfsbasepath;
+
+  lfs = std::numeric_limits<size_t>::max();
+  lfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      if(!fs::info(*basepath,readonly,spaceavail))
+        continue;
+      if(readonly)
+        continue;
+      if(spaceavail < minfreespace)
+        continue;
+      if(spaceavail > lfs)
+        continue;
+
+      lfs = spaceavail;
+      lfsbasepath = basepath;
+    }
+
+  if(lfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(lfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_lfs_other(const vector<string>  &basepaths,
+           const char            *fusepath,
+           vector<const string*> &paths)
+{
+  string fullpath;
+  size_t lfs;
+  const string *lfsbasepath;
+
+  lfs = std::numeric_limits<size_t>::max();
+  lfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::spaceavail(*basepath,spaceavail))
+        continue;
+      if(spaceavail > lfs)
+        continue;
+
+      lfs = spaceavail;
+      lfsbasepath = basepath;
+    }
+
+  if(lfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(lfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_lfs(const Category::Enum::Type  type,
+     const vector<string>       &basepaths,
+     const char                 *fusepath,
+     const size_t                minfreespace,
+     vector<const string*>      &paths)
+{
+  if(type == Category::Enum::create)
+    return _lfs_create(basepaths,minfreespace,paths);
+
+  return _lfs_other(basepaths,fusepath,paths);
+}
+
+
+namespace mergerfs
+{
+  int
+  Policy::Func::lfs(const Category::Enum::Type  type,
+                    const vector<string>       &basepaths,
+                    const char                 *fusepath,
+                    const size_t                minfreespace,
+                    vector<const string*>      &paths)
+  {
+    int rv;
+
+    rv = _lfs(type,basepaths,fusepath,minfreespace,paths);
+    if(POLICY_FAILED(rv))
+      rv = Policy::Func::mfs(type,basepaths,fusepath,minfreespace,paths);
+
+    return rv;
+  }
+}

src/policy_mfs.cpp

@@ -0,0 +1,135 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <string>
+#include <vector>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+using mergerfs::Category;
+
+static
+int
+_mfs_create(const vector<string>  &basepaths,
+            vector<const string*> &paths)
+{
+  string fullpath;
+  size_t mfs;
+  const string *mfsbasepath;
+
+  mfs = 0;
+  mfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      bool readonly;
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      if(!fs::info(*basepath,readonly,spaceavail))
+        continue;
+      if(readonly)
+        continue;
+      if(spaceavail < mfs)
+        continue;
+
+      mfs = spaceavail;
+      mfsbasepath = basepath;
+    }
+
+  if(mfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(mfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_mfs_other(const vector<string>  &basepaths,
+           const char            *fusepath,
+           vector<const string*> &paths)
+{
+  string fullpath;
+  size_t mfs;
+  const string *mfsbasepath;
+
+  mfs = 0;
+  mfsbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      size_t spaceavail;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath))
+        continue;
+      if(!fs::spaceavail(*basepath,spaceavail))
+        continue;
+      if(spaceavail < mfs)
+        continue;
+
+      mfs = spaceavail;
+      mfsbasepath = basepath;
+    }
+
+  if(mfsbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(mfsbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_mfs(const Category::Enum::Type  type,
+     const vector<string>       &basepaths,
+     const char                 *fusepath,
+     vector<const string*>      &paths)
+{
+  if(type == Category::Enum::create)
+    return _mfs_create(basepaths,paths);
+
+  return _mfs_other(basepaths,fusepath,paths);
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::mfs(const Category::Enum::Type  type,
+                    const vector<string>       &basepaths,
+                    const char                 *fusepath,
+                    const size_t                minfreespace,
+                    vector<const string*>      &paths)
+  {
+    int rv;
+
+    rv = _mfs(type,basepaths,fusepath,paths);
+    if(POLICY_FAILED(rv))
+      rv = Policy::Func::ff(type,basepaths,fusepath,minfreespace,paths);
+
+    return rv;
+  }
+}

src/policy_newest.cpp

@@ -0,0 +1,122 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+#include <sys/stat.h>
+
+#include <string>
+#include <vector>
+#include <limits>
+
+#include "fs.hpp"
+#include "fs_path.hpp"
+#include "policy.hpp"
+#include "success_fail.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+
+static
+int
+_newest_create(const vector<string>  &basepaths,
+               const char            *fusepath,
+               vector<const string*> &paths)
+{
+  time_t newest;
+  string fullpath;
+  const string *newestbasepath;
+
+  newest = std::numeric_limits<time_t>::min();
+  newestbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+
+      struct stat st;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath,st))
+        continue;
+      if(st.st_mtime < newest)
+        continue;
+      if(fs::readonly(*basepath))
+        continue;
+
+      newest = st.st_mtime;
+      newestbasepath = basepath;
+    }
+
+  if(newestbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(newestbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+static
+int
+_newest_other(const vector<string>  &basepaths,
+              const char            *fusepath,
+              vector<const string*> &paths)
+{
+  time_t newest;
+  string fullpath;
+  const string *newestbasepath;
+
+  newest = std::numeric_limits<time_t>::min();
+  newestbasepath = NULL;
+  for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
+    {
+      struct stat st;
+      const string *basepath = &basepaths[i];
+
+      fs::path::make(basepath,fusepath,fullpath);
+
+      if(!fs::exists(fullpath,st))
+        continue;
+      if(st.st_mtime < newest)
+        continue;
+
+      newest = st.st_mtime;
+      newestbasepath = basepath;
+    }
+
+  if(newestbasepath == NULL)
+    return POLICY_FAIL_ENOENT;
+
+  paths.push_back(newestbasepath);
+
+  return POLICY_SUCCESS;
+}
+
+namespace mergerfs
+{
+  int
+  Policy::Func::newest(const Category::Enum::Type  type,
+                       const vector<string>       &basepaths,
+                       const char                 *fusepath,
+                       const size_t                minfreespace,
+                       vector<const string*>      &paths)
+  {
+    if(type == Category::Enum::create)
+      return _newest_create(basepaths,fusepath,paths);
+
+    return _newest_other(basepaths,fusepath,paths);
+  }
+}

src/policy_rand.cpp

@@ -0,0 +1,47 @@
+/*
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <errno.h>
+
+#include <string>
+#include <vector>
+#include <algorithm>
+
+#include "policy.hpp"
+#include "success_fail.hpp"
+
+using std::string;
+using std::vector;
+using std::size_t;
+
+namespace mergerfs
+{
+  int
+  Policy::Func::rand(const Category::Enum::Type  type,
+                     const vector<string>       &basepaths,
+                     const char                 *fusepath,
+                     const size_t                minfreespace,
+                     vector<const string*>      &paths)
+  {
+    int rv;
+
+    rv = Policy::Func::all(type,basepaths,fusepath,minfreespace,paths);
+    if(POLICY_SUCCEEDED(rv))
+      std::random_shuffle(paths.begin(),paths.end());
+
+    return rv;
+  }
+}

src/read.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #include <fuse.h>
@@ -30,6 +22,8 @@
 
 #include <string>
 
+#include "fileinfo.hpp"
+
 static
 int
 _read(const int     fd,
@@ -46,16 +40,18 @@ _read(const int     fd,
 
 namespace mergerfs
 {
-  namespace read
+  namespace fuse
   {
     int
-    read(const char            *fusepath,
-         char                  *buf,
-         size_t                 count,
-         off_t                  offset,
-         struct fuse_file_info *ffi)
+    read(const char     *fusepath,
+         char           *buf,
+         size_t          count,
+         off_t           offset,
+         fuse_file_info *ffi)
     {
-      return _read(ffi->fh,
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
+
+      return _read(fi->fd,
                    buf,
                    count,
                    offset);

src/read.hpp

@@ -1,36 +1,28 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 namespace mergerfs
 {
-  namespace read
+  namespace fuse
   {
     int
-    read(const char            *fusepath,
-         char                  *buf,
-         size_t                 count,
-         off_t                  offset,
-         struct fuse_file_info *fi);
+    read(const char     *fusepath,
+         char           *buf,
+         size_t          count,
+         off_t           offset,
+         fuse_file_info *fi);
   }
 }

src/read_buf.cpp

@@ -1,25 +1,17 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
 #if READ_BUF
@@ -30,16 +22,20 @@
 #include <errno.h>
 #include <string.h>
 
+#include "fileinfo.hpp"
+
+typedef struct fuse_bufvec fuse_bufvec;
+
 static
 int
-_read_buf(const int            fd,
-          struct fuse_bufvec **bufp,
-          const size_t         size,
-          const off_t          offset)
+_read_buf(const int      fd,
+          fuse_bufvec  **bufp,
+          const size_t   size,
+          const off_t    offset)
 {
-  struct fuse_bufvec *src;
+  fuse_bufvec *src;
 
-  src = (fuse_bufvec*)malloc(sizeof(struct fuse_bufvec));
+  src = (fuse_bufvec*)malloc(sizeof(fuse_bufvec));
   if(src == NULL)
     return -ENOMEM;
 
@@ -56,16 +52,18 @@ _read_buf(const int            fd,
 
 namespace mergerfs
 {
-  namespace read_buf
+  namespace fuse
   {
     int
-    read_buf(const char             *fusepath,
-             struct fuse_bufvec    **bufp,
-             size_t                  size,
-             off_t                   offset,
-             struct fuse_file_info  *ffi)
+    read_buf(const char      *fusepath,
+             fuse_bufvec    **bufp,
+             size_t           size,
+             off_t            offset,
+             fuse_file_info  *ffi)
     {
-      return _read_buf(ffi->fh,
+      FileInfo *fi = reinterpret_cast<FileInfo*>(ffi->fh);
+
+      return _read_buf(fi->fd,
                        bufp,
                        size,
                        offset);

src/read_buf.hpp

@@ -1,36 +1,37 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
+#ifndef __READ_BUF_HPP__
+#define __READ_BUF_HPP__
+
+#include <fuse.h>
+
+#include <sys/types.h>
+
 namespace mergerfs
 {
-  namespace read_buf
+  namespace fuse
   {
     int
-    read_buf(const char             *fusepath,
-             struct fuse_bufvec    **buf,
-             size_t                  size,
-             off_t                   offset,
-             struct fuse_file_info  *fi);
+    read_buf(const char          *fusepath,
+             struct fuse_bufvec **buf,
+             size_t               size,
+             off_t                offset,
+             fuse_file_info      *fi);
   }
 }
+
+#endif