Merge pull request #415 from trapexit/static

add libfuse 2.9.7 to repo and build against libfuse.a
2024-04-21 12:31:43 +00:00 · 2017-06-02 16:14:54 -04:00 · 2017-06-02 11:25:25 -04:00 · 2017-05-26 19:51:28 -04:00 · 2017-05-26 18:11:18 -04:00 · 2017-05-05 00:47:24 -04:00
345 changed files with 52968 additions and 2698 deletions
@@ -0,0 +1,31 @@
+language: cpp
+
+matrix:
+  include:
+    - os: linux
+      dist: precise
+      compiler: gcc
+      sudo: required
+    - os: linux
+      dist: precise
+      compiler: clang
+      sudo: required
+    - os: linux
+      dist: trusty
+      compiler: gcc
+      sudo: required
+    - os: linux
+      dist: trusty
+      compiler: clang
+      sudo: required
+    - os: osx
+      compiler: clang
+
+before_script:
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update; fi
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew tap caskroom/cask; fi
+  - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew cask install osxfuse; fi
+
+script:
+  - sudo -E make install-build-pkgs
+  - make
@@ -1,4 +1,6 @@
 /*
+  ISC License
+
  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>

  Permission to use, copy, modify, and/or distribute this software for any
@@ -12,8 +12,6 @@
 #  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)
 TAR 	  = 	$(shell which tar)
 MKDIR     = 	$(shell which mkdir)
@@ -30,11 +28,6 @@ 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")
-endif

 ifeq ($(PANDOC),"")
 $(warning "pandoc does not appear available: manpage won't be buildable")
@@ -42,22 +35,6 @@ endif

 XATTR_AVAILABLE = $(shell test ! -e /usr/include/attr/xattr.h; echo $$?)

-FUSE_AVAILABLE = $(shell ! pkg-config --exists fuse; echo $$?)
-
-ifeq ($(FUSE_AVAILABLE),0)
-FUSE_AVAILABLE = $(shell test ! -e /usr/include/fuse.h; echo $$?)
-endif
-
-ifeq ($(FUSE_AVAILABLE),0)
-$(error "FUSE development package doesn't appear available")
-endif
-
-FLAG_NOPATH = $(shell $(CPPFIND) "flag_nopath")
-FALLOCATE   = $(shell $(CPPFIND) "fuse_fs_fallocate")
-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
@@ -66,20 +43,15 @@ OBJ         = $(SRC:src/%.cpp=obj/%.o)
 DEPS        = $(OBJ:obj/%.o=obj/%.d)
 TARGET      = mergerfs
 MANPAGE     = $(TARGET).1
-FUSE_CFLAGS = $(shell $(PKGCONFIG) --cflags fuse)
+FUSE_CFLAGS = -D_FILE_OFFSET_BITS=64 -Ilibfuse/include
 CFLAGS      = -g -Wall \
 	      $(OPTS) \
 	      -Wno-unused-result \
              $(FUSE_CFLAGS) \
-              -DFUSE_USE_VERSION=26 \
+              -DFUSE_USE_VERSION=29 \
              -MMD \
-	      -DFLAG_NOPATH=$(FLAG_NOPATH) \
-	      -DFALLOCATE=$(FALLOCATE) \
-              -DFLOCK=$(FLOCK) \
-	      -DREAD_BUF=$(READ_BUF) \
-              -DWRITE_BUF=$(WRITE_BUF) \
 	      -DUGID_USE_RWLOCK=$(UGID_USE_RWLOCK)
-LDFLAGS       = $(shell $(PKGCONFIG) fuse --libs)
+LDFLAGS       = -pthread -lrt

 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
@@ -105,8 +77,9 @@ help:
 	@echo "usage: make"
 	@echo "make XATTR_AVAILABLE=0 - to build program without xattrs functionality (auto discovered otherwise)"

-$(TARGET): src/version.hpp obj/obj-stamp $(OBJ)
-	$(CXX) $(CFLAGS) $(OBJ) -o $@ $(LDFLAGS)
+$(TARGET): src/version.hpp obj/obj-stamp libfuse/lib/.libs/libfuse.a $(OBJ)
+	cd libfuse && make
+	$(CXX) $(CFLAGS) $(OBJ) -o $@ libfuse/lib/.libs/libfuse.a -ldl $(LDFLAGS)

 mount.mergerfs: $(TARGET)
 	$(LN) -fs "$<" "$@"
@@ -131,26 +104,35 @@ obj/obj-stamp:
 obj/%.o: src/%.cpp
 	$(CXX) $(CFLAGS) -c $< -o $@

-clean: rpm-clean
-	$(RM) -rf obj
+clean: rpm-clean libfuse_Makefile
+ifneq ($(GIT),)
+ifeq  ($(shell test -e .git; echo $$?),0)
 	$(RM) -f src/version.hpp
-	$(RM) -f "$(TARGET)" "$(MANPAGE)" mount.mergerfs
+endif
+endif
+	$(RM) -rf obj
+	$(RM) -f "$(TARGET)" mount.mergerfs
 	$(FIND) . -name "*~" -delete

-distclean: clean
+	cd libfuse && $(MAKE) clean
+
+distclean: clean libfuse_Makefile
+	cd libfuse && $(MAKE) distclean
 	$(GIT) clean -fd

 install: install-base install-mount.mergerfs install-man

 install-base: $(TARGET)
-	$(INSTALL) -v -m 0755 -D "$(TARGET)" "$(INSTALLBINDIR)/$(TARGET)"
+	$(MKDIR) -p "$(INSTALLBINDIR)"
+	$(INSTALL) -v -m 0755 "$(TARGET)" "$(INSTALLBINDIR)/$(TARGET)"

 install-mount.mergerfs: mount.mergerfs
 	$(MKDIR) -p "$(INSTALLBINDIR)"
 	$(CP) -a "$<" "$(INSTALLBINDIR)/$<"

 install-man: $(MANPAGE)
-	$(INSTALL) -v -m 0644 -D "$(MANPAGE)" "$(INSTALLMAN1DIR)/$(MANPAGE)"
+	$(MKDIR) -p "$(INSTALLMAN1DIR)"
+	$(INSTALL) -v -m 0644 "man/$(MANPAGE)" "$(INSTALLMAN1DIR)/$(MANPAGE)"

 install-strip: install-base
 	$(STRIP) "$(INSTALLBINDIR)/$(TARGET)"
@@ -168,9 +150,7 @@ uninstall-man:

 $(MANPAGE): README.md
 ifneq (,$(PANDOC))
-	$(PANDOC) -s -t man -o $(MANPAGE) README.md
-else
-	$(CP) man/mergerfs.1 .
+	$(PANDOC) -s -t man -o "man/$(MANPAGE)" README.md
 endif

 man: $(MANPAGE)
@@ -207,6 +187,32 @@ rpm: tarball
 	$(RPMBUILD) -ba rpmbuild/SOURCES/$(TARGET).spec \
 		--define "_topdir $(CURDIR)/rpmbuild"

+install-build-pkgs:
+ifeq ($(shell test -e /usr/bin/apt-get; echo $$?),0)
+	apt-get -qy update
+	apt-get -qy --no-install-suggests --no-install-recommends --force-yes \
+		install build-essential git g++ debhelper libattr1-dev python automake libtool lsb-release
+else ifeq ($(shell test -e /usr/bin/dnf; echo $$?),0)
+	dnf -y update
+	dnf -y install git rpm-build libattr-devel gcc-c++ make which python automake libtool gettext-devel
+else ifeq ($(shell test -e /usr/bin/yum; echo $$?),0)
+	yum -y update
+	yum -y install git rpm-build libattr-devel gcc-c++ make which python automake libtool gettext-devel
+endif
+
+unexport CFLAGS LDFLAGS
+.PHONY: libfuse_Makefile
+libfuse_Makefile:
+ifeq ($(shell test -e libfuse/Makefile; echo $$?),1)
+	cd libfuse && \
+	$(MKDIR) -p m4 && \
+	autoreconf --force --install && \
+        ./configure --enable-lib --disable-util --disable-example
+endif
+
+libfuse/lib/.libs/libfuse.a: libfuse_Makefile
+	cd libfuse && $(MAKE)
+
 .PHONY: all clean install help

-include $(wildcard obj/*.d)
+-include $(DEPS)
@@ -1,10 +1,10 @@
 % mergerfs(1) mergerfs user manual
 % Antonio SJ Musumeci <trapexit@spawn.link>
-% 2016-01-21
+% 2017-05-26

 # NAME

-mergerfs - another (FUSE based) union filesystem
+mergerfs - a featureful union filesystem

 # SYNOPSIS

@@ -12,7 +12,7 @@ mergerfs -o&lt;options&gt; &lt;srcmounts&gt; &lt;mountpoint&gt;

 # DESCRIPTION

-**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**.
+**mergerfs** is a union filesystem geared towards simplifying storage and management of files across numerous commodity storage devices. It is similar to **mhddfs**, **unionfs**, and **aufs**.

 # FEATURES

@@ -24,69 +24,136 @@ mergerfs -o&lt;options&gt; &lt;srcmounts&gt; &lt;mountpoint&gt;
 * Safe to run as root
 * Opportunistic credential caching
 * Works with heterogeneous filesystem types
-* Handling of writes to full drives
+* Handling of writes to full drives (transparently move file to drive with capacity)
+* Handles pool of readonly and read/write drives
+* Turn read-only files into symlinks to increase read performance

 # OPTIONS

-###options###
+### mount options

 * **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 the **lfs**, **fwfs**, and **epmfs** 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)
+* **direct_io**: causes FUSE to bypass caching which can increase write speeds at the detriment of reads. Note that not enabling `direct_io` will cause double caching of files and therefore less memory for caching generally. However, `mmap` does not work when `direct_io` is enabled.
+* **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** or **EDQUOT** 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)
+* **use_ino**: causes mergerfs to supply file/directory inodes rather than libfuse. While not a default it is generally recommended it be enabled so that hard linked files share the same inode value.
+* **dropcacheonclose**: when a file is requested to be closed call `posix_fadvise` on it first to instruct the kernel that we no longer need the data and it can drop its cache. Recommended when **direct_io** is not enabled to limit double caching. (default: false)
+* **symlinkify**: when enabled (set to **true**) and a file is not writable and its mtime or ctime is older than **symlinkify_timeout** files will be reported as symlinks to the original files. Please read more below before using. (default: false)
+* **symlinkify_timeout**: time to wait, in seconds, to activate the **symlinkify** behavior. (default: 3600)
+* **nullrw**: turns reads and writes into no-ops. The request will succeed but do nothing. Useful for benchmarking mergerfs. (default: false)
+* **fsname**: sets the name of the filesystem as seen in **mount**, **df**, etc. Defaults to a list of the source paths concatenated together with the longest common prefix removed.
 * **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**

 **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.

-###srcmounts###
+### srcmounts

-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.**
+The srcmounts (source mounts) argument is a colon (':') delimited list of paths to be included in the pool. It does not matter if the paths are on the same or different drives nor does it matter the filesystem. Used and available space will not be duplicated for paths on the same device and any features which aren't supported by the underlying filesystem (such as file attributes or extended attributes) will return the appropriate errors.
+
+To make it easier to include multiple source mounts mergerfs supports [globbing](http://linux.die.net/man/7/glob). **The globbing tokens MUST be escaped when using via the shell else the shell itself will expand it.**

 ```
-$ mergerfs /mnt/disk\*:/mnt/cdrom /media/drives
+$ mergerfs -o defaults,allow_other,use_ino /mnt/disk\*:/mnt/cdrom /media/drives
 ```

-The above line will use all mount 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 **cdrom**.

-In /etc/fstab it'd look like the following:
+To have the pool mounted at boot or otherwise accessable from related tools use **/etc/fstab**.

 ```
-# <file system>        <mount point>  <type>         <options>             <dump>  <pass>
-/mnt/disk*:/mnt/cdrom  /media/drives  fuse.mergerfs  defaults,allow_other  0       0
+# <file system>        <mount point>  <type>         <options>                     <dump>  <pass>
+/mnt/disk*:/mnt/cdrom  /media/drives  fuse.mergerfs  defaults,allow_other,use_ino  0       0
 ```

-**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.
+**NOTE:** the globbing is done at mount or xattr update time (see below). If a new directory is added matching the glob after the fact it will not be automatically included.

-# POLICIES
+**NOTE:** for mounting via **fstab** to work you must have **mount.fuse** installed. For Ubuntu/Debian it is included in the **fuse** package.

-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** 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**.
+### symlinkify

-#### Functional  classifications ####
+Due to the levels of indirection introduced by mergerfs and the underlying technology FUSE there can be varying levels of performance degredation. This feature will turn non-directories which are not writable into symlinks to the original file found by the `readlink` policy after the mtime and ctime are older than the timeout.

-| Category | FUSE Functions |
-|----------|----------------|
+**WARNING:** The current implementation has a known issue in which if the file is open and being used when the file is converted to a symlink then the application which has that file open will receive an error when using it. This is unlikely to occur in practice but is something to keep in mind.
+
+**WARNING:** Some backup solutions, such as CrashPlan, do not backup the target of a symlink. If using this feature it will be necessary to point any backup software to the original drives or configure the software to follow symlinks if such an option is available. Alternatively create two mounts. One for backup and one for general consumption.
+
+### nullrw
+
+Due to how FUSE works there is an overhead to all requests made to a FUSE filesystem. Meaning that even a simple passthrough will have some slowdown. However, generally the overhead is minimal in comparison to the cost of the underlying I/O. By disabling the underlying I/O we can test the theoretical performance boundries.
+
+By enabling `nullrw` mergerfs will work as it always does **except** that all reads and writes will be no-ops. A write will succeed (the size of the write will be returned as if it were successful) but mergerfs does nothing with the data it was given. Similarly a read will return the size requested but won't touch the buffer.
+
+Example:
+```
+$ dd if=/dev/zero of=/path/to/mergerfs/mount/benchmark ibs=1M obs=512 count=1024
+1024+0 records in
+2097152+0 records out
+1073741824 bytes (1.1 GB, 1.0 GiB) copied, 15.4067 s, 69.7 MB/s
+
+$ dd if=/dev/zero of=/path/to/mergerfs/mount/benchmark ibs=1M obs=1M count=1024
+1024+0 records in
+1024+0 records out
+1073741824 bytes (1.1 GB, 1.0 GiB) copied, 0.219585 s, 4.9 GB/s
+
+$ dd if=/path/to/mergerfs/mount/benchmark of=/dev/null bs=512 count=102400
+102400+0 records in
+102400+0 records out
+52428800 bytes (52 MB, 50 MiB) copied, 0.757991 s, 69.2 MB/s
+
+$ dd if=/path/to/mergerfs/mount/benchmark of=/dev/null bs=1M count=1024
+1024+0 records in
+1024+0 records out
+1073741824 bytes (1.1 GB, 1.0 GiB) copied, 0.18405 s, 5.8 GB/s
+```
+
+It's important to test with different `obs` (output block size) values since the relative overhead is greater with smaller values. As you can see above the size of a read or write can massively impact theoretical performance. If an application performs much worse through mergerfs it could very well be that it doesn't optimally size its read and write requests.
+
+# FUNCTIONS / POLICIES / CATEGORIES
+
+The POSIX filesystem API has a number of functions. **creat**, **stat**, **chown**, etc. In mergerfs these functions are grouped into 3 categories: **action**, **create**, and **search**. 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 may not be very useful in practice. For instance: **rand** (random) may be useful for file creation (create) but could lead to very odd behavior if used for `chmod` (though only if there were more than one copy of the file).
+
+Policies, when called to create, will ignore drives which are readonly. This allows for readonly and read/write drives to be mixed together. Note that the drive must be explicitly mounted with the **ro** mount option for this to work.
+
+#### 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 |
+| 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 |

-**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.
+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) **getattr** will also be used.

-#### Policy descriptions ####
+#### Path Preservation

-| Policy | Description |
-|--------------|-------------|
-| ff (first found) | Given the order of the drives act on the first one found (regardless if stat would return EACCES). |
-| ffwp (first found w/ permissions) | Given the order of the drives 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) | Use the drive with the most free space available. |
-| epmfs (existing path, most free space) | If the path exists on multiple drives use the one with the most free space and is greater than **minfreespace**. If no drive has at least **minfreespace** then fallback to **mfs**. |
-| fwfs (first with free space) | Pick the first drive which has at least **minfreespace**. |
-| lfs (least free space) | Pick the drive with least available space but more than **minfreespace**. |
-| rand (random) | Pick an existing drive at random. |
-| all | Applies action to all found. For searches it will behave like first found **ff**. |
-| enosys, einval, enotsup, exdev, erofs | Exclusively return `-1` with `errno` set to the respective value. Useful for debugging other applications' behavior to errors. |
+Policies, as described below, are of two core types. `path preserving` and `non-path preserving`.
+
+All policies which start with `ep` (**epff**, **eplfs**, **eplus**, **epmfs**, **eprand**) are `path preserving'. `ep` stands for 'existing path`.
+
+As the descriptions explain a path preserving policy will only consider drives where the relative path being accessed already exists.
+
+When using non-path preserving policies where something is created paths will be copied to target drives as necessary.
+
+#### Policy descriptions
+
+| Policy           | Description                                                |
+|------------------|------------------------------------------------------------|
+| all | Search category: acts like **ff**. Action category: apply to all found. Create category: for **mkdir**, **mknod**, and **symlink** it will apply to all found. **create** works like **ff**. It will exclude readonly drives and those with free space less than **minfreespace**. |
+| epall (existing path, all) | Search category: acts like **epff**. Action category: apply to all found. Create category: for **mkdir**, **mknod**, and **symlink** it will apply to all existing paths found. **create** works like **epff**. Excludes readonly drives and those with free space less than **minfreespace**. |
+| epff (existing path, first found) | Given the order of the drives, as defined at mount time or configured at runtime, act on the first one found where the relative path already exists. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). Falls back to **ff**. |
+| eplfs (existing path, least free space) | Of all the drives on which the relative path exists choose the drive with the least free space. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **lfs**. |
+| eplus (existing path, least used space) | Of all the drives on which the relative path exists choose the drive with the least used space. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **lus**. |
+| epmfs (existing path, most free space) | Of all the drives on which the relative path exists choose the drive with the most free space. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
+| eprand (existing path, random) | Calls **epall** and then randomizes. Otherwise behaves the same as **epall**. |
+| erofs | Exclusively return **-1** with **errno** set to **EROFS** (Read-only filesystem). By setting **create** functions to this you can in effect turn the filesystem mostly readonly. |
+| ff (first found) | Given the order of the drives, as defined at mount time or configured at runtime, act on the first one found. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). |
+| lfs (least free space) | Pick the drive with the least available free space. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
+| lus (least used space) | Pick the drive with the least used space. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
+| mfs (most free space) | Pick the drive with the most available free space. For **create** category functions it will exclude readonly drives. Falls back to **ff**. |
+| newest | Pick the file / directory with the largest mtime. For **create** category functions it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). |
+| rand (random) | Calls **all** and then randomizes. |

 #### Defaults ####

@@ -98,14 +165,18 @@ Filesystem calls are broken up into 3 categories: **action**, **create**, **sear

 #### 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.
+**NOTE:** If you're receiving errors from software when files are moved / renamed then you should consider changing the create policy to one which is **not** path preserving or contacting the author of the offending software and requesting that `EXDEV` be properly handled.

-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.
+[rename](http://man7.org/linux/man-pages/man2/rename.2.html) is a tricky function in a merged system. Under normal situations rename only works within a single filesystem or device. 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** (cross device).

-* If using a policy which tries to preserve directories (epmfs)
-  * Using the `rename` policy get the list of files to rename
+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 otherwise handle it poorly. 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.
+
+As a result a compromise was made in order to get most software to work while still obeying mergerfs' policies. Below is the rather complicated logic.
+
+* If using a **create** policy which tries to preserve directory paths (epff,eplfs,eplus,epmfs)
+  * Using the **rename** policy get the list of files to rename
  * For each file attempt rename:
-    * If failure with ENOENT run `create` policy
+    * 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
@@ -113,9 +184,9 @@ Originally mergerfs would return EXDEV whenever a rename was requested which was
  * 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
+* If using a **create** policy which does **not** try to preserve directory paths
+  * 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
@@ -128,19 +199,17 @@ Originally mergerfs would return EXDEV whenever a rename was requested which was

 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.
+The above behavior will help minimize the likelihood of EXDEV being returned but it will still be possible.

-`link` uses the same basic strategy.
+**link** uses the same basic strategy.

 #### readdir ####

-[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 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.
+[readdir](http://linux.die.net/man/3/readdir) is different from all other filesystem functions. While it could have it's own set of policies to tweak its behavior at this time it provides a simple union of files and directories found. Remember that any action or information queried about these files and directories come from the respective function. For instance: an **ls** is a **readdir** and for each file/directory returned **getattr** is called. Meaning the policy of **getattr** is responsible for choosing the file/directory which is the source of the metadata you see in an **ls**.

 #### 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 mount points on the same drive will not result in double counting it's space. It is possible due to a race condition that the same drive could be double counted but it's rather unlikely.
+[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

@@ -151,13 +220,15 @@ First get the code from [github](http://github.com/trapexit/mergerfs).
 ```
 $ git clone https://github.com/trapexit/mergerfs.git
 $ # or
-$ wget https://github.com/trapexit/mergerfs/archive/master.zip
+$ wget https://github.com/trapexit/mergerfs/releases/download/<ver>/mergerfs-<ver>.tar.gz
 ```

 #### Debian / Ubuntu
 ```
-$ sudo apt-get install g++ pkg-config git git-buildpackage pandoc debhelper libfuse-dev libattr1-dev python
+$ sudo apt-get -y update
+$ sudo apt-get -y install git make
 $ cd mergerfs
+$ make install-build-pkgs
 $ make deb
 $ sudo dpkg -i ../mergerfs_version_arch.deb
 ```
@@ -165,20 +236,21 @@ $ sudo dpkg -i ../mergerfs_version_arch.deb
 #### Fedora
 ```
 $ su -
-# dnf install rpm-build fuse-devel libattr-devel pandoc gcc-c++ git make which python
+# dnf -y update
+# dnf -y install git make
 # cd mergerfs
+# make install-build-pkgs
 # make rpm
 # rpm -i rpmbuild/RPMS/<arch>/mergerfs-<verion>.<arch>.rpm
 ```

 #### Generically

-Have git, python, pkg-config, pandoc, libfuse, libattr1 installed.
+Have git, g++, make, python, libattr1, automake, libtool installed.

 ```
 $ cd mergerfs
 $ make
-$ make man
 $ sudo make install
 ```

@@ -191,11 +263,44 @@ $ sudo make install

 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.
+Even if xattrs are disabled for mergerfs the [{list,get,set}xattrs](http://linux.die.net/man/2/listxattr) calls against this pseudo file will still work.
+
+Any changes made at runtime are **not** persisted. If you wish for values to persist they must be included as options wherever you configure the mounting of mergerfs (fstab).

 ##### Keys #####

-Use `xattr -l /mount/point/.mergerfs` to see all supported keys.
+Use `xattr -l /mount/point/.mergerfs` to see all supported keys. Some are informational and therefore readonly.
+
+###### user.mergerfs.srcmounts ######
+
+Used to query or modify the list of source mounts. When modifying there are several shortcuts to easy manipulation of the list.
+
+| Value        | 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 #####

@@ -204,38 +309,14 @@ Use `xattr -l /mount/point/.mergerfs` to see all supported keys.
 user.mergerfs.srcmounts: /tmp/a:/tmp/b
 user.mergerfs.minfreespace: 4294967295
 user.mergerfs.moveonenospc: false
-user.mergerfs.policies: all,einval,enosys,enotsup,epmfs,erofs,exdev,ff,ffwp,fwfs,lfs,mfs,newest,rand
-user.mergerfs.version: x.y.z
-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
+...

 [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
@@ -250,38 +331,7 @@ 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]       | 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.
-
-#### mergerfs file xattrs ####
+#### file / directory 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:

@@ -306,62 +356,217 @@ A B C

 # TOOLING

-Find extra tooling to help with managing `mergerfs` at: https://github.com/trapexit/mergerfs-tools
-
-* fsck.mergerfs: Provides permissions and ownership auditing and the ability to fix them
+* https://github.com/trapexit/mergerfs-tools
+  * mergerfs.ctl: A tool to make it easier to query and configure mergerfs at runtime
+  * mergerfs.fsck: Provides permissions and ownership auditing and the ability to fix them
+  * mergerfs.dedup: Will help identify and optionally remove duplicate files
+  * mergerfs.balance: Rebalance files across drives by moving them from the most filled to the least filled
+  * mergerfs.mktrash: Creates FreeDesktop.org Trash specification compatible directories on a mergerfs mount
+* https://github.com/trapexit/scorch
+  * scorch: A tool to help discover silent corruption of files
+* https://github.com/trapexit/bbf
+  * bbf (bad block finder): a tool to scan for and 'fix' hard drive bad blocks and find the files using those blocks

 # TIPS / NOTES

-* 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 `fsck.mergerfs` 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).
+* The recommended options are **defaults,allow_other,direct_io,use_ino**. (**use_ino** will only work when used with mergerfs 2.18.0 and above.)
+* Run mergerfs as `root` unless you're merging paths which are owned by the same user otherwise strange permission issues may arise.
+* https://github.com/trapexit/backup-and-recovery-howtos : A set of guides / howtos on creating a data storage system, backing it up, maintaining it, and recovering from failure.
+* If you don't see some directories and files you expect in a merged point or policies seem to skip drives be sure the user has permission to all the underlying directories. Use `mergerfs.fsck` to audit the drive for out of sync permissions.
+* Do *not* use `direct_io` if you expect applications (such as rtorrent) to [mmap](http://linux.die.net/man/2/mmap) files. It is not currently supported in FUSE w/ `direct_io` enabled.
+* 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. This means however that some odd situations may arise.
+* [Kodi](http://kodi.tv), [Plex](http://plex.tv), [Subsonic](http://subsonic.org), etc. 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 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.
+* 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.
+* For consistency 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). However, the flexibility is there if needed.

-# Known Issues / Bugs
+# KNOWN ISSUES / BUGS

-#### Samba
-* Moving files or directories between some directories on a SMB share fail with IO errors.    
-    
-    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.
+#### directory mtime is not being updated

-#### Supplemental 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 mount or 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 (as the original design required). 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.
+Remember that the default policy for `getattr` is `ff`. The information for the first directory found will be returned. If it wasn't the directory which had been updated then it will appear outdated.
+
+The reason this is the default is because any other policy would be far more expensive and for many applications it is unnecessary. To always return the directory with the most recent mtime or a faked value based on all found would require a scan of all drives. That alone is far more expensive than `ff` but would also possibly spin up sleeping drives.
+
+If you always want the directory information from the one with the most recent mtime then use the `newest` policy for `getattr`.
+
+#### cached memory appears greater than it should be
+
+Use the `direct_io` option as described above. Due to what mergerfs is doing there ends up being two caches of a file under normal usage. One from the underlying filesystem and one from mergerfs. Enabling `direct_io` removes the mergerfs cache. This saves on memory but means the kernel needs to communicate with mergerfs more often and can therefore result in slower speeds.
+
+Since enabling `direct_io` disables `mmap` this is not an ideal situation however write speeds should be increased.
+
+If `direct_io` is disabled it is probably a good idea to enable `dropcacheonclose` to minimize double caching.
+
+#### NFS clients don't work
+
+Some NFS clients appear to fail when a mergerfs mount is exported. Kodi in particular seems to have issues.
+
+Try enabling the `use_ino` option. Some have reported that it fixes the issue.
+
+#### rtorrent fails with ENODEV (No such device)
+
+Be sure to turn off `direct_io`. rtorrent and some other applications use [mmap](http://linux.die.net/man/2/mmap) to read and write to files and offer no failback to traditional methods. FUSE does not currently support mmap while using `direct_io`. There will be a performance penalty on writes with `direct_io` off as well as the problem of double caching but it's the only way to get such applications to work. If the performance loss is too high for other apps you can mount mergerfs twice. Once with `direct_io` enabled and one without it.
+
+#### mmap performance is really bad
+
+There [is a bug](https://lkml.org/lkml/2016/3/16/260) in caching which affects overall performance of mmap through FUSE in Linux 4.x kernels. It is fixed in [4.4.10 and 4.5.4](https://lkml.org/lkml/2016/5/11/59).
+
+#### When a program tries to move or rename a file it fails
+
+Please read the section above regarding [rename & link](#rename--link).
+
+The problem is that many applications do not properly handle `EXDEV` errors which `rename` and `link` may return even though they are perfectly valid situations which do not indicate actual drive or OS errors. The error will only be returned by mergerfs if using a path preserving policy as described in the policy section above. If you do not care about path preservation simply change the mergerfs policy to the non-path preserving version. For example: `-o category.create=mfs`
+
+Ideally the offending software would be fixed and it is recommended that if you run into this problem you contact the software's author and request proper handling of `EXDEV` errors.
+
+#### 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.
+
+#### 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`.
+
+#### 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
+
+**NOTE:** as of mergerfs 2.22.0 it includes the most recent version of libfuse so any crash should be reported. For older releases continue reading...
+
+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.
+
+#### mergerfs appears to be crashing or exiting
+
+There seems to be an issue with Linux version `4.9.0` and above in which an invalid message appears to be transmitted to libfuse (used by mergerfs) causing it to exit. No messages will be printed in any logs as its not a proper crash. Debugging of the issue is still ongoing and can be followed via the [fuse-devel thread](https://sourceforge.net/p/fuse/mailman/message/35662577).
+
+#### mergerfs under heavy load and memory preasure leads to kernel panic
+
+https://lkml.org/lkml/2016/9/14/527
+
+```
+[25192.515454] kernel BUG at /build/linux-a2WvEb/linux-4.4.0/mm/workingset.c:346!
+[25192.517521] invalid opcode: 0000 [#1] SMP
+[25192.519602] Modules linked in: netconsole ip6t_REJECT nf_reject_ipv6 ipt_REJECT nf_reject_ipv4 configfs binfmt_misc veth bridge stp llc nf_conntrack_ipv6 nf_defrag_ipv6 xt_conntrack ip6table_filter ip6_tables xt_multiport iptable_filter ipt_MASQUERADE nf_nat_masquerade_ipv4 xt_comment xt_nat iptable_nat nf_conntrack_ipv4 nf_defrag_ipv4 nf_nat_ipv4 nf_nat nf_conntrack xt_CHECKSUM xt_tcpudp iptable_mangle ip_tables x_tables intel_rapl x86_pkg_temp_thermal intel_powerclamp eeepc_wmi asus_wmi coretemp sparse_keymap kvm_intel ppdev kvm irqbypass mei_me 8250_fintek input_leds serio_raw parport_pc tpm_infineon mei shpchp mac_hid parport lpc_ich autofs4 drbg ansi_cprng dm_crypt algif_skcipher af_alg btrfs raid456 async_raid6_recov async_memcpy async_pq async_xor async_tx xor raid6_pq libcrc32c raid0 multipath linear raid10 raid1 i915 crct10dif_pclmul crc32_pclmul aesni_intel i2c_algo_bit aes_x86_64 drm_kms_helper lrw gf128mul glue_helper ablk_helper syscopyarea cryptd sysfillrect sysimgblt fb_sys_fops drm ahci r8169 libahci mii wmi fjes video [last unloaded: netconsole]
+[25192.540910] CPU: 2 PID: 63 Comm: kswapd0 Not tainted 4.4.0-36-generic #55-Ubuntu
+[25192.543411] Hardware name: System manufacturer System Product Name/P8H67-M PRO, BIOS 3904 04/27/2013
+[25192.545840] task: ffff88040cae6040 ti: ffff880407488000 task.ti: ffff880407488000
+[25192.548277] RIP: 0010:[<ffffffff811ba501>]  [<ffffffff811ba501>] shadow_lru_isolate+0x181/0x190
+[25192.550706] RSP: 0018:ffff88040748bbe0  EFLAGS: 00010002
+[25192.553127] RAX: 0000000000001c81 RBX: ffff8802f91ee928 RCX: ffff8802f91eeb38
+[25192.555544] RDX: ffff8802f91ee938 RSI: ffff8802f91ee928 RDI: ffff8804099ba2c0
+[25192.557914] RBP: ffff88040748bc08 R08: 000000000001a7b6 R09: 000000000000003f
+[25192.560237] R10: 000000000001a750 R11: 0000000000000000 R12: ffff8804099ba2c0
+[25192.562512] R13: ffff8803157e9680 R14: ffff8803157e9668 R15: ffff8804099ba2c8
+[25192.564724] FS:  0000000000000000(0000) GS:ffff88041f280000(0000) knlGS:0000000000000000
+[25192.566990] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
+[25192.569201] CR2: 00007ffabb690000 CR3: 0000000001e0a000 CR4: 00000000000406e0
+[25192.571419] Stack:
+[25192.573550]  ffff8804099ba2c0 ffff88039e4f86f0 ffff8802f91ee928 ffff8804099ba2c8
+[25192.575695]  ffff88040748bd08 ffff88040748bc58 ffffffff811b99bf 0000000000000052
+[25192.577814]  0000000000000000 ffffffff811ba380 000000000000008a 0000000000000080
+[25192.579947] Call Trace:
+[25192.582022]  [<ffffffff811b99bf>] __list_lru_walk_one.isra.3+0x8f/0x130
+[25192.584137]  [<ffffffff811ba380>] ? memcg_drain_all_list_lrus+0x190/0x190
+[25192.586165]  [<ffffffff811b9a83>] list_lru_walk_one+0x23/0x30
+[25192.588145]  [<ffffffff811ba544>] scan_shadow_nodes+0x34/0x50
+[25192.590074]  [<ffffffff811a0e9d>] shrink_slab.part.40+0x1ed/0x3d0
+[25192.591985]  [<ffffffff811a53da>] shrink_zone+0x2ca/0x2e0
+[25192.593863]  [<ffffffff811a64ce>] kswapd+0x51e/0x990
+[25192.595737]  [<ffffffff811a5fb0>] ? mem_cgroup_shrink_node_zone+0x1c0/0x1c0
+[25192.597613]  [<ffffffff810a0808>] kthread+0xd8/0xf0
+[25192.599495]  [<ffffffff810a0730>] ? kthread_create_on_node+0x1e0/0x1e0
+[25192.601335]  [<ffffffff8182e34f>] ret_from_fork+0x3f/0x70
+[25192.603193]  [<ffffffff810a0730>] ? kthread_create_on_node+0x1e0/0x1e0
+```
+
+There is a bug in the kernel. A work around appears to be turning off `splice`. Add `no_splice_write,no_splice_move,no_splice_read` to mergerfs' options. Should be placed after `defaults` if it is used since it will turn them on. This however is not guaranteed to work.

 # 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) 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.  
+mhddfs is no longer maintained and has some known stability and security issues (see below). MergerFS provides a superset of mhddfs' features and should offer the same or maybe better performance.

-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.  
+If you wish to get similar behavior to mhddfs from mergerfs then set `category.create=ff`.

-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.  
+#### Why use mergerfs over aufs?

-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)  
+While aufs can offer better peak performance mergerfs provides more configurability and is generally easier to use. mergerfs however does not offer the overlay / copy-on-write (COW) features which aufs and overlayfs have.

-> 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).  
+#### Why use mergerfs over LVM/ZFS/BTRFS/RAID0 drive concatenation / striping?

-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).  
+With simple JBOD / drive concatenation / stripping / RAID0 a single drive failure will result in full pool failure. mergerfs performs a similar behavior without the possibility of catastrophic failure and difficulties in recovery. Drives may fail however all other data will continue to be accessable.

-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.   
+When combined with something like [SnapRaid](http://www.snapraid.it) and/or an offsite backup solution you can have the flexibilty of JBOD without the single point of failure.
+
+#### Why use mergerfs over ZFS?
+
+MergerFS is not intended to be a replacement for ZFS. MergerFS is intended to provide flexible pooling of arbitrary drives (local or remote), of arbitrary sizes, and arbitrary filesystems. For `write once, read many` usecases such as bulk media storage. Where data integrity and backup is managed in other ways. In that situation ZFS can introduce major maintance and cost burdens as described [here](http://louwrentius.com/the-hidden-cost-of-using-zfs-for-your-home-nas.html).
+
+#### Can drives be written to directly? Outside of mergerfs while pooled?
+
+Yes. It will be represented immediately in the pool as the policies perscribe.
+
+#### Why do I get an "out of space" error even though the system says there's lots of space left?
+
+First make sure you've read the sections above about policies, path preserving, and the **moveonenospc** option.
+
+Remember that mergerfs is simply presenting a logical merging of the contents of the pooled drives. The reported free space is the aggregate space available **not** the contiguous space available. MergerFS does not split files across drives. If the writing of a file fills a drive and **moveonenospc** is disabled it will return an ENOSPC error.
+
+If **moveonenospc** is enabled but there exists no drives with enough space for the file and the data to be written (or the drive happened to fill up as the file was being moved) it will error indicating there isn't enough space.
+
+It is also possible that the filesystem selected has run out of inodes. Use `df -i` to list the total and available inodes per filesystem. In the future it might be worth considering the number of inodes available when making placement decisions in order to minimize this situation.
+
+#### Can mergerfs mounts be exported over NFS?
+
+Yes. Some clients (Kodi) have issues in which the contents of the NFS mount will not be presented but users have found that enabling the `use_ino` option often fixes that problem.
+
+#### Can mergerfs mounts be exported over Samba / SMB?
+
+Yes.
+
+#### How are inodes calculated?
+
+mergerfs-inode = (original-inode | (device-id << 32))
+
+While `ino_t` is 64 bits only a few filesystems use more than 32. Similarly, while `dev_t` is also 64 bits it was traditionally 16 bits. Bitwise or'ing them together should work most of the time. While totally unique inodes are preferred the overhead which would be needed does not seem to outweighted by the benefits.
+
+#### 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) manages running 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 behavior the proper way to manage this is to use [seteuid](http://linux.die.net/man/2/seteuid) and [setegid](http://linux.die.net/man/2/setegid), in effect becoming the user making the original call, and perform the action as them. This is what mergerfs does.
+
+In Linux setreuid syscalls apply only to the thread. GLIBC hides this away by using realtime 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 between drives).
+
+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 allowing 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 assuming there are few users.

 # SUPPORT

 #### Issues with the software
 * github.com: https://github.com/trapexit/mergerfs/issues
 * email: trapexit@spawn.link
+* twitter: https://twitter.com/_trapexit

 #### Support development
 * Gratipay: https://gratipay.com/~trapexit
 * BitCoin: 12CdMhEPQVmjz3SSynkAEuD5q9JmhTDCZA
+
+# LINKS
+
+* http://github.com/trapexit/mergerfs
+* http://github.com/trapexit/mergerfs-tools
+* http://github.com/trapexit/scorch
+* http://github.com/trapexit/backup-and-recovery-howtos
@@ -3,17 +3,14 @@ Section: utils
 Priority: optional
 Maintainer: Antonio SJ Musumeci <trapexit@spawn.link>
 Build-Depends: debhelper (>= 8.0.0),
- libfuse-dev,
- libattr1-dev,
- pkg-config
+ libattr1-dev
 Standards-Version: 3.9.4
 Homepage: http://github.com/trapexit/mergerfs

 Package: mergerfs
 Architecture: any
 Depends: ${shlibs:Depends},
- ${misc:Depends},
- libfuse2
+ ${misc:Depends}
 Description: another FUSE union filesystem
 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
@@ -0,0 +1,59 @@
+Current Maintainer
+------------------
+
+Nikolaus Rath <Nikolaus@rath.org>
+
+
+Past Maintainers
+----------------
+
+Miklos Szeredi <miklos@szeredi.hu> (until 12/2015)
+
+
+Contributors
+------------
+
+CUSE has been written by Tejun Heo <teheo@suse.de>. Furthermore, the
+following people have contributed patches (autogenerated list):
+
+Anatol Pomozov <anatol.pomozov@gmail.com>
+Antonio SJ Musumeci <trapexit@spawn.link>
+Christopher Harrison <ch12@sanger.ac.uk>
+Csaba Henk <csaba.henk@creo.hu>
+cvs2git <>
+Dalvik Khertel <khertel@outlook.com>
+Daniel Thau <danthau@bedrocklinux.org>
+David McNab <david@rebirthing.co.nz>
+David Sheets <sheets@alum.mit.edu>
+Emmanuel Dreyfus <manu@netbsd.org>
+Enke Chen <enkechen@yahoo.com>
+Eric Engestrom <eric@engestrom.ch>
+Eric Wong <normalperson@yhbt.net>
+Fabrice Bauzac <fbauzac@amadeus.com>
+Feng Shuo <steve.shuo.feng@gmail.com>
+Hendrik Brueckner <brueckner@linux.vnet.ibm.com>
+Ikey Doherty <michael.i.doherty@intel.com>
+Jan Blumschein <jan@jan-blumschein.de>
+Joachim Schiele <joachim.schiele@daimler.com>
+Joachim Schiele <js@lastlog.de>
+John Muir <john@jmuir.com>
+Laszlo Papp <ext-laszlo.papp@nokia.com>
+Madan Valluri <mvalluri@cumulus-systems.com>
+Mark Glines <mark@glines.org>
+Max Krasnyansky <maxk@kernel.org>
+Michael Grigoriev <mag@luminal.org>
+Miklos Szeredi <miklos@szeredi.hu>
+Miklos Szeredi <mszeredi@suse.cz>
+mkmm@gmx-topmail.de <mkmm@gmx-topmail.de>
+Natanael Copa <ncopa@alpinelinux.org>
+Nikolaus Rath <Nikolaus@rath.org>
+Olivier Blin <olivier.blin@softathome.com>
+Ratna_Bolla@dell.com <Ratna_Bolla@dell.com>
+Reuben Hawkins <reubenhwk@gmail.com>
+Richard W.M. Jones <rjones@redhat.com>
+Riku Voipio <riku.voipio@linaro.org>
+Roland Bauerschmidt <rb@debian.org>
+Sam Stuewe <halosghost@archlinux.info>
+Sebastian Pipping <sebastian@pipping.org>
+therealneworld@gmail.com <therealneworld@gmail.com>
+Winfried Koehler <w_scan@gmx-topmail.de>
@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
@@ -0,0 +1,502 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
@@ -0,0 +1,15 @@
+## Process this file with automake to produce Makefile.in
+
+ACLOCAL_AMFLAGS = -I m4
+
+SUBDIRS = @subdirs2@ doc
+AUTOMAKE_OPTIONS = subdir-objects
+
+EXTRA_DIST =			\
+	fuse.pc.in		\
+	README*
+
+pkgconfigdir = @pkgconfigdir@
+pkgconfig_DATA = fuse.pc
+
+$(pkgconfig_DATA): config.status
@@ -0,0 +1,303 @@
+What is new in 2.9
+
+ - Add "zero copy" support for kernel 2.6.35 or newer
+
+ - Make maximum background requests tunable on kernel 2.6.32 or newer
+
+ - Require --no-canonicalize in (u)mount (util-linux version 2.18 or
+   newer) to fix security problems with fusermount
+
+ - Use dynamically sized hash tables in high level library
+
+ - Memory use of filesystem daemon can shrink more easily
+
+ - Add "auto_unmount" option
+
+ - Add "remember" option
+
+ - Add man pages for fusermount, mount.fuse and ulockmgr_server
+
+ - API changes:
+
+    o Introduce "store" and "retrieve" for accessing kernel buffers on
+      kernel 2.6.36 or newer
+
+    o Introduce abstract buffer for zero copy operations
+
+    o Allow path calculation to be omitted on certain operations
+
+    o Allow batching forget requests
+
+    o Add "flock" method
+
+    o Add support for ioctl on directories
+
+    o Add delete notification
+
+    o Add fallocate operation (linux kernel 3.5 or newer)
+
+ - Bug fixes and small improvements
+
+============================================================================
+
+What is new in 2.8
+
+ - More scalable directory tree locking
+
+ - Atomic open(O_TRUNC) support
+
+ - Support big write requests on kernels 2.6.26 and newer
+
+ - Out-of-tree fuse module removed
+
+ - Better NFS exporting support
+
+ - New ioctl and poll requests
+
+ - New CUSE (Character Device in Userspace) interface
+
+ - Allow umask processing in userspace
+
+ - Added cache invalidation notifications
+
+ - Bugfixes and small improvements
+
+============================================================================
+
+What is new in 2.7
+
+ - Stacking support for the high level API
+
+ - Add filename charset conversion module
+
+ - Improved mounting
+
+============================================================================
+
+What is new in 2.6
+
+ - Improved read characteristics (asynchronous reads)
+
+ - Support for aborting filesystem connection
+
+ - POSIX file locking support
+
+ - Request interruption support
+
+ - Building module for Linux kernels earlier than 2.6.9 not supported
+
+ - Allow block device based filesystems to support swap files
+
+ - Several bugs fixed, including a rare system hang on SMP
+
+============================================================================
+
+What is new in 2.5
+
+ - Merge library part of FreeBSD port
+
+ - New atomic create+open, access and ftruncate operations
+
+ - On filesystems implementing the new create+open operation, and
+   running on Linux kernels 2.6.15 or later, the 'cp' operation will
+   work correctly when copying read-only files.
+
+ - New option parsing interface added to the library
+
+ - Lots of minor improvements and fixes
+
+============================================================================
+
+What is new in 2.4
+
+ - Simplify device opening.  Now '/dev/fuse' is a requirement
+
+ - Allow module auto-loading if user has access to '/dev/fuse'
+
+ - Allow mounting over a regular file for unprivileged users
+
+ - Allow mounting of arbitrary FUSE filesystems from /etc/fstab
+
+ - New mount options: 'umask=M', 'uid=N', 'gid=N'
+
+ - Check for non-empty mountpoint, and refuse mount by default.  New
+   mount option: 'nonempty'
+
+ - Low level (inode based) API added
+
+ - Allow 'direct_io' and 'keep_cache' options to be set on a
+   case-by-case basis on open.
+
+ - Add 'attr_timeout' and 'entry_timeout' mount options to the
+   high-level library.  Until now these timeouts were fixed at 1 sec.
+
+ - Some bugfixes
+
+============================================================================
+
+What is new in 2.3
+
+ - Add new directory related operations: opendir(), readdir(),
+   releasedir() and fsyncdir()
+
+ - Add init() and destroy() operations which are called before the
+   event loop is started and after it has exited
+
+ - Update kernel ABI so that on dual architectures (e.g. AMD64) 32bit
+   binaries work under a 64bit kernel
+
+ - Bugfixes
+
+============================================================================
+
+What is new in 2.2
+
+Userspace changes:
+
+ - Add fuse_file_info structure to file operations, this allows the
+   filesystem to return a file handle in open() which is passed to
+   read(), write(), flush(), fsync() and release().
+
+ - Add source compatibility with 2.1 and 1.4 releases
+
+ - Binary compatibility with 2.1 release is retained
+
+Kernel changes:
+
+ - Make requests interruptible.  This prevents the filesystem to go
+   into an unbreakable deadlock with itself.
+
+ - Make readpages() synchronous.  Asynchronous requests are deadlock
+   prone, since they cannot be interrupted (see above)
+
+ - Remove shared-writeable mapping support, which could deadlock the
+   machine
+
+ - Remove INVALIDATE userspace initiated request
+
+ - Update ABI to be independent of sizeof(long), so dual-size archs
+   don't cause problems
+
+ - Remove /sys/fs/fuse/version.  Version checking is now done through
+   the fuse device
+
+ - Replace directory reading method on the kernel interface.  Instead
+   of passing an open file descriptor to the kernel, send data through
+   the FUSE device, like all other operations.
+
+============================================================================
+
+What is new in 2.1
+
+* Bug fixes
+
+* Improved support for filesystems implementing a custom event-loop
+
+* Add 'pkg-config' support
+
+* Kernel module can be compiled separately
+
+============================================================================
+
+What is new in 1.9
+
+* Lots of bugs fixed
+
+* Minor modifications to the library API
+
+* Improvements to the kernel/userspace interface
+
+* Mounting by non-root made more secure
+
+* Build shared library in addition to the static one
+
+* Consolidated mount options
+
+* Optimized reading under 2.6 kernels
+
+* Direct I/O support
+
+* Support file I/O on deleted files
+
+* Extended attributes support
+
+============================================================================
+
+What is new in 1.3
+
+* Thanks to user bugreports and stress testing with LTP and sfx-linux
+a number of bugs were fixed, some quite serious.
+
+* Fix compile problems with recent SuSE kernles
+
+============================================================================
+
+What is new in 1.2
+
+* Fix mount problems on recent 2.6 kernels with SELinux enabled
+
+* Fixed writing files lager than 2GBytes
+
+* Other bugfixes
+
+============================================================================
+
+What is new in 1.1
+
+* Support for the 2.6 kernels
+
+* Support for exporting filesystem over NFS in 2.6 kernels
+
+* Read efficiency improvements: read in 64k blocks instead of 4k
+(Michael Grigoriev).  Can be turned on with '-l' option of fusermount
+
+* Lazy automatic unmount
+
+* Added 'fsync()' VFS call to the FUSE interface
+
+* Bugfixes
+
+============================================================================
+
+What is new in 1.0
+
+* Cleanups and bugfixes
+
+* Added 'release()' VFS call to the FUSE interface
+
+* 64 bit file offsets (handling of > 4 GByte files)
+
+* libfuse is now under LGPL
+
+* New 'statfs' call (Mark Glines)
+
+* Cleaned up mount procedure (mostly by Mark Glines)
+
+  NOTE: Binaries linked with with a previous version of libavfs may
+  not work with the new version of the fusermount program.  In such
+  case recompile the program after installing the new libavfs library.
+
+* Fix for problems under linux kernel 2.4.19
+
+============================================================================
+
+What is new in 0.95
+
+* Optimized read/write operations.  Raw throughput has increased to
+about 60Mbyte/s on a Celeron/360
+
+* Python bindings by Jeff Epler
+
+* Perl bindings by Mark Glines
+
+* Improved multithreaded operation
+
+* Simplified library interface
+
+* Bugfixes
+
+============================================================================
+
+What is new in 0.9:
+
+* Everything
@@ -0,0 +1,33 @@
+NFS exporting is supported in Linux kernels 2.6.27 or later.
+
+You need to add an fsid=NNN option to /etc/exports to make exporting a
+FUSE directory work.
+
+Filesystem support
+------------------
+
+NFS exporting works to some extent on all fuse filesystems, but not
+perfectly.  This is due to the stateless nature of the protocol, the
+server has no way of knowing whether the client is keeping a reference
+to a file or not, and hence that file may be removed from the server's
+cache.  In that case there has to be a way to look up that object
+using the inode number, otherwise an ESTALE error will be returned.
+
+1) low-level interface
+
+Filesystems need to implement special lookups for the names "." and
+"..".  The former may be requested on any inode, including
+non-directories, while the latter is only requested for directories.
+Otherwise these special lookups should behave identically to ordinary
+lookups.
+
+2) high-level interface
+
+Because the high-level interface is path based, it is not possible to
+delegate looking up by inode to the filesystem.
+
+To work around this, currently a "noforget" option is provided, which
+makes the library remember nodes forever.  This will make the NFS
+server happy, but also results in an ever growing memory footprint for
+the filesystem.  For this reason if the filesystem is large (or the
+memory is small), then this option is not recommended.
@@ -0,0 +1,108 @@
+libfuse
+=======
+
+Warning: unresolved security issue
+----------------------------------
+
+Be aware that FUSE has an unresolved security bug
+([bug #15](https://github.com/libfuse/libfuse/issues/15)): the
+permission check for accessing a cached directory is only done once
+when the directory entry is first loaded into the cache. Subsequent
+accesses will re-use the results of the first check, even if the
+directory permissions have since changed, and even if the subsequent
+access is made by a different user.
+
+This bug needs to be fixed in the Linux kernel and has been known
+since 2006 but unfortunately no fix has been applied yet. If you
+depend on correct permission handling for FUSE file systems, the only
+workaround is to completely disable caching of directory
+entries. Alternatively, the severity of the bug can be somewhat
+reduced by not using the `allow_other` mount option.
+
+
+About
+-----
+
+FUSE (Filesystem in Userspace) is an interface for userspace programs
+to export a filesystem to the Linux kernel. The FUSE project consists
+of two components: the *fuse* kernel module (maintained in the regular
+kernel repositories) and the *libfuse* userspace library (maintained
+in this repository). libfuse provides the reference implementation
+for communicating with the FUSE kernel module.
+
+A FUSE file system is typically implemented as a standalone
+application that links with libfuse. libfuse provides functions to
+mount the file system, unmount it, read requests from the kernel, and
+send responses back. libfuse offers two APIs: a "high-level",
+synchronous API, and a "low-level" asynchronous API. In both cases,
+incoming requests from the kernel are passed to the main program using
+callbacks. When using the high-level API, the callbacks may work with
+file names and paths instead of inodes, and processing of a request
+finishes when the callback function returns. When using the low-level
+API, the callbacks must work with inodes and responses must be sent
+explicitly using a separate set of API functions.
+
+
+Installation
+------------
+
+    ./configure
+    make -j8
+    make install
+
+You may also need to add `/usr/local/lib` to `/etc/ld.so.conf` and/or
+run *ldconfig*. If you're building from the git repository (instead of
+using a release tarball), you also need to run `./makeconf.sh` to
+create the `configure` script.
+
+You'll also need a fuse kernel module (Linux kernels 2.6.14 or later
+contain FUSE support).
+
+For more details see the file `INSTALL`
+
+Security implications
+---------------------
+
+If you run `make install`, the *fusermount* program is installed
+set-user-id to root.  This is done to allow normal users to mount
+their own filesystem implementations.
+
+There must however be some limitations, in order to prevent Bad User from
+doing nasty things.  Currently those limitations are:
+
+  - The user can only mount on a mountpoint, for which it has write
+    permission
+
+  - The mountpoint is not a sticky directory which isn't owned by the
+    user (like /tmp usually is)
+
+  - No other user (including root) can access the contents of the
+    mounted filesystem (though this can be relaxed by allowing the use
+    of the `allow_other` and `allow_root` mount options in `fuse.conf`)
+
+
+Building your own filesystem
+------------------------------
+
+FUSE comes with several example file systems in the `examples`
+directory. For example, the *fusexmp* example mirrors the contents of
+the root directory under the mountpoint. Start from there and adapt
+the code!
+
+The documentation of the API functions and necessary callbacks is
+mostly contained in the files `include/fuse.h` (for the high-level
+API) and `include/fuse_lowlevel.h` (for the low-level API). An
+autogenerated html version of the API is available in the `doc/html`
+directory and at http://libfuse.github.io/doxygen.
+
+
+Getting Help
+------------
+
+If you need help, please ask on the <fuse-devel@lists.sourceforge.net>
+mailing list (subscribe at
+https://lists.sourceforge.net/lists/listinfo/fuse-devel).
+
+Please report any bugs on the GitHub issue tracker at
+https://github.com/libfuse/main/issues.
+
@@ -0,0 +1,684 @@
+#! /bin/sh
+# Output a system dependent set of variables, describing how to set the
+# run time search path of shared libraries in an executable.
+#
+#   Copyright 1996-2014 Free Software Foundation, Inc.
+#   Taken from GNU libtool, 2001
+#   Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+#
+#   This file is free software; the Free Software Foundation gives
+#   unlimited permission to copy and/or distribute it, with or without
+#   modifications, as long as this notice is preserved.
+#
+# The first argument passed to this file is the canonical host specification,
+#    CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM
+# or
+#    CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM
+# The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld
+# should be set by the caller.
+#
+# The set of defined variables is at the end of this script.
+
+# Known limitations:
+# - On IRIX 6.5 with CC="cc", the run time search patch must not be longer
+#   than 256 bytes, otherwise the compiler driver will dump core. The only
+#   known workaround is to choose shorter directory names for the build
+#   directory and/or the installation directory.
+
+# All known linkers require a '.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+shrext=.so
+
+host="$1"
+host_cpu=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
+host_vendor=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
+host_os=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
+
+# Code taken from libtool.m4's _LT_CC_BASENAME.
+
+for cc_temp in $CC""; do
+  case $cc_temp in
+    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
+    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
+    \-*) ;;
+    *) break;;
+  esac
+done
+cc_basename=`echo "$cc_temp" | sed -e 's%^.*/%%'`
+
+# Code taken from libtool.m4's _LT_COMPILER_PIC.
+
+wl=
+if test "$GCC" = yes; then
+  wl='-Wl,'
+else
+  case "$host_os" in
+    aix*)
+      wl='-Wl,'
+      ;;
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      ;;
+    hpux9* | hpux10* | hpux11*)
+      wl='-Wl,'
+      ;;
+    irix5* | irix6* | nonstopux*)
+      wl='-Wl,'
+      ;;
+    linux* | k*bsd*-gnu | kopensolaris*-gnu)
+      case $cc_basename in
+        ecc*)
+          wl='-Wl,'
+          ;;
+        icc* | ifort*)
+          wl='-Wl,'
+          ;;
+        lf95*)
+          wl='-Wl,'
+          ;;
+        nagfor*)
+          wl='-Wl,-Wl,,'
+          ;;
+        pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+          wl='-Wl,'
+          ;;
+        ccc*)
+          wl='-Wl,'
+          ;;
+        xl* | bgxl* | bgf* | mpixl*)
+          wl='-Wl,'
+          ;;
+        como)
+          wl='-lopt='
+          ;;
+        *)
+          case `$CC -V 2>&1 | sed 5q` in
+            *Sun\ F* | *Sun*Fortran*)
+              wl=
+              ;;
+            *Sun\ C*)
+              wl='-Wl,'
+              ;;
+          esac
+          ;;
+      esac
+      ;;
+    newsos6)
+      ;;
+    *nto* | *qnx*)
+      ;;
+    osf3* | osf4* | osf5*)
+      wl='-Wl,'
+      ;;
+    rdos*)
+      ;;
+    solaris*)
+      case $cc_basename in
+        f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
+          wl='-Qoption ld '
+          ;;
+        *)
+          wl='-Wl,'
+          ;;
+      esac
+      ;;
+    sunos4*)
+      wl='-Qoption ld '
+      ;;
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      wl='-Wl,'
+      ;;
+    sysv4*MP*)
+      ;;
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      wl='-Wl,'
+      ;;
+    unicos*)
+      wl='-Wl,'
+      ;;
+    uts4*)
+      ;;
+  esac
+fi
+
+# Code taken from libtool.m4's _LT_LINKER_SHLIBS.
+
+hardcode_libdir_flag_spec=
+hardcode_libdir_separator=
+hardcode_direct=no
+hardcode_minus_L=no
+
+case "$host_os" in
+  cygwin* | mingw* | pw32* | cegcc*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test "$GCC" != yes; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd*)
+    with_gnu_ld=no
+    ;;
+esac
+
+ld_shlibs=yes
+if test "$with_gnu_ld" = yes; then
+  # Set some defaults for GNU ld with shared library support. These
+  # are reset later if shared libraries are not supported. Putting them
+  # here allows them to be overridden if necessary.
+  # Unlike libtool, we use -rpath here, not --rpath, since the documented
+  # option of GNU ld is called -rpath, not --rpath.
+  hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+  case "$host_os" in
+    aix[3-9]*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test "$host_cpu" != ia64; then
+        ld_shlibs=no
+      fi
+      ;;
+    amigaos*)
+      case "$host_cpu" in
+        powerpc)
+          ;;
+        m68k)
+          hardcode_libdir_flag_spec='-L$libdir'
+          hardcode_minus_L=yes
+          ;;
+      esac
+      ;;
+    beos*)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    cygwin* | mingw* | pw32* | cegcc*)
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec='-L$libdir'
+      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    haiku*)
+      ;;
+    interix[3-9]*)
+      hardcode_direct=no
+      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+      ;;
+    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    netbsd*)
+      ;;
+    solaris*)
+      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
+        ld_shlibs=no
+      elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
+          ld_shlibs=no
+          ;;
+        *)
+          if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+            hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
+          else
+            ld_shlibs=no
+          fi
+          ;;
+      esac
+      ;;
+    sunos4*)
+      hardcode_direct=yes
+      ;;
+    *)
+      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+  esac
+  if test "$ld_shlibs" = no; then
+    hardcode_libdir_flag_spec=
+  fi
+else
+  case "$host_os" in
+    aix3*)
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L=yes
+      if test "$GCC" = yes; then
+        # Neither direct hardcoding nor static linking is supported with a
+        # broken collect2.
+        hardcode_direct=unsupported
+      fi
+      ;;
+    aix[4-9]*)
+      if test "$host_cpu" = ia64; then
+        # On IA64, the linker does run time linking by default, so we don't
+        # have to do anything special.
+        aix_use_runtimelinking=no
+      else
+        aix_use_runtimelinking=no
+        # Test if we are trying to use run time linking or normal
+        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+        # need to do runtime linking.
+        case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*)
+          for ld_flag in $LDFLAGS; do
+            if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
+              aix_use_runtimelinking=yes
+              break
+            fi
+          done
+          ;;
+        esac
+      fi
+      hardcode_direct=yes
+      hardcode_libdir_separator=':'
+      if test "$GCC" = yes; then
+        case $host_os in aix4.[012]|aix4.[012].*)
+          collect2name=`${CC} -print-prog-name=collect2`
+          if test -f "$collect2name" && \
+            strings "$collect2name" | grep resolve_lib_name >/dev/null
+          then
+            # We have reworked collect2
+            :
+          else
+            # We have old collect2
+            hardcode_direct=unsupported
+            hardcode_minus_L=yes
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_libdir_separator=
+          fi
+          ;;
+        esac
+      fi
+      # Begin _LT_AC_SYS_LIBPATH_AIX.
+      echo 'int main () { return 0; }' > conftest.c
+      ${CC} ${LDFLAGS} conftest.c -o conftest
+      aix_libpath=`dump -H conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+      if test -z "$aix_libpath"; then
+        aix_libpath=`dump -HX64 conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0  *\(.*\)$/\1/; p; }
+}'`
+      fi
+      if test -z "$aix_libpath"; then
+        aix_libpath="/usr/lib:/lib"
+      fi
+      rm -f conftest.c conftest
+      # End _LT_AC_SYS_LIBPATH_AIX.
+      if test "$aix_use_runtimelinking" = yes; then
+        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+      else
+        if test "$host_cpu" = ia64; then
+          hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
+        else
+          hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
+        fi
+      fi
+      ;;
+    amigaos*)
+      case "$host_cpu" in
+        powerpc)
+          ;;
+        m68k)
+          hardcode_libdir_flag_spec='-L$libdir'
+          hardcode_minus_L=yes
+          ;;
+      esac
+      ;;
+    bsdi[45]*)
+      ;;
+    cygwin* | mingw* | pw32* | cegcc*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      hardcode_libdir_flag_spec=' '
+      libext=lib
+      ;;
+    darwin* | rhapsody*)
+      hardcode_direct=no
+      if { case $cc_basename in ifort*) true;; *) test "$GCC" = yes;; esac; }; then
+        :
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    dgux*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      ;;
+    freebsd2.[01]*)
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      ;;
+    freebsd* | dragonfly*)
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      ;;
+    hpux9*)
+      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+      hardcode_libdir_separator=:
+      hardcode_direct=yes
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L=yes
+      ;;
+    hpux10*)
+      if test "$with_gnu_ld" = no; then
+        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+        hardcode_libdir_separator=:
+        hardcode_direct=yes
+        # hardcode_minus_L: Not really in the search PATH,
+        # but as the default location of the library.
+        hardcode_minus_L=yes
+      fi
+      ;;
+    hpux11*)
+      if test "$with_gnu_ld" = no; then
+        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
+        hardcode_libdir_separator=:
+        case $host_cpu in
+          hppa*64*|ia64*)
+            hardcode_direct=no
+            ;;
+          *)
+            hardcode_direct=yes
+            # hardcode_minus_L: Not really in the search PATH,
+            # but as the default location of the library.
+            hardcode_minus_L=yes
+            ;;
+        esac
+      fi
+      ;;
+    irix5* | irix6* | nonstopux*)
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+    netbsd*)
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      ;;
+    newsos6)
+      hardcode_direct=yes
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+    *nto* | *qnx*)
+      ;;
+    openbsd*)
+      if test -f /usr/libexec/ld.so; then
+        hardcode_direct=yes
+        if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
+          hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+        else
+          case "$host_os" in
+            openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
+              hardcode_libdir_flag_spec='-R$libdir'
+              ;;
+            *)
+              hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
+              ;;
+          esac
+        fi
+      else
+        ld_shlibs=no
+      fi
+      ;;
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      ;;
+    osf3*)
+      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      hardcode_libdir_separator=:
+      ;;
+    osf4* | osf5*)
+      if test "$GCC" = yes; then
+        hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
+      else
+        # Both cc and cxx compiler support -rpath directly
+        hardcode_libdir_flag_spec='-rpath $libdir'
+      fi
+      hardcode_libdir_separator=:
+      ;;
+    solaris*)
+      hardcode_libdir_flag_spec='-R$libdir'
+      ;;
+    sunos4*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      ;;
+    sysv4)
+      case $host_vendor in
+        sni)
+          hardcode_direct=yes # is this really true???
+          ;;
+        siemens)
+          hardcode_direct=no
+          ;;
+        motorola)
+          hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+          ;;
+      esac
+      ;;
+    sysv4.3*)
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+        ld_shlibs=yes
+      fi
+      ;;
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
+      ;;
+    sysv5* | sco3.2v5* | sco5v6*)
+      hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
+      hardcode_libdir_separator=':'
+      ;;
+    uts4*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      ;;
+    *)
+      ld_shlibs=no
+      ;;
+  esac
+fi
+
+# Check dynamic linker characteristics
+# Code taken from libtool.m4's _LT_SYS_DYNAMIC_LINKER.
+# Unlike libtool.m4, here we don't care about _all_ names of the library, but
+# only about the one the linker finds when passed -lNAME. This is the last
+# element of library_names_spec in libtool.m4, or possibly two of them if the
+# linker has special search rules.
+library_names_spec=      # the last element of library_names_spec in libtool.m4
+libname_spec='lib$name'
+case "$host_os" in
+  aix3*)
+    library_names_spec='$libname.a'
+    ;;
+  aix[4-9]*)
+    library_names_spec='$libname$shrext'
+    ;;
+  amigaos*)
+    case "$host_cpu" in
+      powerpc*)
+        library_names_spec='$libname$shrext' ;;
+      m68k)
+        library_names_spec='$libname.a' ;;
+    esac
+    ;;
+  beos*)
+    library_names_spec='$libname$shrext'
+    ;;
+  bsdi[45]*)
+    library_names_spec='$libname$shrext'
+    ;;
+  cygwin* | mingw* | pw32* | cegcc*)
+    shrext=.dll
+    library_names_spec='$libname.dll.a $libname.lib'
+    ;;
+  darwin* | rhapsody*)
+    shrext=.dylib
+    library_names_spec='$libname$shrext'
+    ;;
+  dgux*)
+    library_names_spec='$libname$shrext'
+    ;;
+  freebsd[23].*)
+    library_names_spec='$libname$shrext$versuffix'
+    ;;
+  freebsd* | dragonfly*)
+    library_names_spec='$libname$shrext'
+    ;;
+  gnu*)
+    library_names_spec='$libname$shrext'
+    ;;
+  haiku*)
+    library_names_spec='$libname$shrext'
+    ;;
+  hpux9* | hpux10* | hpux11*)
+    case $host_cpu in
+      ia64*)
+        shrext=.so
+        ;;
+      hppa*64*)
+        shrext=.sl
+        ;;
+      *)
+        shrext=.sl
+        ;;
+    esac
+    library_names_spec='$libname$shrext'
+    ;;
+  interix[3-9]*)
+    library_names_spec='$libname$shrext'
+    ;;
+  irix5* | irix6* | nonstopux*)
+    library_names_spec='$libname$shrext'
+    case "$host_os" in
+      irix5* | nonstopux*)
+        libsuff= shlibsuff=
+        ;;
+      *)
+        case $LD in
+          *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= ;;
+          *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 ;;
+          *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 ;;
+          *) libsuff= shlibsuff= ;;
+        esac
+        ;;
+    esac
+    ;;
+  linux*oldld* | linux*aout* | linux*coff*)
+    ;;
+  linux* | k*bsd*-gnu | kopensolaris*-gnu)
+    library_names_spec='$libname$shrext'
+    ;;
+  knetbsd*-gnu)
+    library_names_spec='$libname$shrext'
+    ;;
+  netbsd*)
+    library_names_spec='$libname$shrext'
+    ;;
+  newsos6)
+    library_names_spec='$libname$shrext'
+    ;;
+  *nto* | *qnx*)
+    library_names_spec='$libname$shrext'
+    ;;
+  openbsd*)
+    library_names_spec='$libname$shrext$versuffix'
+    ;;
+  os2*)
+    libname_spec='$name'
+    shrext=.dll
+    library_names_spec='$libname.a'
+    ;;
+  osf3* | osf4* | osf5*)
+    library_names_spec='$libname$shrext'
+    ;;
+  rdos*)
+    ;;
+  solaris*)
+    library_names_spec='$libname$shrext'
+    ;;
+  sunos4*)
+    library_names_spec='$libname$shrext$versuffix'
+    ;;
+  sysv4 | sysv4.3*)
+    library_names_spec='$libname$shrext'
+    ;;
+  sysv4*MP*)
+    library_names_spec='$libname$shrext'
+    ;;
+  sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+    library_names_spec='$libname$shrext'
+    ;;
+  tpf*)
+    library_names_spec='$libname$shrext'
+    ;;
+  uts4*)
+    library_names_spec='$libname$shrext'
+    ;;
+esac
+
+sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
+escaped_wl=`echo "X$wl" | sed -e 's/^X//' -e "$sed_quote_subst"`
+shlibext=`echo "$shrext" | sed -e 's,^\.,,'`
+escaped_libname_spec=`echo "X$libname_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
+escaped_library_names_spec=`echo "X$library_names_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
+escaped_hardcode_libdir_flag_spec=`echo "X$hardcode_libdir_flag_spec" | sed -e 's/^X//' -e "$sed_quote_subst"`
+
+LC_ALL=C sed -e 's/^\([a-zA-Z0-9_]*\)=/acl_cv_\1=/' <<EOF
+
+# How to pass a linker flag through the compiler.
+wl="$escaped_wl"
+
+# Static library suffix (normally "a").
+libext="$libext"
+
+# Shared library suffix (normally "so").
+shlibext="$shlibext"
+
+# Format of library name prefix.
+libname_spec="$escaped_libname_spec"
+
+# Library names that the linker finds when passed -lNAME.
+library_names_spec="$escaped_library_names_spec"
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist.
+hardcode_libdir_flag_spec="$escaped_hardcode_libdir_flag_spec"
+
+# Whether we need a single -rpath flag with a separated argument.
+hardcode_libdir_separator="$hardcode_libdir_separator"
+
+# Set to yes if using DIR/libNAME.so during linking hardcodes DIR into the
+# resulting binary.
+hardcode_direct="$hardcode_direct"
+
+# Set to yes if using the -LDIR flag during linking hardcodes DIR into the
+# resulting binary.
+hardcode_minus_L="$hardcode_minus_L"
+
+EOF
@@ -0,0 +1,127 @@
+AC_INIT(fuse, 2.9.7)
+
+AC_PREREQ(2.59d)
+AC_CONFIG_MACRO_DIR([m4])
+AC_CANONICAL_TARGET
+AM_INIT_AUTOMAKE([foreign])
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES(yes)])
+AC_CONFIG_HEADERS(include/config.h)
+
+AC_PROG_LIBTOOL
+AC_PROG_CC
+AC_PROG_MKDIR_P
+AM_PROG_CC_C_O
+
+case $target_os in
+     *linux*)	arch=linux;;
+     *netbsd*)  arch=netbsd;;
+     *bsd*)	arch=bsd;;
+     *)		arch=unknown;;
+esac
+
+if test "$ac_env_CFLAGS_set" != set; then
+	CFLAGS="-Wall -W -Wno-sign-compare -Wstrict-prototypes -Wmissing-declarations -Wwrite-strings -g -O2 -fno-strict-aliasing"
+fi
+
+AC_ARG_ENABLE(lib,
+	[  --enable-lib            Compile with library ])
+AC_ARG_ENABLE(util,
+	[  --enable-util           Compile with util ])
+AC_ARG_ENABLE(example,
+	[  --enable-example        Compile with examples ])
+AC_ARG_ENABLE(mtab,
+	[  --disable-mtab          Disable and ignore usage of /etc/mtab ])
+
+AC_ARG_WITH(pkgconfigdir,
+            [  --with-pkgconfigdir=DIR      pkgconfig file in DIR @<:@LIBDIR/pkgconfig@:>@],
+            [pkgconfigdir=$withval],
+            [pkgconfigdir='${libdir}/pkgconfig'])
+AC_SUBST(pkgconfigdir)
+
+subdirs2="include"
+
+if test "$enable_lib" != "no"; then
+	subdirs2="$subdirs2 lib";
+fi
+if test "$arch" = linux -a "$enable_util" != "no"; then
+	subdirs2="$subdirs2 util";
+fi
+if test "$enable_example" != "no"; then
+	subdirs2="$subdirs2 example";
+fi
+if test "$enable_mtab" = "no"; then
+	AC_DEFINE(IGNORE_MTAB, 1, [Don't update /etc/mtab])
+fi
+
+AC_CHECK_FUNCS([fork setxattr fdatasync splice vmsplice utimensat])
+AC_CHECK_FUNCS([posix_fallocate])
+AC_CHECK_MEMBERS([struct stat.st_atim])
+AC_CHECK_MEMBERS([struct stat.st_atimespec])
+
+LIBS=
+AC_SEARCH_LIBS(dlopen, [dl])
+AC_SEARCH_LIBS(clock_gettime, [rt])
+libfuse_libs=$LIBS
+LIBS=
+AC_ARG_WITH([libiconv-prefix],
+[  --with-libiconv-prefix=DIR  search for libiconv in DIR/include and DIR/lib], [
+    for dir in `echo "$withval" | tr : ' '`; do
+      if test -d $dir/include; then CPPFLAGS="$CPPFLAGS -I$dir/include"; fi
+      if test -d $dir/lib; then LDFLAGS="$LDFLAGS -L$dir/lib"; fi
+    done
+   ])
+AM_ICONV
+libfuse_libs="$libfuse_libs $LTLIBICONV"
+AM_CONDITIONAL(ICONV, test "$am_cv_func_iconv" = yes)
+AC_SUBST(libfuse_libs)
+
+if test -z "$MOUNT_FUSE_PATH"; then
+	MOUNT_FUSE_PATH=/sbin
+	AC_MSG_NOTICE([MOUNT_FUSE_PATH env var not set, using default $MOUNT_FUSE_PATH])
+fi
+AC_SUBST(MOUNT_FUSE_PATH)
+if test -z "$UDEV_RULES_PATH"; then
+	UDEV_RULES_PATH=/etc/udev/rules.d
+	AC_MSG_NOTICE([UDEV_RULES_PATH env var not set, using default $UDEV_RULES_PATH])
+fi
+AC_SUBST(UDEV_RULES_PATH)
+if test -z "$INIT_D_PATH"; then
+	INIT_D_PATH=/etc/init.d
+	AC_MSG_NOTICE([INIT_D_PATH env var not set, using default $INIT_D_PATH])
+fi
+AC_SUBST(INIT_D_PATH)
+
+AC_SUBST(subdirs2)
+
+AM_CONDITIONAL(LINUX, test "$arch" = linux)
+AM_CONDITIONAL(NETBSD, test "$arch" = netbsd)
+AM_CONDITIONAL(BSD, test "$arch" = bsd)
+
+util_linux_ok=yes
+if test "$arch" = linux -a "$cross_compiling" != "yes"; then
+	AC_MSG_CHECKING([if umount supports --fake --no-canonicalize])
+	# exit code of umount is 1 if option is unrecognised, 2 otherwise
+	umount --fake --no-canonicalize > /dev/null 2>&1
+	if test $? != 1; then
+		AC_MSG_RESULT([yes])
+	else
+		firstline=`umount --fake --no-canonicalize 2>&1 | head -1`
+		if test "$firstline" = 'umount: only root can use "--fake" option'; then
+			AC_MSG_RESULT([yes])
+		else
+			AC_MSG_RESULT([$firstline])
+			util_linux_ok=no
+		fi
+	fi
+fi
+
+AC_CONFIG_FILES([fuse.pc Makefile lib/Makefile util/Makefile example/Makefile include/Makefile doc/Makefile])
+AC_OUTPUT
+
+if test "$util_linux_ok" = no; then
+	AC_MSG_WARN([
+******************************************************************
+* Please install util-linux version 2.18 or later which supports *
+* --fake and --no-canonicalize options in mount and umount       *
+******************************************************************])
+fi
@@ -0,0 +1,5 @@
+## Process this file with automake to produce Makefile.in
+
+dist_man_MANS = fusermount.1 mount.fuse.8 ulockmgr_server.1
+
+EXTRA_DIST = how-fuse-works kernel.txt Doxyfile html
@@ -0,0 +1,39 @@
+.TH FUSERMOUNT 1 2011\-10\-23 2.8.6 "Filesystem in Userspace (FUSE)"
+
+.SH NAME
+\fBfusermount\fR \- mount and unmount FUSE filesystems
+
+.SH SYNOPSIS
+\fBfusermount\fR [\fIOPTIONS\fR] \fIMOUNTPOINT\fR
+
+.SH DESCRIPTION
+Filesystem in Userspace (FUSE) is a simple interface for userspace programs to export a virtual filesystem to the Linux kernel. It also aims to provide a secure method for non privileged users to create and mount their own filesystem implementations.
+.PP
+\fBfusermount\fR is a program to mount and unmount FUSE filesystems.
+
+.SH OPTIONS
+.IP "\-h" 4
+print help.
+.IP "\-V" 4
+print version.
+.IP "-o \fIOPTION\fR[,\fIOPTION\fR...]" 4
+mount options.
+.IP "-u" 4
+unmount.
+.IP "-q" 4
+quiet.
+.IP "-z" 4
+lazy unmount.
+
+.SH SEE ALSO
+\fImount\fR(8),
+\fImount.fuse\fR(8),
+\fIulockmgr_server\fR(1).
+
+.SH HOMEPAGE
+More information about fusermount and the FUSE project can be found at <\fIhttp://fuse.sourceforge.net/\fR>.
+
+.SH AUTHOR
+FUSE was written by Miklos Szeredi <\fImiklos@szeredi.hu\fR>.
+.PP
+This manual page was written by Daniel Baumann <\fIdaniel.baumann@progress\-technologies.net\fR>.
@@ -0,0 +1,54 @@
+                           How Fuse-1.3 Works
+
+[Written by Terje Oseberg]
+
+1. The fuse library.
+
+When your user mode program calls fuse_main() (lib/helper.c),
+fuse_main() parses the arguments passed to your user mode program,
+then calls fuse_mount() (lib/mount.c).
+
+fuse_mount() creates a UNIX domain socket pair, then forks and execs
+fusermount (util/fusermount.c) passing it one end of the socket in the
+FUSE_COMMFD_ENV environment variable.
+
+fusermount (util/fusermount.c) makes sure that the fuse module is
+loaded. fusermount then open /dev/fuse and send the file handle over a
+UNIX domain socket back to fuse_mount().
+
+fuse_mount() returns the filehandle for /dev/fuse to fuse_main().
+
+fuse_main() calls fuse_new() (lib/fuse.c) which allocates the struct
+fuse datastructure that stores and maintains a cached image of the
+filesystem data.
+
+Lastly, fuse_main() calls either fuse_loop() (lib/fuse.c) or
+fuse_loop_mt() (lib/fuse_mt.c) which both start to read the filesystem
+system calls from the /dev/fuse, call the usermode functions
+stored in struct fuse_operations datastructure before calling
+fuse_main(). The results of those calls are then written back to the
+/dev/fuse file where they can be forwarded back to the system
+calls.
+
+2. The kernel module.
+
+The kernel module consists of two parts. First the proc filesystem
+component in kernel/dev.c -and second the filesystem system calls
+kernel/file.c, kernel/inode.c, and kernel/dir.c
+
+All the system calls in kernel/file.c, kernel/inode.c, and
+kernel/dir.c make calls to either request_send(),
+request_send_noreply(), or request_send_nonblock(). Most of the calls
+(all but 2) are to request_send(). request_send() adds the request to,
+"list of requests" structure (fc->pending), then waits for a response.
+request_send_noreply() and request_send_nonblock() are both similar in
+function to request_send() except that one is non-blocking, and the
+other does not respond with a reply.
+
+The proc filesystem component in kernel/dev.c responds to file io
+requests to the file /dev/fuse. fuse_dev_read() handles the
+file reads and returns commands from the "list of requests" structure
+to the calling program. fuse_dev_write() handles file writes and takes
+the data written and places them into the req->out datastructure where
+they can be returned to the system call through the "list of requests"
+structure and request_send().
@@ -0,0 +1,74 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Data Structures</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">Data Structures</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here are the data structures with brief descriptions:</div><div class="directory">
+<table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__args.html" target="_self">fuse_args</a></td><td class="desc"></td></tr>
+<tr id="row_1_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__buf.html" target="_self">fuse_buf</a></td><td class="desc"></td></tr>
+<tr id="row_2_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__bufvec.html" target="_self">fuse_bufvec</a></td><td class="desc"></td></tr>
+<tr id="row_3_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__chan__ops.html" target="_self">fuse_chan_ops</a></td><td class="desc"></td></tr>
+<tr id="row_4_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__conn__info.html" target="_self">fuse_conn_info</a></td><td class="desc"></td></tr>
+<tr id="row_5_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__context.html" target="_self">fuse_context</a></td><td class="desc"></td></tr>
+<tr id="row_6_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__ctx.html" target="_self">fuse_ctx</a></td><td class="desc"></td></tr>
+<tr id="row_7_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__entry__param.html" target="_self">fuse_entry_param</a></td><td class="desc"></td></tr>
+<tr id="row_8_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__file__info.html" target="_self">fuse_file_info</a></td><td class="desc"></td></tr>
+<tr id="row_9_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__lowlevel__ops.html" target="_self">fuse_lowlevel_ops</a></td><td class="desc"></td></tr>
+<tr id="row_10_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__module.html" target="_self">fuse_module</a></td><td class="desc"></td></tr>
+<tr id="row_11_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__operations.html" target="_self">fuse_operations</a></td><td class="desc"></td></tr>
+<tr id="row_12_" class="even"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__opt.html" target="_self">fuse_opt</a></td><td class="desc"></td></tr>
+<tr id="row_13_"><td class="entry"><span style="width:16px;display:inline-block;">&#160;</span><span class="icona"><span class="icon">C</span></span><a class="el" href="structfuse__session__ops.html" target="_self">fuse_session_ops</a></td><td class="desc"></td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,66 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Data Structure Index</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">Data Structure Index</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="qindex"><a class="qindex" href="#letter_F">F</a></div>
+<table style="margin: 10px; white-space: nowrap;" align="center" width="95%" border="0" cellspacing="0" cellpadding="0">
+<tr><td rowspan="2" valign="bottom"><a name="letter_f"></a><table border="0" cellspacing="0" cellpadding="0"><tr><td><div class="ah">&#160;&#160;f&#160;&#160;</div></td></tr></table>
+</td><td valign="top"><a class="el" href="structfuse__bufvec.html">fuse_bufvec</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__ctx.html">fuse_ctx</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__module.html">fuse_module</a>&#160;&#160;&#160;</td><td></td></tr>
+<tr><td valign="top"><a class="el" href="structfuse__chan__ops.html">fuse_chan_ops</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__entry__param.html">fuse_entry_param</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__operations.html">fuse_operations</a>&#160;&#160;&#160;</td><td></td></tr>
+<tr><td valign="top"><a class="el" href="structfuse__args.html">fuse_args</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__conn__info.html">fuse_conn_info</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__file__info.html">fuse_file_info</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__opt.html">fuse_opt</a>&#160;&#160;&#160;</td><td></td></tr>
+<tr><td valign="top"><a class="el" href="structfuse__buf.html">fuse_buf</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__context.html">fuse_context</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__lowlevel__ops.html">fuse_lowlevel_ops</a>&#160;&#160;&#160;</td><td valign="top"><a class="el" href="structfuse__session__ops.html">fuse_session_ops</a>&#160;&#160;&#160;</td><td></td></tr>
+<tr><td></td><td></td><td></td><td></td><td></td></tr>
+</table>
+<div class="qindex"><a class="qindex" href="#letter_F">F</a></div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,60 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: include/old Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+<div id="nav-path" class="navpath">
+  <ul>
+<li class="navelem"><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html">include</a></li><li class="navelem"><a class="el" href="dir_3ccffc210a036acba650f09ebe71329d.html">old</a></li>  </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">old Directory Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:old_2fuse_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>fuse.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,85 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: include Directory Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+<div id="nav-path" class="navpath">
+  <ul>
+<li class="navelem"><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html">include</a></li>  </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">include Directory Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="subdirs"></a>
+Directories</h2></td></tr>
+<tr class="memitem:dir_3ccffc210a036acba650f09ebe71329d"><td class="memItemLeft" align="right" valign="top">directory &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="dir_3ccffc210a036acba650f09ebe71329d.html">old</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="files"></a>
+Files</h2></td></tr>
+<tr class="memitem:config_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>config.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:cuse__lowlevel_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>cuse_lowlevel.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html">fuse.h</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse__common_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html">fuse_common.h</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse__common__compat_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>fuse_common_compat.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse__compat_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>fuse_compat.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse__kernel_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>fuse_kernel.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse__lowlevel_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__lowlevel_8h.html">fuse_lowlevel.h</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse__lowlevel__compat_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>fuse_lowlevel_compat.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:fuse__opt_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html">fuse_opt.h</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ulockmgr_8h"><td class="memItemLeft" align="right" valign="top">file &#160;</td><td class="memItemRight" valign="bottom"><b>ulockmgr.h</b></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,97 @@
+function toggleVisibility(linkObj)
+{
+ var base = $(linkObj).attr('id');
+ var summary = $('#'+base+'-summary');
+ var content = $('#'+base+'-content');
+ var trigger = $('#'+base+'-trigger');
+ var src=$(trigger).attr('src');
+ if (content.is(':visible')===true) {
+   content.hide();
+   summary.show();
+   $(linkObj).addClass('closed').removeClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-8)+'closed.png');
+ } else {
+   content.show();
+   summary.hide();
+   $(linkObj).removeClass('closed').addClass('opened');
+   $(trigger).attr('src',src.substring(0,src.length-10)+'open.png');
+ } 
+ return false;
+}
+
+function updateStripes()
+{
+  $('table.directory tr').
+       removeClass('even').filter(':visible:even').addClass('even');
+}
+
+function toggleLevel(level)
+{
+  $('table.directory tr').each(function() {
+    var l = this.id.split('_').length-1;
+    var i = $('#img'+this.id.substring(3));
+    var a = $('#arr'+this.id.substring(3));
+    if (l<level+1) {
+      i.removeClass('iconfopen iconfclosed').addClass('iconfopen');
+      a.html('&#9660;');
+      $(this).show();
+    } else if (l==level+1) {
+      i.removeClass('iconfclosed iconfopen').addClass('iconfclosed');
+      a.html('&#9658;');
+      $(this).show();
+    } else {
+      $(this).hide();
+    }
+  });
+  updateStripes();
+}
+
+function toggleFolder(id)
+{
+  // the clicked row
+  var currentRow = $('#row_'+id);
+
+  // all rows after the clicked row
+  var rows = currentRow.nextAll("tr");
+
+  var re = new RegExp('^row_'+id+'\\d+_$', "i"); //only one sub
+
+  // only match elements AFTER this one (can't hide elements before)
+  var childRows = rows.filter(function() { return this.id.match(re); });
+
+  // first row is visible we are HIDING
+  if (childRows.filter(':first').is(':visible')===true) {
+    // replace down arrow by right arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    currentRowSpans.filter(".arrow").html('&#9658;');
+    rows.filter("[id^=row_"+id+"]").hide(); // hide all children
+  } else { // we are SHOWING
+    // replace right arrow by down arrow for current row
+    var currentRowSpans = currentRow.find("span");
+    currentRowSpans.filter(".iconfclosed").removeClass("iconfclosed").addClass("iconfopen");
+    currentRowSpans.filter(".arrow").html('&#9660;');
+    // replace down arrows by right arrows for child rows
+    var childRowsSpans = childRows.find("span");
+    childRowsSpans.filter(".iconfopen").removeClass("iconfopen").addClass("iconfclosed");
+    childRowsSpans.filter(".arrow").html('&#9658;');
+    childRows.show(); //show all children
+  }
+  updateStripes();
+}
+
+
+function toggleInherit(id)
+{
+  var rows = $('tr.inherit.'+id);
+  var img = $('tr.inherit_header.'+id+' img');
+  var src = $(img).attr('src');
+  if (rows.filter(':first').is(':visible')===true) {
+    rows.css('display','none');
+    $(img).attr('src',src.substring(0,src.length-8)+'closed.png');
+  } else {
+    rows.css('display','table-row'); // using show() causes jump in firefox
+    $(img).attr('src',src.substring(0,src.length-10)+'open.png');
+  }
+}
+
@@ -0,0 +1,65 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: File List</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li class="current"><a href="files.html"><span>File&#160;List</span></a></li>
+      <li><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">File List</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock">Here is a list of all documented files with brief descriptions:</div><div class="directory">
+<div class="levels">[detail level <span onclick="javascript:toggleLevel(1);">1</span><span onclick="javascript:toggleLevel(2);">2</span>]</div><table class="directory">
+<tr id="row_0_" class="even"><td class="entry"><span style="width:0px;display:inline-block;">&#160;</span><span id="arr_0_" class="arrow" onclick="toggleFolder('0_')">&#9660;</span><span id="img_0_" class="iconfopen" onclick="toggleFolder('0_')">&#160;</span><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html" target="_self">include</a></td><td class="desc"></td></tr>
+<tr id="row_0_0_"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icondoc"></span><a class="el" href="fuse_8h.html" target="_self">fuse.h</a></td><td class="desc"></td></tr>
+<tr id="row_0_1_" class="even"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icondoc"></span><a class="el" href="fuse__common_8h.html" target="_self">fuse_common.h</a></td><td class="desc"></td></tr>
+<tr id="row_0_2_"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icondoc"></span><a class="el" href="fuse__lowlevel_8h.html" target="_self">fuse_lowlevel.h</a></td><td class="desc"></td></tr>
+<tr id="row_0_3_" class="even"><td class="entry"><span style="width:32px;display:inline-block;">&#160;</span><span class="icondoc"></span><a class="el" href="fuse__opt_8h.html" target="_self">fuse_opt.h</a></td><td class="desc"></td></tr>
+</table>
+</div><!-- directory -->
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,519 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Data Fields</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li class="current"><a href="functions.html"><span>All</span></a></li>
+      <li><a href="functions_vars.html"><span>Variables</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow4" class="tabs3">
+    <ul class="tablist">
+      <li><a href="#index_a"><span>a</span></a></li>
+      <li><a href="#index_b"><span>b</span></a></li>
+      <li><a href="#index_c"><span>c</span></a></li>
+      <li><a href="#index_d"><span>d</span></a></li>
+      <li><a href="#index_e"><span>e</span></a></li>
+      <li><a href="#index_f"><span>f</span></a></li>
+      <li><a href="#index_g"><span>g</span></a></li>
+      <li><a href="#index_i"><span>i</span></a></li>
+      <li><a href="#index_k"><span>k</span></a></li>
+      <li><a href="#index_l"><span>l</span></a></li>
+      <li><a href="#index_m"><span>m</span></a></li>
+      <li><a href="#index_n"><span>n</span></a></li>
+      <li><a href="#index_o"><span>o</span></a></li>
+      <li><a href="#index_p"><span>p</span></a></li>
+      <li><a href="#index_r"><span>r</span></a></li>
+      <li><a href="#index_s"><span>s</span></a></li>
+      <li><a href="#index_t"><span>t</span></a></li>
+      <li><a href="#index_u"><span>u</span></a></li>
+      <li><a href="#index_v"><span>v</span></a></li>
+      <li class="current"><a href="#index_w"><span>w</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all documented struct and union fields with links to the struct/union documentation for each field:</div>
+
+<h3><a class="anchor" id="index_a"></a>- a -</h3><ul>
+<li>access
+: <a class="el" href="structfuse__lowlevel__ops.html#abdfcb8249b126f95bc33ba23e78f1916">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a2248db35e200265f7fb9a18348229858">fuse_operations</a>
+</li>
+<li>allocated
+: <a class="el" href="structfuse__args.html#a3fdc7eb5448d89a4ecbabba88cbafe5f">fuse_args</a>
+</li>
+<li>argc
+: <a class="el" href="structfuse__args.html#a501883d1eababa08e05b0c802b31e11d">fuse_args</a>
+</li>
+<li>argv
+: <a class="el" href="structfuse__args.html#a6f90bec2356aff03de79baaca65276b6">fuse_args</a>
+</li>
+<li>async_read
+: <a class="el" href="structfuse__conn__info.html#a25c9b670226641a2ccdb6bd0c74082b6">fuse_conn_info</a>
+</li>
+<li>attr
+: <a class="el" href="structfuse__entry__param.html#adcdee37c96ad18380a47cdbe96a323b9">fuse_entry_param</a>
+</li>
+<li>attr_timeout
+: <a class="el" href="structfuse__entry__param.html#aa797a9f4152cae506ba479af8bbe2eb7">fuse_entry_param</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_b"></a>- b -</h3><ul>
+<li>bmap
+: <a class="el" href="structfuse__lowlevel__ops.html#adb295e706897d7ada3249d8b027fde7b">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ae3f3482e33a0eada0292350d76b82901">fuse_operations</a>
+</li>
+<li>buf
+: <a class="el" href="structfuse__bufvec.html#a754caca61fdf8107d28b510505a033bb">fuse_bufvec</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_c"></a>- c -</h3><ul>
+<li>capable
+: <a class="el" href="structfuse__conn__info.html#a8a1c61f5d7cc14249fb6971165bb958e">fuse_conn_info</a>
+</li>
+<li>chmod
+: <a class="el" href="structfuse__operations.html#a7e75d299efe3a401e8473af7028e5cc5">fuse_operations</a>
+</li>
+<li>chown
+: <a class="el" href="structfuse__operations.html#a40421f8a43e903582c49897894f4692d">fuse_operations</a>
+</li>
+<li>congestion_threshold
+: <a class="el" href="structfuse__conn__info.html#a2ce707ca8bfd6f6669557db7f37bb1ad">fuse_conn_info</a>
+</li>
+<li>count
+: <a class="el" href="structfuse__bufvec.html#ac303661a9c39ade1feeb05d8238b4ed6">fuse_bufvec</a>
+</li>
+<li>create
+: <a class="el" href="structfuse__lowlevel__ops.html#a226ce8b472150dd91977cb6c191ff792">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a97243e0f9268a96236bc3b6f2bacee17">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_d"></a>- d -</h3><ul>
+<li>destroy
+: <a class="el" href="structfuse__chan__ops.html#a5df2257938552c436142f1c790667f74">fuse_chan_ops</a>
+, <a class="el" href="structfuse__lowlevel__ops.html#a963181c33f58859fd060b0ccde2f5ec3">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ac41d37ab860204fe4bd7612f9fb036c5">fuse_operations</a>
+, <a class="el" href="structfuse__session__ops.html#afee317cbaa077d50fd19245924ddfff3">fuse_session_ops</a>
+</li>
+<li>direct_io
+: <a class="el" href="structfuse__file__info.html#a03b59a10e62963d9affa34ad78bd144a">fuse_file_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_e"></a>- e -</h3><ul>
+<li>entry_timeout
+: <a class="el" href="structfuse__entry__param.html#a281b39b72e7ec574ba40d7341fd22c1d">fuse_entry_param</a>
+</li>
+<li>exit
+: <a class="el" href="structfuse__session__ops.html#aeb6548d5e59314ae6c83b905993710e3">fuse_session_ops</a>
+</li>
+<li>exited
+: <a class="el" href="structfuse__session__ops.html#a6307bc12276d867dcb06ade8744cf02b">fuse_session_ops</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_f"></a>- f -</h3><ul>
+<li>factory
+: <a class="el" href="structfuse__module.html#a433d1857217f025aaf561fb95ffadae5">fuse_module</a>
+</li>
+<li>fallocate
+: <a class="el" href="structfuse__lowlevel__ops.html#a5d0ddef3583d645ccf957bdef9291047">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a4fa8203e4bfa71d62c15deb5dffe4867">fuse_operations</a>
+</li>
+<li>fd
+: <a class="el" href="structfuse__buf.html#a62b2ae82904ac4355142984b9dd90d68">fuse_buf</a>
+</li>
+<li>fgetattr
+: <a class="el" href="structfuse__operations.html#a573d79862df591c98e1685225a4cd3a5">fuse_operations</a>
+</li>
+<li>fh
+: <a class="el" href="structfuse__file__info.html#a45314d0b92a8d4c9de33d996aa59ada8">fuse_file_info</a>
+</li>
+<li>fh_old
+: <a class="el" href="structfuse__file__info.html#a62d0083192d16484ac3136af3710cc11">fuse_file_info</a>
+</li>
+<li>flag_nopath
+: <a class="el" href="structfuse__operations.html#abd0d90b9b500f6607f9aad9ae07784d8">fuse_operations</a>
+</li>
+<li>flag_nullpath_ok
+: <a class="el" href="structfuse__operations.html#acf5f08abeb39ab627fe1043d9a67cc09">fuse_operations</a>
+</li>
+<li>flag_reserved
+: <a class="el" href="structfuse__operations.html#ab54bb9753d457ceff8240f67b1b6b72d">fuse_operations</a>
+</li>
+<li>flag_utime_omit_ok
+: <a class="el" href="structfuse__operations.html#a0ca87db7234e774e39de7b323e03455d">fuse_operations</a>
+</li>
+<li>flags
+: <a class="el" href="structfuse__buf.html#a1928e204554f2d37cb8dac28a8a2f28c">fuse_buf</a>
+, <a class="el" href="structfuse__file__info.html#ae7d31802727be19670193a411647bca5">fuse_file_info</a>
+</li>
+<li>flock
+: <a class="el" href="structfuse__lowlevel__ops.html#a01b103e34d751d0456add93d9c34e711">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ad5968d566dab370974043fcf4271eb25">fuse_operations</a>
+</li>
+<li>flush
+: <a class="el" href="structfuse__file__info.html#a9c1571cb4b6be75827f48aac5891606c">fuse_file_info</a>
+, <a class="el" href="structfuse__lowlevel__ops.html#af6c2540969d60626f1c18e0012de393a">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ad4ec9c309072a92dd82ddb20efa4ab14">fuse_operations</a>
+</li>
+<li>forget
+: <a class="el" href="structfuse__lowlevel__ops.html#a5a9112cb58497e68b7b197951c059d1e">fuse_lowlevel_ops</a>
+</li>
+<li>forget_multi
+: <a class="el" href="structfuse__lowlevel__ops.html#a17808183820bb58dcc17db639511a2cb">fuse_lowlevel_ops</a>
+</li>
+<li>fsync
+: <a class="el" href="structfuse__lowlevel__ops.html#a81ff5a93a2edd71b063c2e827e0fd8d8">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a92bdd6f43ba390a54ac360541c56b528">fuse_operations</a>
+</li>
+<li>fsyncdir
+: <a class="el" href="structfuse__lowlevel__ops.html#ab2e3a9ad8b264daec4c254f5b064dfb3">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#aba5cc1fe9a63ec152ceb19656f243256">fuse_operations</a>
+</li>
+<li>ftruncate
+: <a class="el" href="structfuse__operations.html#a1e492882859740f13cbf3344cf963c70">fuse_operations</a>
+</li>
+<li>fuse
+: <a class="el" href="structfuse__context.html#a8872cbd7e8d0269fb5cbd1ed40e60a19">fuse_context</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_g"></a>- g -</h3><ul>
+<li>generation
+: <a class="el" href="structfuse__entry__param.html#a6481786ffc9fcf968df41953d3f0bf98">fuse_entry_param</a>
+</li>
+<li>getattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a994c316fa7a1ca33525a4540675f6b47">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a7a4c5d8eaf7179d819618c0cf3f73724">fuse_operations</a>
+</li>
+<li>getlk
+: <a class="el" href="structfuse__lowlevel__ops.html#a709d41ca0cde37dbd4d4d06c89f6906a">fuse_lowlevel_ops</a>
+</li>
+<li>getxattr
+: <a class="el" href="structfuse__lowlevel__ops.html#aaed65c2801391c35ad0c60e73a0c43d9">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ae21503c64fe2990c8a599f5ba339a8f2">fuse_operations</a>
+</li>
+<li>gid
+: <a class="el" href="structfuse__context.html#ab131a0e5df17a04126ba88b7614a5cf8">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#a923348304ee26adb3a43c31a4bac9583">fuse_ctx</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_i"></a>- i -</h3><ul>
+<li>idx
+: <a class="el" href="structfuse__bufvec.html#a41cc18cb303ee16d20b3ae1ebb0ef830">fuse_bufvec</a>
+</li>
+<li>init
+: <a class="el" href="structfuse__lowlevel__ops.html#ab6fa0b9edb5b002cd1502c969c887329">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#adc6dc71274f185de72217e38d62142c4">fuse_operations</a>
+</li>
+<li>ino
+: <a class="el" href="structfuse__entry__param.html#a285ba89754871772d940fa4fb736bce3">fuse_entry_param</a>
+</li>
+<li>ioctl
+: <a class="el" href="structfuse__lowlevel__ops.html#a399da4f164985be5f5b93ef5b33551da">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a37f0612d67a6b76bf10fe6a71b0e3b5b">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_k"></a>- k -</h3><ul>
+<li>keep_cache
+: <a class="el" href="structfuse__file__info.html#a23a64eaecbf83f99aba8ee79e6de2780">fuse_file_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_l"></a>- l -</h3><ul>
+<li>link
+: <a class="el" href="structfuse__lowlevel__ops.html#a406798b81f44a8b54f188455c31b9be8">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a1b234c43e826c6a690d80ea895a17f61">fuse_operations</a>
+</li>
+<li>listxattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a0f084e779f3fbd407bb5d0890bf0ef6b">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ab4a9c361ce48406f07d5a08ab03f5de8">fuse_operations</a>
+</li>
+<li>lock
+: <a class="el" href="structfuse__operations.html#a1c3fff5cf0c1c2003d117e764b9a76fd">fuse_operations</a>
+</li>
+<li>lock_owner
+: <a class="el" href="structfuse__file__info.html#a3575f36b21f406c211c41c8c31323688">fuse_file_info</a>
+</li>
+<li>lookup
+: <a class="el" href="structfuse__lowlevel__ops.html#ae8a2850c71bec355ad347413fa73f7c2">fuse_lowlevel_ops</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_m"></a>- m -</h3><ul>
+<li>max_background
+: <a class="el" href="structfuse__conn__info.html#a5f9e695735727343448ae1e1a86dfa03">fuse_conn_info</a>
+</li>
+<li>max_readahead
+: <a class="el" href="structfuse__conn__info.html#acb560435478ca7bfb3dbf7df4c0f2dfe">fuse_conn_info</a>
+</li>
+<li>max_write
+: <a class="el" href="structfuse__conn__info.html#ad5009eace718861580e1260d241432d9">fuse_conn_info</a>
+</li>
+<li>mem
+: <a class="el" href="structfuse__buf.html#a537f80b7703cbfc860dfaf4b86de79ae">fuse_buf</a>
+</li>
+<li>mkdir
+: <a class="el" href="structfuse__lowlevel__ops.html#a23af0f6683447112848d9f1731e021d7">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a0a38aa6ca60e945772d5d21b0c1c8916">fuse_operations</a>
+</li>
+<li>mknod
+: <a class="el" href="structfuse__lowlevel__ops.html#a5cd44aa96291fa366d4ef40e2d1d1d76">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a1465eb2268cec2bb5ed11cb09bbda42f">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_n"></a>- n -</h3><ul>
+<li>name
+: <a class="el" href="structfuse__module.html#abc7b2bc3480bbb94a4eb9c1d910a0385">fuse_module</a>
+</li>
+<li>nonseekable
+: <a class="el" href="structfuse__file__info.html#a272022c57a6a79dd8f98ef597786e154">fuse_file_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_o"></a>- o -</h3><ul>
+<li>off
+: <a class="el" href="structfuse__bufvec.html#a0fbb583168d52562f0f848562ecf63bc">fuse_bufvec</a>
+</li>
+<li>offset
+: <a class="el" href="structfuse__opt.html#a333dcd849a3bd54df06084a69b5a8d39">fuse_opt</a>
+</li>
+<li>open
+: <a class="el" href="structfuse__lowlevel__ops.html#aab2f5186ecaa817e75ed443165288218">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">fuse_operations</a>
+</li>
+<li>opendir
+: <a class="el" href="structfuse__lowlevel__ops.html#a57a2c2d826fe11dd005d3275c3028d5e">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a1813889bc5e6e0087a936b7abe8b923f">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_p"></a>- p -</h3><ul>
+<li>padding
+: <a class="el" href="structfuse__file__info.html#ac320b22a715b226cc175d622307150e3">fuse_file_info</a>
+</li>
+<li>pid
+: <a class="el" href="structfuse__context.html#a79fb9aba1169e9a1cdbc6377ae1b3a6a">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#a056667c9ce324cb56b833e981aef8b5b">fuse_ctx</a>
+</li>
+<li>poll
+: <a class="el" href="structfuse__lowlevel__ops.html#a50abf8a54b6c73a5a40123b6cf63c71e">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a2c02838d30391c09dd5213edc61e106a">fuse_operations</a>
+</li>
+<li>pos
+: <a class="el" href="structfuse__buf.html#a8de23b7869b06b9a9caef6beb7c9e88e">fuse_buf</a>
+</li>
+<li>private_data
+: <a class="el" href="structfuse__context.html#a198911619cb8ee1a0b11302b94b6027e">fuse_context</a>
+</li>
+<li>process
+: <a class="el" href="structfuse__session__ops.html#a8ed15bc86f9e32444cd0b80d605f227f">fuse_session_ops</a>
+</li>
+<li>proto_major
+: <a class="el" href="structfuse__conn__info.html#a69c606abe81d16214d14ab58bad60062">fuse_conn_info</a>
+</li>
+<li>proto_minor
+: <a class="el" href="structfuse__conn__info.html#a7a99196bc17f9b91622f6c1353da5f85">fuse_conn_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_r"></a>- r -</h3><ul>
+<li>read
+: <a class="el" href="structfuse__lowlevel__ops.html#ab7b740dccdc6ddc388cdcd7897e4c2e3">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a2a1c6b4ce1845de56863f8b7939501b5">fuse_operations</a>
+</li>
+<li>read_buf
+: <a class="el" href="structfuse__operations.html#a1ecbe844d937ffbbe135958bcb28a719">fuse_operations</a>
+</li>
+<li>readdir
+: <a class="el" href="structfuse__lowlevel__ops.html#af1ef8e59e0cb0b02dc0e406898aeaa51">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a0f634deda31d1e1c42664585ae820076">fuse_operations</a>
+</li>
+<li>readlink
+: <a class="el" href="structfuse__lowlevel__ops.html#ae1032649069ae28d46bde76a40743fcf">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ab4ce6e6d69dfde3ec550f22d932c5633">fuse_operations</a>
+</li>
+<li>receive
+: <a class="el" href="structfuse__chan__ops.html#a622c80d319253941c6f71963261bff39">fuse_chan_ops</a>
+</li>
+<li>release
+: <a class="el" href="structfuse__lowlevel__ops.html#abc49c6310cd0eaddf116988426ca21d2">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#abac8718cdfc1ee273a44831a27393419">fuse_operations</a>
+</li>
+<li>releasedir
+: <a class="el" href="structfuse__lowlevel__ops.html#abfc54ffe5fa5778fc273a6666494d802">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a729e53d36acc05a7a8985a1a3bbfac1e">fuse_operations</a>
+</li>
+<li>removexattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a15be6632986e6be8660071e1d71ffe51">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a5e54de801a0e0d7019e4579112ecc477">fuse_operations</a>
+</li>
+<li>rename
+: <a class="el" href="structfuse__lowlevel__ops.html#aff3670fecb2b4bf45543c191c9d70c02">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#aa777cbddc91887b117ac414e9a2d3cb5">fuse_operations</a>
+</li>
+<li>reserved
+: <a class="el" href="structfuse__conn__info.html#ac036677ef99574c0faba807b0cfee0de">fuse_conn_info</a>
+</li>
+<li>retrieve_reply
+: <a class="el" href="structfuse__lowlevel__ops.html#a1c1d7ad0c1fb40d7180660e7f3f7f089">fuse_lowlevel_ops</a>
+</li>
+<li>rmdir
+: <a class="el" href="structfuse__lowlevel__ops.html#a3cbf1eaf4366aed47fa5d991ea5ff0d5">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ac59578d18db12f0142ae1ab6e8812d55">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_s"></a>- s -</h3><ul>
+<li>send
+: <a class="el" href="structfuse__chan__ops.html#a5dadbc392d24d80a53c71d50daa0b59c">fuse_chan_ops</a>
+</li>
+<li>setattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a6a95408dd79575df7f6c64e55f1e973b">fuse_lowlevel_ops</a>
+</li>
+<li>setlk
+: <a class="el" href="structfuse__lowlevel__ops.html#af290d78441583d1d6ba02da01904f328">fuse_lowlevel_ops</a>
+</li>
+<li>setxattr
+: <a class="el" href="structfuse__lowlevel__ops.html#ab80c4081204c07a423c3c88b116f3086">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a988ced7091c2821daa208e6c96d8b598">fuse_operations</a>
+</li>
+<li>size
+: <a class="el" href="structfuse__buf.html#afb58c1e18f434d1d4edb784d00e2e13d">fuse_buf</a>
+</li>
+<li>statfs
+: <a class="el" href="structfuse__lowlevel__ops.html#aeea156121a28b519e284451721fb7d25">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a4e765e29122e7b6b533dc99849a52655">fuse_operations</a>
+</li>
+<li>symlink
+: <a class="el" href="structfuse__lowlevel__ops.html#a30455cc58397c5a45434492d93a71af4">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ab86022391e56a8ad3211cf754b5b5ebe">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_t"></a>- t -</h3><ul>
+<li>templ
+: <a class="el" href="structfuse__opt.html#a215255be3ed5c0f6c3e0d5dcc96d7b12">fuse_opt</a>
+</li>
+<li>truncate
+: <a class="el" href="structfuse__operations.html#a8efb50b9cd975ba8c4c450248caff6ed">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_u"></a>- u -</h3><ul>
+<li>uid
+: <a class="el" href="structfuse__context.html#a3b71993170253c519e85736524201bf4">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#abf920c4533df81789fd284aa05ee5771">fuse_ctx</a>
+</li>
+<li>umask
+: <a class="el" href="structfuse__context.html#ac02329c0eacbd034fd0b44b1c0cb2c81">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#aa6932619b51a5bfe4d1362ac4c1d2ce8">fuse_ctx</a>
+</li>
+<li>unlink
+: <a class="el" href="structfuse__lowlevel__ops.html#afb6e186f5cbe806d3838a51c112a97ee">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a8bf63301a9d6e94311fa10480993801e">fuse_operations</a>
+</li>
+<li>utime
+: <a class="el" href="structfuse__operations.html#acb7452acad1002d418409892b6e54c2e">fuse_operations</a>
+</li>
+<li>utimens
+: <a class="el" href="structfuse__operations.html#a79955861cc5eb006954476607ef28944">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_v"></a>- v -</h3><ul>
+<li>value
+: <a class="el" href="structfuse__opt.html#aeb76339e1ce6948ad94bd2d4d5d01e20">fuse_opt</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_w"></a>- w -</h3><ul>
+<li>want
+: <a class="el" href="structfuse__conn__info.html#af45de81548b591f3004353a324e4e04d">fuse_conn_info</a>
+</li>
+<li>write
+: <a class="el" href="structfuse__lowlevel__ops.html#a09cc5c1078cfb909513b5ca27464f53a">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a897d1ece4b8b04c92d97b97b2dbf9768">fuse_operations</a>
+</li>
+<li>write_buf
+: <a class="el" href="structfuse__lowlevel__ops.html#a3b40ed06d1297f244363a8dcd40d44aa">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a89f400083a03ddcc43e47ce126b6761f">fuse_operations</a>
+</li>
+<li>writepage
+: <a class="el" href="structfuse__file__info.html#ac58a8634699eb8ed8d424cd4413dd75b">fuse_file_info</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,519 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Data Fields - Variables</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li><a href="functions.html"><span>All</span></a></li>
+      <li class="current"><a href="functions_vars.html"><span>Variables</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow4" class="tabs3">
+    <ul class="tablist">
+      <li><a href="#index_a"><span>a</span></a></li>
+      <li><a href="#index_b"><span>b</span></a></li>
+      <li><a href="#index_c"><span>c</span></a></li>
+      <li><a href="#index_d"><span>d</span></a></li>
+      <li><a href="#index_e"><span>e</span></a></li>
+      <li><a href="#index_f"><span>f</span></a></li>
+      <li><a href="#index_g"><span>g</span></a></li>
+      <li><a href="#index_i"><span>i</span></a></li>
+      <li><a href="#index_k"><span>k</span></a></li>
+      <li><a href="#index_l"><span>l</span></a></li>
+      <li><a href="#index_m"><span>m</span></a></li>
+      <li><a href="#index_n"><span>n</span></a></li>
+      <li><a href="#index_o"><span>o</span></a></li>
+      <li><a href="#index_p"><span>p</span></a></li>
+      <li><a href="#index_r"><span>r</span></a></li>
+      <li><a href="#index_s"><span>s</span></a></li>
+      <li><a href="#index_t"><span>t</span></a></li>
+      <li><a href="#index_u"><span>u</span></a></li>
+      <li><a href="#index_v"><span>v</span></a></li>
+      <li class="current"><a href="#index_w"><span>w</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+&#160;
+
+<h3><a class="anchor" id="index_a"></a>- a -</h3><ul>
+<li>access
+: <a class="el" href="structfuse__lowlevel__ops.html#abdfcb8249b126f95bc33ba23e78f1916">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a2248db35e200265f7fb9a18348229858">fuse_operations</a>
+</li>
+<li>allocated
+: <a class="el" href="structfuse__args.html#a3fdc7eb5448d89a4ecbabba88cbafe5f">fuse_args</a>
+</li>
+<li>argc
+: <a class="el" href="structfuse__args.html#a501883d1eababa08e05b0c802b31e11d">fuse_args</a>
+</li>
+<li>argv
+: <a class="el" href="structfuse__args.html#a6f90bec2356aff03de79baaca65276b6">fuse_args</a>
+</li>
+<li>async_read
+: <a class="el" href="structfuse__conn__info.html#a25c9b670226641a2ccdb6bd0c74082b6">fuse_conn_info</a>
+</li>
+<li>attr
+: <a class="el" href="structfuse__entry__param.html#adcdee37c96ad18380a47cdbe96a323b9">fuse_entry_param</a>
+</li>
+<li>attr_timeout
+: <a class="el" href="structfuse__entry__param.html#aa797a9f4152cae506ba479af8bbe2eb7">fuse_entry_param</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_b"></a>- b -</h3><ul>
+<li>bmap
+: <a class="el" href="structfuse__lowlevel__ops.html#adb295e706897d7ada3249d8b027fde7b">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ae3f3482e33a0eada0292350d76b82901">fuse_operations</a>
+</li>
+<li>buf
+: <a class="el" href="structfuse__bufvec.html#a754caca61fdf8107d28b510505a033bb">fuse_bufvec</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_c"></a>- c -</h3><ul>
+<li>capable
+: <a class="el" href="structfuse__conn__info.html#a8a1c61f5d7cc14249fb6971165bb958e">fuse_conn_info</a>
+</li>
+<li>chmod
+: <a class="el" href="structfuse__operations.html#a7e75d299efe3a401e8473af7028e5cc5">fuse_operations</a>
+</li>
+<li>chown
+: <a class="el" href="structfuse__operations.html#a40421f8a43e903582c49897894f4692d">fuse_operations</a>
+</li>
+<li>congestion_threshold
+: <a class="el" href="structfuse__conn__info.html#a2ce707ca8bfd6f6669557db7f37bb1ad">fuse_conn_info</a>
+</li>
+<li>count
+: <a class="el" href="structfuse__bufvec.html#ac303661a9c39ade1feeb05d8238b4ed6">fuse_bufvec</a>
+</li>
+<li>create
+: <a class="el" href="structfuse__lowlevel__ops.html#a226ce8b472150dd91977cb6c191ff792">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a97243e0f9268a96236bc3b6f2bacee17">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_d"></a>- d -</h3><ul>
+<li>destroy
+: <a class="el" href="structfuse__chan__ops.html#a5df2257938552c436142f1c790667f74">fuse_chan_ops</a>
+, <a class="el" href="structfuse__lowlevel__ops.html#a963181c33f58859fd060b0ccde2f5ec3">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ac41d37ab860204fe4bd7612f9fb036c5">fuse_operations</a>
+, <a class="el" href="structfuse__session__ops.html#afee317cbaa077d50fd19245924ddfff3">fuse_session_ops</a>
+</li>
+<li>direct_io
+: <a class="el" href="structfuse__file__info.html#a03b59a10e62963d9affa34ad78bd144a">fuse_file_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_e"></a>- e -</h3><ul>
+<li>entry_timeout
+: <a class="el" href="structfuse__entry__param.html#a281b39b72e7ec574ba40d7341fd22c1d">fuse_entry_param</a>
+</li>
+<li>exit
+: <a class="el" href="structfuse__session__ops.html#aeb6548d5e59314ae6c83b905993710e3">fuse_session_ops</a>
+</li>
+<li>exited
+: <a class="el" href="structfuse__session__ops.html#a6307bc12276d867dcb06ade8744cf02b">fuse_session_ops</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_f"></a>- f -</h3><ul>
+<li>factory
+: <a class="el" href="structfuse__module.html#a433d1857217f025aaf561fb95ffadae5">fuse_module</a>
+</li>
+<li>fallocate
+: <a class="el" href="structfuse__lowlevel__ops.html#a5d0ddef3583d645ccf957bdef9291047">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a4fa8203e4bfa71d62c15deb5dffe4867">fuse_operations</a>
+</li>
+<li>fd
+: <a class="el" href="structfuse__buf.html#a62b2ae82904ac4355142984b9dd90d68">fuse_buf</a>
+</li>
+<li>fgetattr
+: <a class="el" href="structfuse__operations.html#a573d79862df591c98e1685225a4cd3a5">fuse_operations</a>
+</li>
+<li>fh
+: <a class="el" href="structfuse__file__info.html#a45314d0b92a8d4c9de33d996aa59ada8">fuse_file_info</a>
+</li>
+<li>fh_old
+: <a class="el" href="structfuse__file__info.html#a62d0083192d16484ac3136af3710cc11">fuse_file_info</a>
+</li>
+<li>flag_nopath
+: <a class="el" href="structfuse__operations.html#abd0d90b9b500f6607f9aad9ae07784d8">fuse_operations</a>
+</li>
+<li>flag_nullpath_ok
+: <a class="el" href="structfuse__operations.html#acf5f08abeb39ab627fe1043d9a67cc09">fuse_operations</a>
+</li>
+<li>flag_reserved
+: <a class="el" href="structfuse__operations.html#ab54bb9753d457ceff8240f67b1b6b72d">fuse_operations</a>
+</li>
+<li>flag_utime_omit_ok
+: <a class="el" href="structfuse__operations.html#a0ca87db7234e774e39de7b323e03455d">fuse_operations</a>
+</li>
+<li>flags
+: <a class="el" href="structfuse__buf.html#a1928e204554f2d37cb8dac28a8a2f28c">fuse_buf</a>
+, <a class="el" href="structfuse__file__info.html#ae7d31802727be19670193a411647bca5">fuse_file_info</a>
+</li>
+<li>flock
+: <a class="el" href="structfuse__lowlevel__ops.html#a01b103e34d751d0456add93d9c34e711">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ad5968d566dab370974043fcf4271eb25">fuse_operations</a>
+</li>
+<li>flush
+: <a class="el" href="structfuse__file__info.html#a9c1571cb4b6be75827f48aac5891606c">fuse_file_info</a>
+, <a class="el" href="structfuse__lowlevel__ops.html#af6c2540969d60626f1c18e0012de393a">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ad4ec9c309072a92dd82ddb20efa4ab14">fuse_operations</a>
+</li>
+<li>forget
+: <a class="el" href="structfuse__lowlevel__ops.html#a5a9112cb58497e68b7b197951c059d1e">fuse_lowlevel_ops</a>
+</li>
+<li>forget_multi
+: <a class="el" href="structfuse__lowlevel__ops.html#a17808183820bb58dcc17db639511a2cb">fuse_lowlevel_ops</a>
+</li>
+<li>fsync
+: <a class="el" href="structfuse__lowlevel__ops.html#a81ff5a93a2edd71b063c2e827e0fd8d8">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a92bdd6f43ba390a54ac360541c56b528">fuse_operations</a>
+</li>
+<li>fsyncdir
+: <a class="el" href="structfuse__lowlevel__ops.html#ab2e3a9ad8b264daec4c254f5b064dfb3">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#aba5cc1fe9a63ec152ceb19656f243256">fuse_operations</a>
+</li>
+<li>ftruncate
+: <a class="el" href="structfuse__operations.html#a1e492882859740f13cbf3344cf963c70">fuse_operations</a>
+</li>
+<li>fuse
+: <a class="el" href="structfuse__context.html#a8872cbd7e8d0269fb5cbd1ed40e60a19">fuse_context</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_g"></a>- g -</h3><ul>
+<li>generation
+: <a class="el" href="structfuse__entry__param.html#a6481786ffc9fcf968df41953d3f0bf98">fuse_entry_param</a>
+</li>
+<li>getattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a994c316fa7a1ca33525a4540675f6b47">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a7a4c5d8eaf7179d819618c0cf3f73724">fuse_operations</a>
+</li>
+<li>getlk
+: <a class="el" href="structfuse__lowlevel__ops.html#a709d41ca0cde37dbd4d4d06c89f6906a">fuse_lowlevel_ops</a>
+</li>
+<li>getxattr
+: <a class="el" href="structfuse__lowlevel__ops.html#aaed65c2801391c35ad0c60e73a0c43d9">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ae21503c64fe2990c8a599f5ba339a8f2">fuse_operations</a>
+</li>
+<li>gid
+: <a class="el" href="structfuse__context.html#ab131a0e5df17a04126ba88b7614a5cf8">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#a923348304ee26adb3a43c31a4bac9583">fuse_ctx</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_i"></a>- i -</h3><ul>
+<li>idx
+: <a class="el" href="structfuse__bufvec.html#a41cc18cb303ee16d20b3ae1ebb0ef830">fuse_bufvec</a>
+</li>
+<li>init
+: <a class="el" href="structfuse__lowlevel__ops.html#ab6fa0b9edb5b002cd1502c969c887329">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#adc6dc71274f185de72217e38d62142c4">fuse_operations</a>
+</li>
+<li>ino
+: <a class="el" href="structfuse__entry__param.html#a285ba89754871772d940fa4fb736bce3">fuse_entry_param</a>
+</li>
+<li>ioctl
+: <a class="el" href="structfuse__lowlevel__ops.html#a399da4f164985be5f5b93ef5b33551da">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a37f0612d67a6b76bf10fe6a71b0e3b5b">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_k"></a>- k -</h3><ul>
+<li>keep_cache
+: <a class="el" href="structfuse__file__info.html#a23a64eaecbf83f99aba8ee79e6de2780">fuse_file_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_l"></a>- l -</h3><ul>
+<li>link
+: <a class="el" href="structfuse__lowlevel__ops.html#a406798b81f44a8b54f188455c31b9be8">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a1b234c43e826c6a690d80ea895a17f61">fuse_operations</a>
+</li>
+<li>listxattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a0f084e779f3fbd407bb5d0890bf0ef6b">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ab4a9c361ce48406f07d5a08ab03f5de8">fuse_operations</a>
+</li>
+<li>lock
+: <a class="el" href="structfuse__operations.html#a1c3fff5cf0c1c2003d117e764b9a76fd">fuse_operations</a>
+</li>
+<li>lock_owner
+: <a class="el" href="structfuse__file__info.html#a3575f36b21f406c211c41c8c31323688">fuse_file_info</a>
+</li>
+<li>lookup
+: <a class="el" href="structfuse__lowlevel__ops.html#ae8a2850c71bec355ad347413fa73f7c2">fuse_lowlevel_ops</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_m"></a>- m -</h3><ul>
+<li>max_background
+: <a class="el" href="structfuse__conn__info.html#a5f9e695735727343448ae1e1a86dfa03">fuse_conn_info</a>
+</li>
+<li>max_readahead
+: <a class="el" href="structfuse__conn__info.html#acb560435478ca7bfb3dbf7df4c0f2dfe">fuse_conn_info</a>
+</li>
+<li>max_write
+: <a class="el" href="structfuse__conn__info.html#ad5009eace718861580e1260d241432d9">fuse_conn_info</a>
+</li>
+<li>mem
+: <a class="el" href="structfuse__buf.html#a537f80b7703cbfc860dfaf4b86de79ae">fuse_buf</a>
+</li>
+<li>mkdir
+: <a class="el" href="structfuse__lowlevel__ops.html#a23af0f6683447112848d9f1731e021d7">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a0a38aa6ca60e945772d5d21b0c1c8916">fuse_operations</a>
+</li>
+<li>mknod
+: <a class="el" href="structfuse__lowlevel__ops.html#a5cd44aa96291fa366d4ef40e2d1d1d76">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a1465eb2268cec2bb5ed11cb09bbda42f">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_n"></a>- n -</h3><ul>
+<li>name
+: <a class="el" href="structfuse__module.html#abc7b2bc3480bbb94a4eb9c1d910a0385">fuse_module</a>
+</li>
+<li>nonseekable
+: <a class="el" href="structfuse__file__info.html#a272022c57a6a79dd8f98ef597786e154">fuse_file_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_o"></a>- o -</h3><ul>
+<li>off
+: <a class="el" href="structfuse__bufvec.html#a0fbb583168d52562f0f848562ecf63bc">fuse_bufvec</a>
+</li>
+<li>offset
+: <a class="el" href="structfuse__opt.html#a333dcd849a3bd54df06084a69b5a8d39">fuse_opt</a>
+</li>
+<li>open
+: <a class="el" href="structfuse__lowlevel__ops.html#aab2f5186ecaa817e75ed443165288218">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">fuse_operations</a>
+</li>
+<li>opendir
+: <a class="el" href="structfuse__lowlevel__ops.html#a57a2c2d826fe11dd005d3275c3028d5e">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a1813889bc5e6e0087a936b7abe8b923f">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_p"></a>- p -</h3><ul>
+<li>padding
+: <a class="el" href="structfuse__file__info.html#ac320b22a715b226cc175d622307150e3">fuse_file_info</a>
+</li>
+<li>pid
+: <a class="el" href="structfuse__context.html#a79fb9aba1169e9a1cdbc6377ae1b3a6a">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#a056667c9ce324cb56b833e981aef8b5b">fuse_ctx</a>
+</li>
+<li>poll
+: <a class="el" href="structfuse__lowlevel__ops.html#a50abf8a54b6c73a5a40123b6cf63c71e">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a2c02838d30391c09dd5213edc61e106a">fuse_operations</a>
+</li>
+<li>pos
+: <a class="el" href="structfuse__buf.html#a8de23b7869b06b9a9caef6beb7c9e88e">fuse_buf</a>
+</li>
+<li>private_data
+: <a class="el" href="structfuse__context.html#a198911619cb8ee1a0b11302b94b6027e">fuse_context</a>
+</li>
+<li>process
+: <a class="el" href="structfuse__session__ops.html#a8ed15bc86f9e32444cd0b80d605f227f">fuse_session_ops</a>
+</li>
+<li>proto_major
+: <a class="el" href="structfuse__conn__info.html#a69c606abe81d16214d14ab58bad60062">fuse_conn_info</a>
+</li>
+<li>proto_minor
+: <a class="el" href="structfuse__conn__info.html#a7a99196bc17f9b91622f6c1353da5f85">fuse_conn_info</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_r"></a>- r -</h3><ul>
+<li>read
+: <a class="el" href="structfuse__lowlevel__ops.html#ab7b740dccdc6ddc388cdcd7897e4c2e3">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a2a1c6b4ce1845de56863f8b7939501b5">fuse_operations</a>
+</li>
+<li>read_buf
+: <a class="el" href="structfuse__operations.html#a1ecbe844d937ffbbe135958bcb28a719">fuse_operations</a>
+</li>
+<li>readdir
+: <a class="el" href="structfuse__lowlevel__ops.html#af1ef8e59e0cb0b02dc0e406898aeaa51">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a0f634deda31d1e1c42664585ae820076">fuse_operations</a>
+</li>
+<li>readlink
+: <a class="el" href="structfuse__lowlevel__ops.html#ae1032649069ae28d46bde76a40743fcf">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ab4ce6e6d69dfde3ec550f22d932c5633">fuse_operations</a>
+</li>
+<li>receive
+: <a class="el" href="structfuse__chan__ops.html#a622c80d319253941c6f71963261bff39">fuse_chan_ops</a>
+</li>
+<li>release
+: <a class="el" href="structfuse__lowlevel__ops.html#abc49c6310cd0eaddf116988426ca21d2">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#abac8718cdfc1ee273a44831a27393419">fuse_operations</a>
+</li>
+<li>releasedir
+: <a class="el" href="structfuse__lowlevel__ops.html#abfc54ffe5fa5778fc273a6666494d802">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a729e53d36acc05a7a8985a1a3bbfac1e">fuse_operations</a>
+</li>
+<li>removexattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a15be6632986e6be8660071e1d71ffe51">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a5e54de801a0e0d7019e4579112ecc477">fuse_operations</a>
+</li>
+<li>rename
+: <a class="el" href="structfuse__lowlevel__ops.html#aff3670fecb2b4bf45543c191c9d70c02">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#aa777cbddc91887b117ac414e9a2d3cb5">fuse_operations</a>
+</li>
+<li>reserved
+: <a class="el" href="structfuse__conn__info.html#ac036677ef99574c0faba807b0cfee0de">fuse_conn_info</a>
+</li>
+<li>retrieve_reply
+: <a class="el" href="structfuse__lowlevel__ops.html#a1c1d7ad0c1fb40d7180660e7f3f7f089">fuse_lowlevel_ops</a>
+</li>
+<li>rmdir
+: <a class="el" href="structfuse__lowlevel__ops.html#a3cbf1eaf4366aed47fa5d991ea5ff0d5">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ac59578d18db12f0142ae1ab6e8812d55">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_s"></a>- s -</h3><ul>
+<li>send
+: <a class="el" href="structfuse__chan__ops.html#a5dadbc392d24d80a53c71d50daa0b59c">fuse_chan_ops</a>
+</li>
+<li>setattr
+: <a class="el" href="structfuse__lowlevel__ops.html#a6a95408dd79575df7f6c64e55f1e973b">fuse_lowlevel_ops</a>
+</li>
+<li>setlk
+: <a class="el" href="structfuse__lowlevel__ops.html#af290d78441583d1d6ba02da01904f328">fuse_lowlevel_ops</a>
+</li>
+<li>setxattr
+: <a class="el" href="structfuse__lowlevel__ops.html#ab80c4081204c07a423c3c88b116f3086">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a988ced7091c2821daa208e6c96d8b598">fuse_operations</a>
+</li>
+<li>size
+: <a class="el" href="structfuse__buf.html#afb58c1e18f434d1d4edb784d00e2e13d">fuse_buf</a>
+</li>
+<li>statfs
+: <a class="el" href="structfuse__lowlevel__ops.html#aeea156121a28b519e284451721fb7d25">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a4e765e29122e7b6b533dc99849a52655">fuse_operations</a>
+</li>
+<li>symlink
+: <a class="el" href="structfuse__lowlevel__ops.html#a30455cc58397c5a45434492d93a71af4">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#ab86022391e56a8ad3211cf754b5b5ebe">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_t"></a>- t -</h3><ul>
+<li>templ
+: <a class="el" href="structfuse__opt.html#a215255be3ed5c0f6c3e0d5dcc96d7b12">fuse_opt</a>
+</li>
+<li>truncate
+: <a class="el" href="structfuse__operations.html#a8efb50b9cd975ba8c4c450248caff6ed">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_u"></a>- u -</h3><ul>
+<li>uid
+: <a class="el" href="structfuse__context.html#a3b71993170253c519e85736524201bf4">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#abf920c4533df81789fd284aa05ee5771">fuse_ctx</a>
+</li>
+<li>umask
+: <a class="el" href="structfuse__context.html#ac02329c0eacbd034fd0b44b1c0cb2c81">fuse_context</a>
+, <a class="el" href="structfuse__ctx.html#aa6932619b51a5bfe4d1362ac4c1d2ce8">fuse_ctx</a>
+</li>
+<li>unlink
+: <a class="el" href="structfuse__lowlevel__ops.html#afb6e186f5cbe806d3838a51c112a97ee">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a8bf63301a9d6e94311fa10480993801e">fuse_operations</a>
+</li>
+<li>utime
+: <a class="el" href="structfuse__operations.html#acb7452acad1002d418409892b6e54c2e">fuse_operations</a>
+</li>
+<li>utimens
+: <a class="el" href="structfuse__operations.html#a79955861cc5eb006954476607ef28944">fuse_operations</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_v"></a>- v -</h3><ul>
+<li>value
+: <a class="el" href="structfuse__opt.html#aeb76339e1ce6948ad94bd2d4d5d01e20">fuse_opt</a>
+</li>
+</ul>
+
+
+<h3><a class="anchor" id="index_w"></a>- w -</h3><ul>
+<li>want
+: <a class="el" href="structfuse__conn__info.html#af45de81548b591f3004353a324e4e04d">fuse_conn_info</a>
+</li>
+<li>write
+: <a class="el" href="structfuse__lowlevel__ops.html#a09cc5c1078cfb909513b5ca27464f53a">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a897d1ece4b8b04c92d97b97b2dbf9768">fuse_operations</a>
+</li>
+<li>write_buf
+: <a class="el" href="structfuse__lowlevel__ops.html#a3b40ed06d1297f244363a8dcd40d44aa">fuse_lowlevel_ops</a>
+, <a class="el" href="structfuse__operations.html#a89f400083a03ddcc43e47ce126b6761f">fuse_operations</a>
+</li>
+<li>writepage
+: <a class="el" href="structfuse__file__info.html#ac58a8634699eb8ed8d424cd4413dd75b">fuse_file_info</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,968 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: include/fuse.h File Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+<div id="nav-path" class="navpath">
+  <ul>
+<li class="navelem"><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html">include</a></li>  </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#nested-classes">Data Structures</a> &#124;
+<a href="#define-members">Macros</a> &#124;
+<a href="#typedef-members">Typedefs</a> &#124;
+<a href="#func-members">Functions</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse.h File Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><code>#include &quot;<a class="el" href="fuse__common_8h.html">fuse_common.h</a>&quot;</code><br />
+<code>#include &lt;fcntl.h&gt;</code><br />
+<code>#include &lt;time.h&gt;</code><br />
+<code>#include &lt;utime.h&gt;</code><br />
+<code>#include &lt;sys/types.h&gt;</code><br />
+<code>#include &lt;sys/stat.h&gt;</code><br />
+<code>#include &lt;sys/statvfs.h&gt;</code><br />
+<code>#include &lt;sys/uio.h&gt;</code><br />
+<code>#include &quot;fuse_compat.h&quot;</code><br />
+</div><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Data Structures</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html">fuse_operations</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__context.html">fuse_context</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__module.html">fuse_module</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
+Macros</h2></td></tr>
+<tr class="memitem:a61755930843c427b79622eda0ad8f083"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a61755930843c427b79622eda0ad8f083">fuse_main</a>(argc, argv, op, user_data)&#160;&#160;&#160;<a class="el" href="fuse_8h.html#a2098b9d60626bf749801d12f2d0d6fd3">fuse_main_real</a>(argc, argv, op, sizeof(*(op)), user_data)</td></tr>
+<tr class="separator:a61755930843c427b79622eda0ad8f083"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:af335784cf29289c7583f3312d98d2bcd"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#af335784cf29289c7583f3312d98d2bcd">FUSE_REGISTER_MODULE</a>(name_, factory_)</td></tr>
+<tr class="separator:af335784cf29289c7583f3312d98d2bcd"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad549ea7a3a1649a8b062843cecd793b6"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#ad549ea7a3a1649a8b062843cecd793b6">fuse_main</a>&#160;&#160;&#160;fuse_main_compat2</td></tr>
+<tr class="separator:ad549ea7a3a1649a8b062843cecd793b6"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
+Typedefs</h2></td></tr>
+<tr class="memitem:ae2a2054f9852fd6020c26a1bcc7f1042"><td class="memItemLeft" align="right" valign="top">typedef int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#ae2a2054f9852fd6020c26a1bcc7f1042">fuse_fill_dir_t</a> )(void *buf, const char *name, const struct stat *stbuf, off_t off)</td></tr>
+<tr class="separator:ae2a2054f9852fd6020c26a1bcc7f1042"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab27948e20743f4c153f6ba6d71ca7182"><td class="memItemLeft" align="right" valign="top">typedef void(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#ab27948e20743f4c153f6ba6d71ca7182">fuse_processor_t</a> )(struct fuse *, struct fuse_cmd *, void *)</td></tr>
+<tr class="separator:ab27948e20743f4c153f6ba6d71ca7182"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:a5326844946defe4a50b3f4320786a0f4"><td class="memItemLeft" align="right" valign="top">struct fuse *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a5326844946defe4a50b3f4320786a0f4">fuse_new</a> (struct fuse_chan *ch, struct <a class="el" href="structfuse__args.html">fuse_args</a> *args, const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *op, size_t op_size, void *user_data)</td></tr>
+<tr class="separator:a5326844946defe4a50b3f4320786a0f4"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a0d47cac8a295efd5370d7af059e4d14f"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a0d47cac8a295efd5370d7af059e4d14f">fuse_destroy</a> (struct fuse *f)</td></tr>
+<tr class="separator:a0d47cac8a295efd5370d7af059e4d14f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a6ea805c47ccc960497dfd64e12081159"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a6ea805c47ccc960497dfd64e12081159">fuse_loop</a> (struct fuse *f)</td></tr>
+<tr class="separator:a6ea805c47ccc960497dfd64e12081159"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a9024935b211288c1869dc7566895d739"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a9024935b211288c1869dc7566895d739">fuse_exit</a> (struct fuse *f)</td></tr>
+<tr class="separator:a9024935b211288c1869dc7566895d739"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a79387240dad1f77417fd178f4b9ef0a0"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a79387240dad1f77417fd178f4b9ef0a0">fuse_loop_mt</a> (struct fuse *f)</td></tr>
+<tr class="separator:a79387240dad1f77417fd178f4b9ef0a0"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a9a0f2a6603cb1e21f5e4c1aec84a3bcc"><td class="memItemLeft" align="right" valign="top">struct <a class="el" href="structfuse__context.html">fuse_context</a> *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a9a0f2a6603cb1e21f5e4c1aec84a3bcc">fuse_get_context</a> (void)</td></tr>
+<tr class="separator:a9a0f2a6603cb1e21f5e4c1aec84a3bcc"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a04273db088e57d8242caa388193b6958"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a04273db088e57d8242caa388193b6958">fuse_getgroups</a> (int size, gid_t list[])</td></tr>
+<tr class="separator:a04273db088e57d8242caa388193b6958"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a0514ca828e6a02a330dcf037292c8803"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a0514ca828e6a02a330dcf037292c8803">fuse_interrupted</a> (void)</td></tr>
+<tr class="separator:a0514ca828e6a02a330dcf037292c8803"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a390d7e520ea2be2471ffa366cbc1f37d"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a390d7e520ea2be2471ffa366cbc1f37d">fuse_invalidate</a> (struct fuse *f, const char *path)</td></tr>
+<tr class="separator:a390d7e520ea2be2471ffa366cbc1f37d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a2098b9d60626bf749801d12f2d0d6fd3"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a2098b9d60626bf749801d12f2d0d6fd3">fuse_main_real</a> (int argc, char *argv[], const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *op, size_t op_size, void *user_data)</td></tr>
+<tr class="separator:a2098b9d60626bf749801d12f2d0d6fd3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a4b2246caec521ec4ac84093f8c4b616d"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a4b2246caec521ec4ac84093f8c4b616d">fuse_start_cleanup_thread</a> (struct fuse *fuse)</td></tr>
+<tr class="separator:a4b2246caec521ec4ac84093f8c4b616d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad37fd69ba40d5c261f16e207e4a5b0ed"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#ad37fd69ba40d5c261f16e207e4a5b0ed">fuse_stop_cleanup_thread</a> (struct fuse *fuse)</td></tr>
+<tr class="separator:ad37fd69ba40d5c261f16e207e4a5b0ed"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a90f104e6d4e01480161a3300bddbecbe"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a90f104e6d4e01480161a3300bddbecbe">fuse_clean_cache</a> (struct fuse *fuse)</td></tr>
+<tr class="separator:a90f104e6d4e01480161a3300bddbecbe"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad4b0e6955b2fd720542c6c3262fb8761"><td class="memItemLeft" align="right" valign="top">struct fuse_fs *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#ad4b0e6955b2fd720542c6c3262fb8761">fuse_fs_new</a> (const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *op, size_t op_size, void *user_data)</td></tr>
+<tr class="separator:ad4b0e6955b2fd720542c6c3262fb8761"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad6380ea6c7cb4a4a4cf421d808ce2b66"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#ad6380ea6c7cb4a4a4cf421d808ce2b66">fuse_register_module</a> (struct <a class="el" href="structfuse__module.html">fuse_module</a> *mod)</td></tr>
+<tr class="separator:ad6380ea6c7cb4a4a4cf421d808ce2b66"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab6dc1548ab6f04f048927dc09882563d"><td class="memItemLeft" align="right" valign="top">struct fuse *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#ab6dc1548ab6f04f048927dc09882563d">fuse_setup</a> (int argc, char *argv[], const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *op, size_t op_size, char **mountpoint, int *multithreaded, void *user_data)</td></tr>
+<tr class="separator:ab6dc1548ab6f04f048927dc09882563d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a87c736a7e6ee86348a9fdf83f6635199"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a87c736a7e6ee86348a9fdf83f6635199">fuse_teardown</a> (struct fuse *fuse, char *mountpoint)</td></tr>
+<tr class="separator:a87c736a7e6ee86348a9fdf83f6635199"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aa5aaa31ed710ea1afe9467f10d523b21"><td class="memItemLeft" align="right" valign="top">struct fuse_cmd *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#aa5aaa31ed710ea1afe9467f10d523b21">fuse_read_cmd</a> (struct fuse *f)</td></tr>
+<tr class="separator:aa5aaa31ed710ea1afe9467f10d523b21"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a638b7477f87a2aca57ef0a5c4ca1d500"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a638b7477f87a2aca57ef0a5c4ca1d500">fuse_process_cmd</a> (struct fuse *f, struct fuse_cmd *cmd)</td></tr>
+<tr class="separator:a638b7477f87a2aca57ef0a5c4ca1d500"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aadced4bb8ad64e622a2d0b9e6738c97b"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#aadced4bb8ad64e622a2d0b9e6738c97b">fuse_loop_mt_proc</a> (struct fuse *f, <a class="el" href="fuse_8h.html#ab27948e20743f4c153f6ba6d71ca7182">fuse_processor_t</a> proc, void *data)</td></tr>
+<tr class="separator:aadced4bb8ad64e622a2d0b9e6738c97b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a3035da06904362a9e924d77c2e460258"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a3035da06904362a9e924d77c2e460258">fuse_exited</a> (struct fuse *f)</td></tr>
+<tr class="separator:a3035da06904362a9e924d77c2e460258"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:adbd6a1fa417b704972554ed983e67b85"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#adbd6a1fa417b704972554ed983e67b85">fuse_set_getcontext_func</a> (struct <a class="el" href="structfuse__context.html">fuse_context</a> *(*func)(void))</td></tr>
+<tr class="separator:adbd6a1fa417b704972554ed983e67b85"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a03baa193b5bfcbe625afbc62e9b97e91"><td class="memItemLeft" align="right" valign="top">struct fuse_session *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse_8h.html#a03baa193b5bfcbe625afbc62e9b97e91">fuse_get_session</a> (struct fuse *f)</td></tr>
+<tr class="separator:a03baa193b5bfcbe625afbc62e9b97e91"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>This file defines the library interface of FUSE</p>
+<p>IMPORTANT: you should define FUSE_USE_VERSION before including this header. To use the newest API define it to 26 (recommended for any new application), to use the old API define it to 21 (default) 22 or 25, to use the even older 1.X API define it to 11. </p>
+</div><h2 class="groupheader">Macro Definition Documentation</h2>
+<a class="anchor" id="a61755930843c427b79622eda0ad8f083"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define fuse_main</td>
+          <td>(</td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">argc, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">argv, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">op, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">user_data&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td>&#160;&#160;&#160;<a class="el" href="fuse_8h.html#a2098b9d60626bf749801d12f2d0d6fd3">fuse_main_real</a>(argc, argv, op, sizeof(*(op)), user_data)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Main function of FUSE.</p>
+<p>This is for the lazy. This is all that has to be called from the main() function.</p>
+<p>This function does the following:</p><ul>
+<li>parses command line options (-d -s and -h)</li>
+<li>passes relevant mount options to the <a class="el" href="fuse__common_8h.html#a30d394a6127b20455bf5a4899e56e759">fuse_mount()</a></li>
+<li>installs signal handlers for INT, HUP, TERM and PIPE</li>
+<li>registers an exit handler to unmount the filesystem on program exit</li>
+<li>creates a fuse handle</li>
+<li>registers the operations</li>
+<li>calls either the single-threaded or the multi-threaded event loop</li>
+</ul>
+<p>Note: this is currently implemented as a macro.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">argc</td><td>the argument counter passed to the main() function </td></tr>
+    <tr><td class="paramname">argv</td><td>the argument vector passed to the main() function </td></tr>
+    <tr><td class="paramname">op</td><td>the file system operation </td></tr>
+    <tr><td class="paramname">user_data</td><td>user data supplied in the context during the init() method </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 on success, nonzero on failure </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="ad549ea7a3a1649a8b062843cecd793b6"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define fuse_main&#160;&#160;&#160;fuse_main_compat2</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Main function of FUSE.</p>
+<p>This is for the lazy. This is all that has to be called from the main() function.</p>
+<p>This function does the following:</p><ul>
+<li>parses command line options (-d -s and -h)</li>
+<li>passes relevant mount options to the <a class="el" href="fuse__common_8h.html#a30d394a6127b20455bf5a4899e56e759">fuse_mount()</a></li>
+<li>installs signal handlers for INT, HUP, TERM and PIPE</li>
+<li>registers an exit handler to unmount the filesystem on program exit</li>
+<li>creates a fuse handle</li>
+<li>registers the operations</li>
+<li>calls either the single-threaded or the multi-threaded event loop</li>
+</ul>
+<p>Note: this is currently implemented as a macro.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">argc</td><td>the argument counter passed to the main() function </td></tr>
+    <tr><td class="paramname">argv</td><td>the argument vector passed to the main() function </td></tr>
+    <tr><td class="paramname">op</td><td>the file system operation </td></tr>
+    <tr><td class="paramname">user_data</td><td>user data supplied in the context during the init() method </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 on success, nonzero on failure </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="af335784cf29289c7583f3312d98d2bcd"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_REGISTER_MODULE</td>
+          <td>(</td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">name_, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">factory_&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<b>Value:</b><div class="fragment"><div class="line"><span class="keyword">static</span> __attribute__((constructor)) void name_ <span class="preprocessor">## _register(void) \</span></div>
+<div class="line"><span class="preprocessor">        {                                                                 \</span></div>
+<div class="line"><span class="preprocessor">                static struct fuse_module mod =                           \</span></div>
+<div class="line"><span class="preprocessor">                        { #name_, factory_, NULL, NULL, 0 };              \</span></div>
+<div class="line"><span class="preprocessor">                fuse_register_module(&amp;mod);                               \</span></div>
+<div class="line"><span class="preprocessor">        }</span></div>
+</div><!-- fragment --><p>Register filesystem module</p>
+<p>For the parameters, see description of the fields in 'struct <a class="el" href="structfuse__module.html">fuse_module</a>' </p>
+
+</div>
+</div>
+<h2 class="groupheader">Typedef Documentation</h2>
+<a class="anchor" id="ae2a2054f9852fd6020c26a1bcc7f1042"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">typedef int(* fuse_fill_dir_t)(void *buf, const char *name, const struct stat *stbuf, off_t off)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Function to add an entry in a readdir() operation</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">buf</td><td>the buffer passed to the readdir() operation </td></tr>
+    <tr><td class="paramname">name</td><td>the file name of the directory entry </td></tr>
+    <tr><td class="paramname">stat</td><td>file attributes, can be NULL </td></tr>
+    <tr><td class="paramname">off</td><td>offset of the next entry or zero </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>1 if buffer is full, zero otherwise </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="ab27948e20743f4c153f6ba6d71ca7182"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">typedef void(* fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Function type used to process commands </p>
+
+</div>
+</div>
+<h2 class="groupheader">Function Documentation</h2>
+<a class="anchor" id="a90f104e6d4e01480161a3300bddbecbe"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_clean_cache </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>fuse</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Iterate over cache removing stale entries use in conjunction with "-oremember"</p>
+<p>NOTE: This is already done for the standard sessions</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">fuse</td><td>struct fuse pointer for fuse instance </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the number of seconds until the next cleanup </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a0d47cac8a295efd5370d7af059e4d14f"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_destroy </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Destroy the FUSE handle.</p>
+<p>The communication channel attached to the handle is also destroyed.</p>
+<p>NOTE: This function does not unmount the filesystem. If this is needed, call <a class="el" href="fuse__common_8h.html#a1b6448c8529f9fac068a35ef7a279d4d">fuse_unmount()</a> before calling this function.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">f</td><td>the FUSE handle </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="a9024935b211288c1869dc7566895d739"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_exit </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Exit from event loop</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">f</td><td>the FUSE handle </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="a3035da06904362a9e924d77c2e460258"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_exited </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Return the exited flag, which indicates if <a class="el" href="fuse_8h.html#a9024935b211288c1869dc7566895d739">fuse_exit()</a> has been called </p>
+
+</div>
+</div>
+<a class="anchor" id="ad4b0e6955b2fd720542c6c3262fb8761"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse_fs* fuse_fs_new </td>
+          <td>(</td>
+          <td class="paramtype">const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *&#160;</td>
+          <td class="paramname"><em>op</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">size_t&#160;</td>
+          <td class="paramname"><em>op_size</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">void *&#160;</td>
+          <td class="paramname"><em>user_data</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create a new fuse filesystem object</p>
+<p>This is usually called from the factory of a fuse module to create a new instance of a filesystem.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">op</td><td>the filesystem operations </td></tr>
+    <tr><td class="paramname">op_size</td><td>the size of the <a class="el" href="structfuse__operations.html">fuse_operations</a> structure </td></tr>
+    <tr><td class="paramname">user_data</td><td>user data supplied in the context during the init() method </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>a new filesystem object </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a9a0f2a6603cb1e21f5e4c1aec84a3bcc"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct <a class="el" href="structfuse__context.html">fuse_context</a>* fuse_get_context </td>
+          <td>(</td>
+          <td class="paramtype">void&#160;</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get the current context</p>
+<p>The context is only valid for the duration of a filesystem operation, and thus must not be stored and used later.</p>
+<dl class="section return"><dt>Returns</dt><dd>the context </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a03baa193b5bfcbe625afbc62e9b97e91"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse_session* fuse_get_session </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get session from fuse object </p>
+
+</div>
+</div>
+<a class="anchor" id="a04273db088e57d8242caa388193b6958"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_getgroups </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>size</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">gid_t&#160;</td>
+          <td class="paramname"><em>list</em>[]&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get the current supplementary group IDs for the current request</p>
+<p>Similar to the getgroups(2) system call, except the return value is always the total number of group IDs, even if it is larger than the specified size.</p>
+<p>The current fuse kernel module in linux (as of 2.6.30) doesn't pass the group list to userspace, hence this function needs to parse "/proc/$TID/task/$TID/status" to get the group IDs.</p>
+<p>This feature may not be supported on all operating systems. In such a case this function will return -ENOSYS.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">size</td><td>size of given array </td></tr>
+    <tr><td class="paramname">list</td><td>array of group IDs to be filled in </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the total number of supplementary group IDs or -errno on failure </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a0514ca828e6a02a330dcf037292c8803"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_interrupted </td>
+          <td>(</td>
+          <td class="paramtype">void&#160;</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Check if the current request has already been interrupted</p>
+<dl class="section return"><dt>Returns</dt><dd>1 if the request has been interrupted, 0 otherwise </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a390d7e520ea2be2471ffa366cbc1f37d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_invalidate </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>path</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Obsolete, doesn't do anything</p>
+<dl class="section return"><dt>Returns</dt><dd>-EINVAL </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a6ea805c47ccc960497dfd64e12081159"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_loop </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>FUSE event loop.</p>
+<p>Requests from the kernel are processed, and the appropriate operations are called.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">f</td><td>the FUSE handle </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if no error occurred, -1 otherwise </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a79387240dad1f77417fd178f4b9ef0a0"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_loop_mt </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>FUSE event loop with multiple threads</p>
+<p>Requests from the kernel are processed, and the appropriate operations are called. Request are processed in parallel by distributing them between multiple threads.</p>
+<p>Calling this function requires the pthreads library to be linked to the application.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">f</td><td>the FUSE handle </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 if no error occurred, -1 otherwise </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="aadced4bb8ad64e622a2d0b9e6738c97b"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_loop_mt_proc </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype"><a class="el" href="fuse_8h.html#ab27948e20743f4c153f6ba6d71ca7182">fuse_processor_t</a>&#160;</td>
+          <td class="paramname"><em>proc</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">void *&#160;</td>
+          <td class="paramname"><em>data</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Multi threaded event loop, which calls the custom command processor function </p>
+
+</div>
+</div>
+<a class="anchor" id="a2098b9d60626bf749801d12f2d0d6fd3"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_main_real </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>argc</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">char *&#160;</td>
+          <td class="paramname"><em>argv</em>[], </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *&#160;</td>
+          <td class="paramname"><em>op</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">size_t&#160;</td>
+          <td class="paramname"><em>op_size</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">void *&#160;</td>
+          <td class="paramname"><em>user_data</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>The real main function</p>
+<p>Do not call this directly, use <a class="el" href="fuse_8h.html#a61755930843c427b79622eda0ad8f083">fuse_main()</a> </p>
+
+</div>
+</div>
+<a class="anchor" id="a5326844946defe4a50b3f4320786a0f4"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse* fuse_new </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse_chan *&#160;</td>
+          <td class="paramname"><em>ch</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">struct <a class="el" href="structfuse__args.html">fuse_args</a> *&#160;</td>
+          <td class="paramname"><em>args</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *&#160;</td>
+          <td class="paramname"><em>op</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">size_t&#160;</td>
+          <td class="paramname"><em>op_size</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">void *&#160;</td>
+          <td class="paramname"><em>user_data</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create a new FUSE filesystem.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">ch</td><td>the communication channel </td></tr>
+    <tr><td class="paramname">args</td><td>argument vector </td></tr>
+    <tr><td class="paramname">op</td><td>the filesystem operations </td></tr>
+    <tr><td class="paramname">op_size</td><td>the size of the <a class="el" href="structfuse__operations.html">fuse_operations</a> structure </td></tr>
+    <tr><td class="paramname">user_data</td><td>user data supplied in the context during the init() method </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the created FUSE handle </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a638b7477f87a2aca57ef0a5c4ca1d500"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_process_cmd </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">struct fuse_cmd *&#160;</td>
+          <td class="paramname"><em>cmd</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Process a single command </p>
+
+</div>
+</div>
+<a class="anchor" id="aa5aaa31ed710ea1afe9467f10d523b21"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse_cmd* fuse_read_cmd </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>f</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Read a single command. If none are read, return NULL </p>
+
+</div>
+</div>
+<a class="anchor" id="ad6380ea6c7cb4a4a4cf421d808ce2b66"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_register_module </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__module.html">fuse_module</a> *&#160;</td>
+          <td class="paramname"><em>mod</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Register a filesystem module</p>
+<p>This function is used by FUSE_REGISTER_MODULE and there's usually no need to call it directly </p>
+
+</div>
+</div>
+<a class="anchor" id="adbd6a1fa417b704972554ed983e67b85"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_set_getcontext_func </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__context.html">fuse_context</a> *(*)(void)&#160;</td>
+          <td class="paramname"><em>func</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>This function is obsolete and implemented as a no-op </p>
+
+</div>
+</div>
+<a class="anchor" id="ab6dc1548ab6f04f048927dc09882563d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse* fuse_setup </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>argc</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">char *&#160;</td>
+          <td class="paramname"><em>argv</em>[], </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const struct <a class="el" href="structfuse__operations.html">fuse_operations</a> *&#160;</td>
+          <td class="paramname"><em>op</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">size_t&#160;</td>
+          <td class="paramname"><em>op_size</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">char **&#160;</td>
+          <td class="paramname"><em>mountpoint</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>multithreaded</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">void *&#160;</td>
+          <td class="paramname"><em>user_data</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>This is the part of <a class="el" href="fuse_8h.html#a61755930843c427b79622eda0ad8f083">fuse_main()</a> before the event loop </p>
+
+</div>
+</div>
+<a class="anchor" id="a4b2246caec521ec4ac84093f8c4b616d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_start_cleanup_thread </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>fuse</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Start the cleanup thread when using option "remember".</p>
+<p>This is done automatically by <a class="el" href="fuse_8h.html#a79387240dad1f77417fd178f4b9ef0a0">fuse_loop_mt()</a> </p><dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">fuse</td><td>struct fuse pointer for fuse instance </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 on success and -1 on error </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="ad37fd69ba40d5c261f16e207e4a5b0ed"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_stop_cleanup_thread </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>fuse</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Stop the cleanup thread when using option "remember".</p>
+<p>This is done automatically by <a class="el" href="fuse_8h.html#a79387240dad1f77417fd178f4b9ef0a0">fuse_loop_mt()</a> </p><dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">fuse</td><td>struct fuse pointer for fuse instance </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="a87c736a7e6ee86348a9fdf83f6635199"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_teardown </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse *&#160;</td>
+          <td class="paramname"><em>fuse</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">char *&#160;</td>
+          <td class="paramname"><em>mountpoint</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>This is the part of <a class="el" href="fuse_8h.html#a61755930843c427b79622eda0ad8f083">fuse_main()</a> after the event loop </p>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,548 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: include/fuse_common.h File Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+<div id="nav-path" class="navpath">
+  <ul>
+<li class="navelem"><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html">include</a></li>  </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#nested-classes">Data Structures</a> &#124;
+<a href="#define-members">Macros</a> &#124;
+<a href="#enum-members">Enumerations</a> &#124;
+<a href="#func-members">Functions</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_common.h File Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+<div class="textblock"><code>#include &quot;<a class="el" href="fuse__opt_8h.html">fuse_opt.h</a>&quot;</code><br />
+<code>#include &lt;stdint.h&gt;</code><br />
+<code>#include &lt;sys/types.h&gt;</code><br />
+<code>#include &quot;fuse_common_compat.h&quot;</code><br />
+</div><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Data Structures</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html">fuse_file_info</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html">fuse_conn_info</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__buf.html">fuse_buf</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__bufvec.html">fuse_bufvec</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
+Macros</h2></td></tr>
+<tr class="memitem:a2779d57c512b7b948992858653e95f0e"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a2779d57c512b7b948992858653e95f0e">FUSE_MAJOR_VERSION</a>&#160;&#160;&#160;2</td></tr>
+<tr class="separator:a2779d57c512b7b948992858653e95f0e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a8571aa4ec96e1685d31eeff07cb2f163"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a8571aa4ec96e1685d31eeff07cb2f163">FUSE_MINOR_VERSION</a>&#160;&#160;&#160;9</td></tr>
+<tr class="separator:a8571aa4ec96e1685d31eeff07cb2f163"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a4e1bacbb44d6dca9a82255c8069c3d69"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a4e1bacbb44d6dca9a82255c8069c3d69">FUSE_CAP_ASYNC_READ</a>&#160;&#160;&#160;(1 &lt;&lt; 0)</td></tr>
+<tr class="separator:a4e1bacbb44d6dca9a82255c8069c3d69"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ade38f8e8c463cd40af5bfeeebfa99486"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#ade38f8e8c463cd40af5bfeeebfa99486">FUSE_IOCTL_COMPAT</a>&#160;&#160;&#160;(1 &lt;&lt; 0)</td></tr>
+<tr class="separator:ade38f8e8c463cd40af5bfeeebfa99486"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="enum-members"></a>
+Enumerations</h2></td></tr>
+<tr class="memitem:a5e36b839c4dbf0439bd85b61c7213a58"><td class="memItemLeft" align="right" valign="top">enum &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58">fuse_buf_flags</a> { <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58affd5b3b7e9cdd5f89b3126eea96e033b">FUSE_BUF_IS_FD</a> = (1 &lt;&lt; 1), 
+<a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58ad67d5c6075febad0594f06d46d02bfa9">FUSE_BUF_FD_SEEK</a> = (1 &lt;&lt; 2), 
+<a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58af89b4b00a2d4a06d8458b320c2cb28cf">FUSE_BUF_FD_RETRY</a> = (1 &lt;&lt; 3)
+ }</td></tr>
+<tr class="separator:a5e36b839c4dbf0439bd85b61c7213a58"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aec0ad71a3e8c357ebe7e87cdecbdbe18"><td class="memItemLeft" align="right" valign="top">enum &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18">fuse_buf_copy_flags</a> { <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18adcef8052c48f314d4d9f9f05a5b4f838">FUSE_BUF_NO_SPLICE</a> = (1 &lt;&lt; 1), 
+<a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18a375767de945f5178e8949d284abf1f5b">FUSE_BUF_FORCE_SPLICE</a> = (1 &lt;&lt; 2), 
+<a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18af239e556066a5d73b3ff542216b157b9">FUSE_BUF_SPLICE_MOVE</a> = (1 &lt;&lt; 3), 
+<a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18a32ec833f1eb4b5cd9283cf9d93021037">FUSE_BUF_SPLICE_NONBLOCK</a> = (1 &lt;&lt; 4)
+ }</td></tr>
+<tr class="separator:aec0ad71a3e8c357ebe7e87cdecbdbe18"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:a30d394a6127b20455bf5a4899e56e759"><td class="memItemLeft" align="right" valign="top">struct fuse_chan *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a30d394a6127b20455bf5a4899e56e759">fuse_mount</a> (const char *mountpoint, struct <a class="el" href="structfuse__args.html">fuse_args</a> *args)</td></tr>
+<tr class="separator:a30d394a6127b20455bf5a4899e56e759"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1b6448c8529f9fac068a35ef7a279d4d"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a1b6448c8529f9fac068a35ef7a279d4d">fuse_unmount</a> (const char *mountpoint, struct fuse_chan *ch)</td></tr>
+<tr class="separator:a1b6448c8529f9fac068a35ef7a279d4d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a971bb6dbde8b6d47dfd5c1fab8b30a1d"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a971bb6dbde8b6d47dfd5c1fab8b30a1d">fuse_parse_cmdline</a> (struct <a class="el" href="structfuse__args.html">fuse_args</a> *args, char **mountpoint, int *multithreaded, int *foreground)</td></tr>
+<tr class="separator:a971bb6dbde8b6d47dfd5c1fab8b30a1d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:af1857d2209952f49a762aff39f3cd8bd"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#af1857d2209952f49a762aff39f3cd8bd">fuse_daemonize</a> (int foreground)</td></tr>
+<tr class="separator:af1857d2209952f49a762aff39f3cd8bd"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ae04b2f721003f5540c71be65396c53c8"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#ae04b2f721003f5540c71be65396c53c8">fuse_version</a> (void)</td></tr>
+<tr class="separator:ae04b2f721003f5540c71be65396c53c8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:adf5027f8a38b2efc03858efd7fdc756a"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#adf5027f8a38b2efc03858efd7fdc756a">fuse_pollhandle_destroy</a> (struct fuse_pollhandle *ph)</td></tr>
+<tr class="separator:adf5027f8a38b2efc03858efd7fdc756a"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a4327f41b2fe1ca84151b407169bd86c0"><td class="memItemLeft" align="right" valign="top">size_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a4327f41b2fe1ca84151b407169bd86c0">fuse_buf_size</a> (const struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *bufv)</td></tr>
+<tr class="separator:a4327f41b2fe1ca84151b407169bd86c0"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a9ca301390fb5e85b85153abb1891a3f7"><td class="memItemLeft" align="right" valign="top">ssize_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a9ca301390fb5e85b85153abb1891a3f7">fuse_buf_copy</a> (struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *dst, struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *src, enum <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18">fuse_buf_copy_flags</a> flags)</td></tr>
+<tr class="separator:a9ca301390fb5e85b85153abb1891a3f7"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a292dccc3c7b1799cb054efa2ba0c774b"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#a292dccc3c7b1799cb054efa2ba0c774b">fuse_set_signal_handlers</a> (struct fuse_session *se)</td></tr>
+<tr class="separator:a292dccc3c7b1799cb054efa2ba0c774b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aeb674bbc11074c4fe520b952d6bfdd30"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__common_8h.html#aeb674bbc11074c4fe520b952d6bfdd30">fuse_remove_signal_handlers</a> (struct fuse_session *se)</td></tr>
+<tr class="separator:aeb674bbc11074c4fe520b952d6bfdd30"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<h2 class="groupheader">Macro Definition Documentation</h2>
+<a class="anchor" id="a4e1bacbb44d6dca9a82255c8069c3d69"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_CAP_ASYNC_READ&#160;&#160;&#160;(1 &lt;&lt; 0)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Capability bits for '<a class="el" href="structfuse__conn__info.html#a8a1c61f5d7cc14249fb6971165bb958e">fuse_conn_info.capable</a>' and '<a class="el" href="structfuse__conn__info.html#af45de81548b591f3004353a324e4e04d">fuse_conn_info.want</a>'</p>
+<p>FUSE_CAP_ASYNC_READ: filesystem supports asynchronous read requests FUSE_CAP_POSIX_LOCKS: filesystem supports "remote" locking FUSE_CAP_ATOMIC_O_TRUNC: filesystem handles the O_TRUNC open flag FUSE_CAP_EXPORT_SUPPORT: filesystem handles lookups of "." and ".." FUSE_CAP_BIG_WRITES: filesystem can handle write size larger than 4kB FUSE_CAP_DONT_MASK: don't apply umask to file mode on create operations FUSE_CAP_SPLICE_WRITE: ability to use splice() to write to the fuse device FUSE_CAP_SPLICE_MOVE: ability to move data to the fuse device with splice() FUSE_CAP_SPLICE_READ: ability to use splice() to read from the fuse device FUSE_CAP_IOCTL_DIR: ioctl support on directories </p>
+
+</div>
+</div>
+<a class="anchor" id="ade38f8e8c463cd40af5bfeeebfa99486"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_IOCTL_COMPAT&#160;&#160;&#160;(1 &lt;&lt; 0)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Ioctl flags</p>
+<p>FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine FUSE_IOCTL_UNRESTRICTED: not restricted to well-formed ioctls, retry allowed FUSE_IOCTL_RETRY: retry with new iovecs FUSE_IOCTL_DIR: is a directory</p>
+<p>FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs </p>
+
+</div>
+</div>
+<a class="anchor" id="a2779d57c512b7b948992858653e95f0e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_MAJOR_VERSION&#160;&#160;&#160;2</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Major version of FUSE library interface </p>
+
+</div>
+</div>
+<a class="anchor" id="a8571aa4ec96e1685d31eeff07cb2f163"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_MINOR_VERSION&#160;&#160;&#160;9</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Minor version of FUSE library interface </p>
+
+</div>
+</div>
+<h2 class="groupheader">Enumeration Type Documentation</h2>
+<a class="anchor" id="aec0ad71a3e8c357ebe7e87cdecbdbe18"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18">fuse_buf_copy_flags</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Buffer copy flags </p>
+<table class="fieldtable">
+<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a class="anchor" id="aec0ad71a3e8c357ebe7e87cdecbdbe18adcef8052c48f314d4d9f9f05a5b4f838"></a>FUSE_BUF_NO_SPLICE&#160;</td><td class="fielddoc">
+<p>Don't use splice(2)</p>
+<p>Always fall back to using read and write instead of splice(2) to copy data from one file descriptor to another.</p>
+<p>If this flag is not set, then only fall back if splice is unavailable. </p>
+</td></tr>
+<tr><td class="fieldname"><a class="anchor" id="aec0ad71a3e8c357ebe7e87cdecbdbe18a375767de945f5178e8949d284abf1f5b"></a>FUSE_BUF_FORCE_SPLICE&#160;</td><td class="fielddoc">
+<p>Force splice</p>
+<p>Always use splice(2) to copy data from one file descriptor to another. If splice is not available, return -EINVAL. </p>
+</td></tr>
+<tr><td class="fieldname"><a class="anchor" id="aec0ad71a3e8c357ebe7e87cdecbdbe18af239e556066a5d73b3ff542216b157b9"></a>FUSE_BUF_SPLICE_MOVE&#160;</td><td class="fielddoc">
+<p>Try to move data with splice.</p>
+<p>If splice is used, try to move pages from the source to the destination instead of copying. See documentation of SPLICE_F_MOVE in splice(2) man page. </p>
+</td></tr>
+<tr><td class="fieldname"><a class="anchor" id="aec0ad71a3e8c357ebe7e87cdecbdbe18a32ec833f1eb4b5cd9283cf9d93021037"></a>FUSE_BUF_SPLICE_NONBLOCK&#160;</td><td class="fielddoc">
+<p>Don't block on the pipe when copying data with splice</p>
+<p>Makes the operations on the pipe non-blocking (if the pipe is full or empty). See SPLICE_F_NONBLOCK in the splice(2) man page. </p>
+</td></tr>
+</table>
+
+</div>
+</div>
+<a class="anchor" id="a5e36b839c4dbf0439bd85b61c7213a58"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58">fuse_buf_flags</a></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Buffer flags </p>
+<table class="fieldtable">
+<tr><th colspan="2">Enumerator</th></tr><tr><td class="fieldname"><a class="anchor" id="a5e36b839c4dbf0439bd85b61c7213a58affd5b3b7e9cdd5f89b3126eea96e033b"></a>FUSE_BUF_IS_FD&#160;</td><td class="fielddoc">
+<p>Buffer contains a file descriptor</p>
+<p>If this flag is set, the .fd field is valid, otherwise the .mem fields is valid. </p>
+</td></tr>
+<tr><td class="fieldname"><a class="anchor" id="a5e36b839c4dbf0439bd85b61c7213a58ad67d5c6075febad0594f06d46d02bfa9"></a>FUSE_BUF_FD_SEEK&#160;</td><td class="fielddoc">
+<p>Seek on the file descriptor</p>
+<p>If this flag is set then the .pos field is valid and is used to seek to the given offset before performing operation on file descriptor. </p>
+</td></tr>
+<tr><td class="fieldname"><a class="anchor" id="a5e36b839c4dbf0439bd85b61c7213a58af89b4b00a2d4a06d8458b320c2cb28cf"></a>FUSE_BUF_FD_RETRY&#160;</td><td class="fielddoc">
+<p>Retry operation on file descriptor</p>
+<p>If this flag is set then retry operation on file descriptor until .size bytes have been copied or an error or EOF is detected. </p>
+</td></tr>
+</table>
+
+</div>
+</div>
+<h2 class="groupheader">Function Documentation</h2>
+<a class="anchor" id="a9ca301390fb5e85b85153abb1891a3f7"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">ssize_t fuse_buf_copy </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *&#160;</td>
+          <td class="paramname"><em>dst</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *&#160;</td>
+          <td class="paramname"><em>src</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">enum <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18">fuse_buf_copy_flags</a>&#160;</td>
+          <td class="paramname"><em>flags</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Copy data from one buffer vector to another</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">dst</td><td>destination buffer vector </td></tr>
+    <tr><td class="paramname">src</td><td>source buffer vector </td></tr>
+    <tr><td class="paramname">flags</td><td>flags controlling the copy </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>actual number of bytes copied or -errno on error </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a4327f41b2fe1ca84151b407169bd86c0"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">size_t fuse_buf_size </td>
+          <td>(</td>
+          <td class="paramtype">const struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *&#160;</td>
+          <td class="paramname"><em>bufv</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get total size of data in a fuse buffer vector</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">bufv</td><td>buffer vector </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>size of data </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="af1857d2209952f49a762aff39f3cd8bd"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_daemonize </td>
+          <td>(</td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>foreground</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Go into the background</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">foreground</td><td>if true, stay in the foreground </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 on success, -1 on failure </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a30d394a6127b20455bf5a4899e56e759"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse_chan* fuse_mount </td>
+          <td>(</td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>mountpoint</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">struct <a class="el" href="structfuse__args.html">fuse_args</a> *&#160;</td>
+          <td class="paramname"><em>args</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create a FUSE mountpoint</p>
+<p>Returns a control file descriptor suitable for passing to <a class="el" href="fuse_8h.html#a5326844946defe4a50b3f4320786a0f4">fuse_new()</a></p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">mountpoint</td><td>the mount point path </td></tr>
+    <tr><td class="paramname">args</td><td>argument vector </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the communication channel on success, NULL on failure </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a971bb6dbde8b6d47dfd5c1fab8b30a1d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_parse_cmdline </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__args.html">fuse_args</a> *&#160;</td>
+          <td class="paramname"><em>args</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">char **&#160;</td>
+          <td class="paramname"><em>mountpoint</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>multithreaded</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int *&#160;</td>
+          <td class="paramname"><em>foreground</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Parse common options</p>
+<p>The following options are parsed:</p>
+<p>'-f' foreground '-d' '-odebug' foreground, but keep the debug option '-s' single threaded '-h' '&ndash;help' help '-ho' help without header '-ofsname=..' file system name, if not present, then set to the program name</p>
+<p>All parameters may be NULL</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">args</td><td>argument vector </td></tr>
+    <tr><td class="paramname">mountpoint</td><td>the returned mountpoint, should be freed after use </td></tr>
+    <tr><td class="paramname">multithreaded</td><td>set to 1 unless the '-s' option is present </td></tr>
+    <tr><td class="paramname">foreground</td><td>set to 1 if one of the relevant options is present </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 on success, -1 on failure </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="adf5027f8a38b2efc03858efd7fdc756a"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_pollhandle_destroy </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse_pollhandle *&#160;</td>
+          <td class="paramname"><em>ph</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Destroy poll handle</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">ph</td><td>the poll handle </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="aeb674bbc11074c4fe520b952d6bfdd30"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_remove_signal_handlers </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse_session *&#160;</td>
+          <td class="paramname"><em>se</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Restore default signal handlers</p>
+<p>Resets global session. After this <a class="el" href="fuse__common_8h.html#a292dccc3c7b1799cb054efa2ba0c774b">fuse_set_signal_handlers()</a> may be called again.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">se</td><td>the same session as given in <a class="el" href="fuse__common_8h.html#a292dccc3c7b1799cb054efa2ba0c774b">fuse_set_signal_handlers()</a> </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="a292dccc3c7b1799cb054efa2ba0c774b"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_set_signal_handlers </td>
+          <td>(</td>
+          <td class="paramtype">struct fuse_session *&#160;</td>
+          <td class="paramname"><em>se</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Exit session on HUP, TERM and INT signals and ignore PIPE signal</p>
+<p>Stores session in a global variable. May only be called once per process until <a class="el" href="fuse__common_8h.html#aeb674bbc11074c4fe520b952d6bfdd30">fuse_remove_signal_handlers()</a> is called.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">se</td><td>the session to exit </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>0 on success, -1 on failure </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a1b6448c8529f9fac068a35ef7a279d4d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_unmount </td>
+          <td>(</td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>mountpoint</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">struct fuse_chan *&#160;</td>
+          <td class="paramname"><em>ch</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Umount a FUSE mountpoint</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">mountpoint</td><td>the mount point path </td></tr>
+    <tr><td class="paramname">ch</td><td>the communication channel </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="ae04b2f721003f5540c71be65396c53c8"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_version </td>
+          <td>(</td>
+          <td class="paramtype">void&#160;</td>
+          <td class="paramname"></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get the version of the library</p>
+<dl class="section return"><dt>Returns</dt><dd>the version </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,530 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: include/fuse_opt.h File Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+<div id="nav-path" class="navpath">
+  <ul>
+<li class="navelem"><a class="el" href="dir_d44c64559bbebec7f509842c48db8b23.html">include</a></li>  </ul>
+</div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#nested-classes">Data Structures</a> &#124;
+<a href="#define-members">Macros</a> &#124;
+<a href="#typedef-members">Typedefs</a> &#124;
+<a href="#func-members">Functions</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_opt.h File Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="nested-classes"></a>
+Data Structures</h2></td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__opt.html">fuse_opt</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__args.html">fuse_args</a></td></tr>
+<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="define-members"></a>
+Macros</h2></td></tr>
+<tr class="memitem:a371d830a8aedd9e3f96d9bb31876a8f1"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a371d830a8aedd9e3f96d9bb31876a8f1">FUSE_OPT_KEY</a>(templ, key)&#160;&#160;&#160;{ templ, -1U, key }</td></tr>
+<tr class="separator:a371d830a8aedd9e3f96d9bb31876a8f1"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aca35962e17d189ceb5447f8eea11bd33"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#aca35962e17d189ceb5447f8eea11bd33">FUSE_OPT_END</a>&#160;&#160;&#160;{ NULL, 0, 0 }</td></tr>
+<tr class="separator:aca35962e17d189ceb5447f8eea11bd33"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a9bea40fe56b18be9aa110185ab7387ed"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a9bea40fe56b18be9aa110185ab7387ed">FUSE_ARGS_INIT</a>(argc, argv)&#160;&#160;&#160;{ argc, argv, 0 }</td></tr>
+<tr class="separator:a9bea40fe56b18be9aa110185ab7387ed"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a48cb1aea482de904a848651360117748"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a48cb1aea482de904a848651360117748">FUSE_OPT_KEY_OPT</a>&#160;&#160;&#160;-1</td></tr>
+<tr class="separator:a48cb1aea482de904a848651360117748"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a632b025441794a4e6fe59b7ab53bbfc4"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a632b025441794a4e6fe59b7ab53bbfc4">FUSE_OPT_KEY_NONOPT</a>&#160;&#160;&#160;-2</td></tr>
+<tr class="separator:a632b025441794a4e6fe59b7ab53bbfc4"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a8533ff341f910c1bd05f10c8fcc35a04"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a8533ff341f910c1bd05f10c8fcc35a04">FUSE_OPT_KEY_KEEP</a>&#160;&#160;&#160;-3</td></tr>
+<tr class="separator:a8533ff341f910c1bd05f10c8fcc35a04"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a6e97b6ce492f1baaaf0a4eb4970c9a2f"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a6e97b6ce492f1baaaf0a4eb4970c9a2f">FUSE_OPT_KEY_DISCARD</a>&#160;&#160;&#160;-4</td></tr>
+<tr class="separator:a6e97b6ce492f1baaaf0a4eb4970c9a2f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="typedef-members"></a>
+Typedefs</h2></td></tr>
+<tr class="memitem:a975525ccd73368c818ef2e3e917aeb33"><td class="memItemLeft" align="right" valign="top">typedef int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a975525ccd73368c818ef2e3e917aeb33">fuse_opt_proc_t</a> )(void *data, const char *arg, int key, struct <a class="el" href="structfuse__args.html">fuse_args</a> *outargs)</td></tr>
+<tr class="separator:a975525ccd73368c818ef2e3e917aeb33"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table><table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="func-members"></a>
+Functions</h2></td></tr>
+<tr class="memitem:a539ef1f571c34f516c60c4cbe2901c0e"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a539ef1f571c34f516c60c4cbe2901c0e">fuse_opt_parse</a> (struct <a class="el" href="structfuse__args.html">fuse_args</a> *args, void *data, const struct <a class="el" href="structfuse__opt.html">fuse_opt</a> opts[], <a class="el" href="fuse__opt_8h.html#a975525ccd73368c818ef2e3e917aeb33">fuse_opt_proc_t</a> proc)</td></tr>
+<tr class="separator:a539ef1f571c34f516c60c4cbe2901c0e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aaae525d5e959c5394bc323be0c1d02b0"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#aaae525d5e959c5394bc323be0c1d02b0">fuse_opt_add_opt</a> (char **opts, const char *opt)</td></tr>
+<tr class="separator:aaae525d5e959c5394bc323be0c1d02b0"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a51a00d087d08bef250a53b9e4979b1cd"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a51a00d087d08bef250a53b9e4979b1cd">fuse_opt_add_opt_escaped</a> (char **opts, const char *opt)</td></tr>
+<tr class="separator:a51a00d087d08bef250a53b9e4979b1cd"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a21602e6a0fff64fc9c7b642d12382094"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a21602e6a0fff64fc9c7b642d12382094">fuse_opt_add_arg</a> (struct <a class="el" href="structfuse__args.html">fuse_args</a> *args, const char *arg)</td></tr>
+<tr class="separator:a21602e6a0fff64fc9c7b642d12382094"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:adb2922444d67f58e4233d21320386bc0"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#adb2922444d67f58e4233d21320386bc0">fuse_opt_insert_arg</a> (struct <a class="el" href="structfuse__args.html">fuse_args</a> *args, int pos, const char *arg)</td></tr>
+<tr class="separator:adb2922444d67f58e4233d21320386bc0"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a2cdf272429ab3869a5162976141b287d"><td class="memItemLeft" align="right" valign="top">void&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#a2cdf272429ab3869a5162976141b287d">fuse_opt_free_args</a> (struct <a class="el" href="structfuse__args.html">fuse_args</a> *args)</td></tr>
+<tr class="separator:a2cdf272429ab3869a5162976141b287d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:af16c684bd2b10b7ac0ae299afa1e0e06"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="fuse__opt_8h.html#af16c684bd2b10b7ac0ae299afa1e0e06">fuse_opt_match</a> (const struct <a class="el" href="structfuse__opt.html">fuse_opt</a> opts[], const char *opt)</td></tr>
+<tr class="separator:af16c684bd2b10b7ac0ae299afa1e0e06"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>This file defines the option parsing interface of FUSE </p>
+</div><h2 class="groupheader">Macro Definition Documentation</h2>
+<a class="anchor" id="a9bea40fe56b18be9aa110185ab7387ed"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_ARGS_INIT</td>
+          <td>(</td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">argc, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">argv&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td>&#160;&#160;&#160;{ argc, argv, 0 }</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Initializer for 'struct <a class="el" href="structfuse__args.html">fuse_args</a>' </p>
+
+</div>
+</div>
+<a class="anchor" id="aca35962e17d189ceb5447f8eea11bd33"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_OPT_END&#160;&#160;&#160;{ NULL, 0, 0 }</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Last option. An array of 'struct <a class="el" href="structfuse__opt.html">fuse_opt</a>' must end with a NULL template value </p>
+
+</div>
+</div>
+<a class="anchor" id="a371d830a8aedd9e3f96d9bb31876a8f1"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_OPT_KEY</td>
+          <td>(</td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">templ, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">&#160;</td>
+          <td class="paramname">key&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td>&#160;&#160;&#160;{ templ, -1U, key }</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Key option. In case of a match, the processing function will be called with the specified key. </p>
+
+</div>
+</div>
+<a class="anchor" id="a6e97b6ce492f1baaaf0a4eb4970c9a2f"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_OPT_KEY_DISCARD&#160;&#160;&#160;-4</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Special key value for options to discard</p>
+<p>Argument is not passed to processing function, but behave as if the processing function returned zero </p>
+
+</div>
+</div>
+<a class="anchor" id="a8533ff341f910c1bd05f10c8fcc35a04"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_OPT_KEY_KEEP&#160;&#160;&#160;-3</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Special key value for options to keep</p>
+<p>Argument is not passed to processing function, but behave as if the processing function returned 1 </p>
+
+</div>
+</div>
+<a class="anchor" id="a632b025441794a4e6fe59b7ab53bbfc4"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_OPT_KEY_NONOPT&#160;&#160;&#160;-2</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Key value passed to the processing function for all non-options</p>
+<p>Non-options are the arguments beginning with a character other than '-' or all arguments after the special '&ndash;' option </p>
+
+</div>
+</div>
+<a class="anchor" id="a48cb1aea482de904a848651360117748"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">#define FUSE_OPT_KEY_OPT&#160;&#160;&#160;-1</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Key value passed to the processing function if an option did not match any template </p>
+
+</div>
+</div>
+<h2 class="groupheader">Typedef Documentation</h2>
+<a class="anchor" id="a975525ccd73368c818ef2e3e917aeb33"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">typedef int(* fuse_opt_proc_t)(void *data, const char *arg, int key, struct <a class="el" href="structfuse__args.html">fuse_args</a> *outargs)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Processing function</p>
+<p>This function is called if</p><ul>
+<li>option did not match any 'struct <a class="el" href="structfuse__opt.html">fuse_opt</a>'</li>
+<li>argument is a non-option</li>
+<li>option did match and offset was set to -1</li>
+</ul>
+<p>The 'arg' parameter will always contain the whole argument or option including the parameter if exists. A two-argument option ("-x foo") is always converted to single argument option of the form "-xfoo" before this function is called.</p>
+<p>Options of the form '-ofoo' are passed to this function without the '-o' prefix.</p>
+<p>The return value of this function determines whether this argument is to be inserted into the output argument vector, or discarded.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">data</td><td>is the user data passed to the <a class="el" href="fuse__opt_8h.html#a539ef1f571c34f516c60c4cbe2901c0e">fuse_opt_parse()</a> function </td></tr>
+    <tr><td class="paramname">arg</td><td>is the whole argument or option </td></tr>
+    <tr><td class="paramname">key</td><td>determines why the processing function was called </td></tr>
+    <tr><td class="paramname">outargs</td><td>the current output argument list </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>-1 on error, 0 if arg is to be discarded, 1 if arg should be kept </dd></dl>
+
+</div>
+</div>
+<h2 class="groupheader">Function Documentation</h2>
+<a class="anchor" id="a21602e6a0fff64fc9c7b642d12382094"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_opt_add_arg </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__args.html">fuse_args</a> *&#160;</td>
+          <td class="paramname"><em>args</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>arg</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Add an argument to a NULL terminated argument vector</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">args</td><td>is the structure containing the current argument list </td></tr>
+    <tr><td class="paramname">arg</td><td>is the new argument to add </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>-1 on allocation error, 0 on success </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="aaae525d5e959c5394bc323be0c1d02b0"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_opt_add_opt </td>
+          <td>(</td>
+          <td class="paramtype">char **&#160;</td>
+          <td class="paramname"><em>opts</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>opt</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Add an option to a comma separated option list</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">opts</td><td>is a pointer to an option list, may point to a NULL value </td></tr>
+    <tr><td class="paramname">opt</td><td>is the option to add </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>-1 on allocation error, 0 on success </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a51a00d087d08bef250a53b9e4979b1cd"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_opt_add_opt_escaped </td>
+          <td>(</td>
+          <td class="paramtype">char **&#160;</td>
+          <td class="paramname"><em>opts</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>opt</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Add an option, escaping commas, to a comma separated option list</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">opts</td><td>is a pointer to an option list, may point to a NULL value </td></tr>
+    <tr><td class="paramname">opt</td><td>is the option to add </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>-1 on allocation error, 0 on success </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a2cdf272429ab3869a5162976141b287d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void fuse_opt_free_args </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__args.html">fuse_args</a> *&#160;</td>
+          <td class="paramname"><em>args</em></td><td>)</td>
+          <td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Free the contents of argument list</p>
+<p>The structure itself is not freed</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">args</td><td>is the structure containing the argument list </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="adb2922444d67f58e4233d21320386bc0"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_opt_insert_arg </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__args.html">fuse_args</a> *&#160;</td>
+          <td class="paramname"><em>args</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">int&#160;</td>
+          <td class="paramname"><em>pos</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>arg</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Add an argument at the specified position in a NULL terminated argument vector</p>
+<p>Adds the argument to the N-th position. This is useful for adding options at the beginning of the array which must not come after the special '&ndash;' option.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">args</td><td>is the structure containing the current argument list </td></tr>
+    <tr><td class="paramname">pos</td><td>is the position at which to add the argument </td></tr>
+    <tr><td class="paramname">arg</td><td>is the new argument to add </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>-1 on allocation error, 0 on success </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="af16c684bd2b10b7ac0ae299afa1e0e06"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_opt_match </td>
+          <td>(</td>
+          <td class="paramtype">const struct <a class="el" href="structfuse__opt.html">fuse_opt</a>&#160;</td>
+          <td class="paramname"><em>opts</em>[], </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const char *&#160;</td>
+          <td class="paramname"><em>opt</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Check if an option matches</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">opts</td><td>is the option description array </td></tr>
+    <tr><td class="paramname">opt</td><td>is the option to match </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>1 if a match is found, 0 if not </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a539ef1f571c34f516c60c4cbe2901c0e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_opt_parse </td>
+          <td>(</td>
+          <td class="paramtype">struct <a class="el" href="structfuse__args.html">fuse_args</a> *&#160;</td>
+          <td class="paramname"><em>args</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">void *&#160;</td>
+          <td class="paramname"><em>data</em>, </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype">const struct <a class="el" href="structfuse__opt.html">fuse_opt</a>&#160;</td>
+          <td class="paramname"><em>opts</em>[], </td>
+        </tr>
+        <tr>
+          <td class="paramkey"></td>
+          <td></td>
+          <td class="paramtype"><a class="el" href="fuse__opt_8h.html#a975525ccd73368c818ef2e3e917aeb33">fuse_opt_proc_t</a>&#160;</td>
+          <td class="paramname"><em>proc</em>&#160;</td>
+        </tr>
+        <tr>
+          <td></td>
+          <td>)</td>
+          <td></td><td></td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Option parsing function</p>
+<p>If 'args' was returned from a previous call to <a class="el" href="fuse__opt_8h.html#a539ef1f571c34f516c60c4cbe2901c0e">fuse_opt_parse()</a> or it was constructed from</p>
+<p>A NULL 'args' is equivalent to an empty argument vector</p>
+<p>A NULL 'opts' is equivalent to an 'opts' array containing a single end marker</p>
+<p>A NULL 'proc' is equivalent to a processing function always returning '1'</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">args</td><td>is the input and output argument list </td></tr>
+    <tr><td class="paramname">data</td><td>is the user data </td></tr>
+    <tr><td class="paramname">opts</td><td>is the option description array </td></tr>
+    <tr><td class="paramname">proc</td><td>is the processing function </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>-1 on error, 0 on success </dd></dl>
+
+</div>
+</div>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,440 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Globals</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li class="current"><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li class="current"><a href="globals.html"><span>All</span></a></li>
+      <li><a href="globals_func.html"><span>Functions</span></a></li>
+      <li><a href="globals_type.html"><span>Typedefs</span></a></li>
+      <li><a href="globals_enum.html"><span>Enumerations</span></a></li>
+      <li><a href="globals_eval.html"><span>Enumerator</span></a></li>
+      <li><a href="globals_defs.html"><span>Macros</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow4" class="tabs3">
+    <ul class="tablist">
+      <li class="current"><a href="#index_f"><span>f</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+<div class="textblock">Here is a list of all documented functions, variables, defines, enums, and typedefs with links to the documentation:</div>
+
+<h3><a class="anchor" id="index_f"></a>- f -</h3><ul>
+<li>fuse_add_direntry()
+: <a class="el" href="fuse__lowlevel_8h.html#ad1957bcc8ece8c90f16c42c4daf3053f">fuse_lowlevel.h</a>
+</li>
+<li>FUSE_ARGS_INIT
+: <a class="el" href="fuse__opt_8h.html#a9bea40fe56b18be9aa110185ab7387ed">fuse_opt.h</a>
+</li>
+<li>fuse_buf_copy()
+: <a class="el" href="fuse__common_8h.html#a9ca301390fb5e85b85153abb1891a3f7">fuse_common.h</a>
+</li>
+<li>fuse_buf_copy_flags
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_FD_RETRY
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58af89b4b00a2d4a06d8458b320c2cb28cf">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_FD_SEEK
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58ad67d5c6075febad0594f06d46d02bfa9">fuse_common.h</a>
+</li>
+<li>fuse_buf_flags
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_FORCE_SPLICE
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18a375767de945f5178e8949d284abf1f5b">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_IS_FD
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58affd5b3b7e9cdd5f89b3126eea96e033b">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_NO_SPLICE
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18adcef8052c48f314d4d9f9f05a5b4f838">fuse_common.h</a>
+</li>
+<li>fuse_buf_size()
+: <a class="el" href="fuse__common_8h.html#a4327f41b2fe1ca84151b407169bd86c0">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_SPLICE_MOVE
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18af239e556066a5d73b3ff542216b157b9">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_SPLICE_NONBLOCK
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18a32ec833f1eb4b5cd9283cf9d93021037">fuse_common.h</a>
+</li>
+<li>FUSE_CAP_ASYNC_READ
+: <a class="el" href="fuse__common_8h.html#a4e1bacbb44d6dca9a82255c8069c3d69">fuse_common.h</a>
+</li>
+<li>fuse_chan_bufsize()
+: <a class="el" href="fuse__lowlevel_8h.html#ab2018fab0f56f1b15f6e5fd9ff63641c">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_data()
+: <a class="el" href="fuse__lowlevel_8h.html#a50696378a60c9b5daea8de2fbcf1dc5d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_destroy()
+: <a class="el" href="fuse__lowlevel_8h.html#a7a88655f900be214db61844337879fa5">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_fd()
+: <a class="el" href="fuse__lowlevel_8h.html#aed5405bd1725a4da8610ce1a1fe49307">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_new()
+: <a class="el" href="fuse__lowlevel_8h.html#a0a9a9cd6bffbd37ee1971b3dfe183140">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_recv()
+: <a class="el" href="fuse__lowlevel_8h.html#afa1748ec47595b3ab7be93ad29e55fcb">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_send()
+: <a class="el" href="fuse__lowlevel_8h.html#ad53f74694d7c8605d956d48ab04b55e9">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_session()
+: <a class="el" href="fuse__lowlevel_8h.html#a0d0c57c5be8fe4884c10270fcaad4710">fuse_lowlevel.h</a>
+</li>
+<li>fuse_clean_cache()
+: <a class="el" href="fuse_8h.html#a90f104e6d4e01480161a3300bddbecbe">fuse.h</a>
+</li>
+<li>fuse_daemonize()
+: <a class="el" href="fuse__common_8h.html#af1857d2209952f49a762aff39f3cd8bd">fuse_common.h</a>
+</li>
+<li>fuse_destroy()
+: <a class="el" href="fuse_8h.html#a0d47cac8a295efd5370d7af059e4d14f">fuse.h</a>
+</li>
+<li>fuse_exit()
+: <a class="el" href="fuse_8h.html#a9024935b211288c1869dc7566895d739">fuse.h</a>
+</li>
+<li>fuse_exited()
+: <a class="el" href="fuse_8h.html#a3035da06904362a9e924d77c2e460258">fuse.h</a>
+</li>
+<li>fuse_fill_dir_t
+: <a class="el" href="fuse_8h.html#ae2a2054f9852fd6020c26a1bcc7f1042">fuse.h</a>
+</li>
+<li>fuse_fs_new()
+: <a class="el" href="fuse_8h.html#ad4b0e6955b2fd720542c6c3262fb8761">fuse.h</a>
+</li>
+<li>fuse_get_context()
+: <a class="el" href="fuse_8h.html#a9a0f2a6603cb1e21f5e4c1aec84a3bcc">fuse.h</a>
+</li>
+<li>fuse_get_session()
+: <a class="el" href="fuse_8h.html#a03baa193b5bfcbe625afbc62e9b97e91">fuse.h</a>
+</li>
+<li>fuse_getgroups()
+: <a class="el" href="fuse_8h.html#a04273db088e57d8242caa388193b6958">fuse.h</a>
+</li>
+<li>fuse_ino_t
+: <a class="el" href="fuse__lowlevel_8h.html#ab419149c707451eaf61b75afb852e016">fuse_lowlevel.h</a>
+</li>
+<li>fuse_interrupt_func_t
+: <a class="el" href="fuse__lowlevel_8h.html#a5bb8b555b1d9d8a38b8c6cac28d51f1e">fuse_lowlevel.h</a>
+</li>
+<li>fuse_interrupted()
+: <a class="el" href="fuse_8h.html#a0514ca828e6a02a330dcf037292c8803">fuse.h</a>
+</li>
+<li>fuse_invalidate()
+: <a class="el" href="fuse_8h.html#a390d7e520ea2be2471ffa366cbc1f37d">fuse.h</a>
+</li>
+<li>FUSE_IOCTL_COMPAT
+: <a class="el" href="fuse__common_8h.html#ade38f8e8c463cd40af5bfeeebfa99486">fuse_common.h</a>
+</li>
+<li>fuse_loop()
+: <a class="el" href="fuse_8h.html#a6ea805c47ccc960497dfd64e12081159">fuse.h</a>
+</li>
+<li>fuse_loop_mt()
+: <a class="el" href="fuse_8h.html#a79387240dad1f77417fd178f4b9ef0a0">fuse.h</a>
+</li>
+<li>fuse_loop_mt_proc()
+: <a class="el" href="fuse_8h.html#aadced4bb8ad64e622a2d0b9e6738c97b">fuse.h</a>
+</li>
+<li>fuse_lowlevel_new()
+: <a class="el" href="fuse__lowlevel_8h.html#ab71e91777def283987cd8a504e926d01">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_delete()
+: <a class="el" href="fuse__lowlevel_8h.html#a94893b3eb83fe2a218e80e43089670a1">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_inval_entry()
+: <a class="el" href="fuse__lowlevel_8h.html#ac250195a1e88bb7c1d10340558b30c8f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_inval_inode()
+: <a class="el" href="fuse__lowlevel_8h.html#a05b0e5326257af22062d90809801b730">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_poll()
+: <a class="el" href="fuse__lowlevel_8h.html#ab078685b1f480188031fc40aa2e2fbca">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_retrieve()
+: <a class="el" href="fuse__lowlevel_8h.html#a8b2a260132708b581b00e1066b43faa8">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_store()
+: <a class="el" href="fuse__lowlevel_8h.html#a4d12f831402f7f25de8bef2d2a82f402">fuse_lowlevel.h</a>
+</li>
+<li>fuse_main
+: <a class="el" href="fuse_8h.html#a61755930843c427b79622eda0ad8f083">fuse.h</a>
+</li>
+<li>fuse_main_real()
+: <a class="el" href="fuse_8h.html#a2098b9d60626bf749801d12f2d0d6fd3">fuse.h</a>
+</li>
+<li>FUSE_MAJOR_VERSION
+: <a class="el" href="fuse__common_8h.html#a2779d57c512b7b948992858653e95f0e">fuse_common.h</a>
+</li>
+<li>FUSE_MINOR_VERSION
+: <a class="el" href="fuse__common_8h.html#a8571aa4ec96e1685d31eeff07cb2f163">fuse_common.h</a>
+</li>
+<li>fuse_mount()
+: <a class="el" href="fuse__common_8h.html#a30d394a6127b20455bf5a4899e56e759">fuse_common.h</a>
+</li>
+<li>fuse_new()
+: <a class="el" href="fuse_8h.html#a5326844946defe4a50b3f4320786a0f4">fuse.h</a>
+</li>
+<li>fuse_opt_add_arg()
+: <a class="el" href="fuse__opt_8h.html#a21602e6a0fff64fc9c7b642d12382094">fuse_opt.h</a>
+</li>
+<li>fuse_opt_add_opt()
+: <a class="el" href="fuse__opt_8h.html#aaae525d5e959c5394bc323be0c1d02b0">fuse_opt.h</a>
+</li>
+<li>fuse_opt_add_opt_escaped()
+: <a class="el" href="fuse__opt_8h.html#a51a00d087d08bef250a53b9e4979b1cd">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_END
+: <a class="el" href="fuse__opt_8h.html#aca35962e17d189ceb5447f8eea11bd33">fuse_opt.h</a>
+</li>
+<li>fuse_opt_free_args()
+: <a class="el" href="fuse__opt_8h.html#a2cdf272429ab3869a5162976141b287d">fuse_opt.h</a>
+</li>
+<li>fuse_opt_insert_arg()
+: <a class="el" href="fuse__opt_8h.html#adb2922444d67f58e4233d21320386bc0">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY
+: <a class="el" href="fuse__opt_8h.html#a371d830a8aedd9e3f96d9bb31876a8f1">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_DISCARD
+: <a class="el" href="fuse__opt_8h.html#a6e97b6ce492f1baaaf0a4eb4970c9a2f">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_KEEP
+: <a class="el" href="fuse__opt_8h.html#a8533ff341f910c1bd05f10c8fcc35a04">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_NONOPT
+: <a class="el" href="fuse__opt_8h.html#a632b025441794a4e6fe59b7ab53bbfc4">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_OPT
+: <a class="el" href="fuse__opt_8h.html#a48cb1aea482de904a848651360117748">fuse_opt.h</a>
+</li>
+<li>fuse_opt_match()
+: <a class="el" href="fuse__opt_8h.html#af16c684bd2b10b7ac0ae299afa1e0e06">fuse_opt.h</a>
+</li>
+<li>fuse_opt_parse()
+: <a class="el" href="fuse__opt_8h.html#a539ef1f571c34f516c60c4cbe2901c0e">fuse_opt.h</a>
+</li>
+<li>fuse_opt_proc_t
+: <a class="el" href="fuse__opt_8h.html#a975525ccd73368c818ef2e3e917aeb33">fuse_opt.h</a>
+</li>
+<li>fuse_parse_cmdline()
+: <a class="el" href="fuse__common_8h.html#a971bb6dbde8b6d47dfd5c1fab8b30a1d">fuse_common.h</a>
+</li>
+<li>fuse_pollhandle_destroy()
+: <a class="el" href="fuse__common_8h.html#adf5027f8a38b2efc03858efd7fdc756a">fuse_common.h</a>
+</li>
+<li>fuse_process_cmd()
+: <a class="el" href="fuse_8h.html#a638b7477f87a2aca57ef0a5c4ca1d500">fuse.h</a>
+</li>
+<li>fuse_processor_t
+: <a class="el" href="fuse_8h.html#ab27948e20743f4c153f6ba6d71ca7182">fuse.h</a>
+</li>
+<li>fuse_read_cmd()
+: <a class="el" href="fuse_8h.html#aa5aaa31ed710ea1afe9467f10d523b21">fuse.h</a>
+</li>
+<li>fuse_register_module()
+: <a class="el" href="fuse_8h.html#ad6380ea6c7cb4a4a4cf421d808ce2b66">fuse.h</a>
+</li>
+<li>FUSE_REGISTER_MODULE
+: <a class="el" href="fuse_8h.html#af335784cf29289c7583f3312d98d2bcd">fuse.h</a>
+</li>
+<li>fuse_remove_signal_handlers()
+: <a class="el" href="fuse__common_8h.html#aeb674bbc11074c4fe520b952d6bfdd30">fuse_common.h</a>
+</li>
+<li>fuse_reply_attr()
+: <a class="el" href="fuse__lowlevel_8h.html#ad28378dc569019c32acdb4995d70be18">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_bmap()
+: <a class="el" href="fuse__lowlevel_8h.html#a65431e8196e0533257acad767f7b074f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_buf()
+: <a class="el" href="fuse__lowlevel_8h.html#a300a88b63ab7c8ca92853a97486448c0">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_create()
+: <a class="el" href="fuse__lowlevel_8h.html#abea78d22349198f8370d7cb91fbf05ed">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_data()
+: <a class="el" href="fuse__lowlevel_8h.html#a1242694fe0fb6e253a88b57795987302">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_entry()
+: <a class="el" href="fuse__lowlevel_8h.html#a672c45e126cd240f4bcd59bf9b7e3708">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_err()
+: <a class="el" href="fuse__lowlevel_8h.html#a2553c03f9a63c75e609e67f90a3a5d88">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_ioctl()
+: <a class="el" href="fuse__lowlevel_8h.html#adf7f34f470c04f276b7091ad3b3dcb31">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_ioctl_iov()
+: <a class="el" href="fuse__lowlevel_8h.html#a37381eb84c39e5fe3af9f3ef507aeeb7">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_ioctl_retry()
+: <a class="el" href="fuse__lowlevel_8h.html#a940683d07df12c24f56b4363aed90e4d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_iov()
+: <a class="el" href="fuse__lowlevel_8h.html#a5fbbf591a55f09c02cd54d34bdbfe0e9">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_lock()
+: <a class="el" href="fuse__lowlevel_8h.html#a135eda9b7d36fb4eaae2de58526d4f85">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_none()
+: <a class="el" href="fuse__lowlevel_8h.html#a85ae91390a6704dc26f8d80fed7d5678">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_open()
+: <a class="el" href="fuse__lowlevel_8h.html#a170f8c6b953d70928e83bcecee43bfdc">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_poll()
+: <a class="el" href="fuse__lowlevel_8h.html#a2172d260d34c76c25cd601870aee4220">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_readlink()
+: <a class="el" href="fuse__lowlevel_8h.html#a5a5872d7f73f0bd593e00788a4c7bbb7">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_statfs()
+: <a class="el" href="fuse__lowlevel_8h.html#aa1d95ec3ca674253baac3639ea10f0ff">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_write()
+: <a class="el" href="fuse__lowlevel_8h.html#aa3cfa73f61d6ef461ab5a3fbf859eb97">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_xattr()
+: <a class="el" href="fuse__lowlevel_8h.html#afed32e5d3e1f54d390103f79ebb8bd42">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_ctx()
+: <a class="el" href="fuse__lowlevel_8h.html#ad1d1963190eb93ae5667d32d2b387ca1">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_getgroups()
+: <a class="el" href="fuse__lowlevel_8h.html#a57f4dabcf044aafcdba6c4682b3a1869">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_interrupt_func()
+: <a class="el" href="fuse__lowlevel_8h.html#ab3cdb9744f033e37a72984489343940f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_interrupted()
+: <a class="el" href="fuse__lowlevel_8h.html#a52674fc627647f33e63c74267f0f1f9d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_t
+: <a class="el" href="fuse__lowlevel_8h.html#a33e2aa4a8905a05397292ae047cd2257">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_userdata()
+: <a class="el" href="fuse__lowlevel_8h.html#aab00273c65d124e44abcf2374f9c504b">fuse_lowlevel.h</a>
+</li>
+<li>FUSE_ROOT_ID
+: <a class="el" href="fuse__lowlevel_8h.html#a14d7299559cf05272b838cfc6388ef91">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_add_chan()
+: <a class="el" href="fuse__lowlevel_8h.html#adcc40a021ee1a21752e3c622f3d3692d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_data()
+: <a class="el" href="fuse__lowlevel_8h.html#ac58f69b8c0f7e9fbd45280fb1d68d9f5">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_destroy()
+: <a class="el" href="fuse__lowlevel_8h.html#a08b5503c4e9656f9c4bc88331233cc65">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_exit()
+: <a class="el" href="fuse__lowlevel_8h.html#a198429f3fbc23ef29ef9971271827690">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_exited()
+: <a class="el" href="fuse__lowlevel_8h.html#a41b12193fa1520ff658d65679f4e513c">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_loop()
+: <a class="el" href="fuse__lowlevel_8h.html#a5f1e538aa3287e251afbe985438c4249">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_loop_mt()
+: <a class="el" href="fuse__lowlevel_8h.html#afeffdee79e361c96b10ce798c56ed2cc">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_new()
+: <a class="el" href="fuse__lowlevel_8h.html#a28b7d09c6e87e3e375743c2ef6e06f0f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_next_chan()
+: <a class="el" href="fuse__lowlevel_8h.html#a8a6664baeee7a580928f959fd4968d5c">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_process()
+: <a class="el" href="fuse__lowlevel_8h.html#a210cb96700171ccbb5fe84a42b4613d8">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_process_buf()
+: <a class="el" href="fuse__lowlevel_8h.html#a58da9b49939ed7e60c906d99bbf7b21a">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_receive_buf()
+: <a class="el" href="fuse__lowlevel_8h.html#a7f7f424f58729d08af8ab7be91d93478">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_remove_chan()
+: <a class="el" href="fuse__lowlevel_8h.html#a93cb94614503b2249d15629c447dddb9">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_reset()
+: <a class="el" href="fuse__lowlevel_8h.html#ab3d015de77ae0edeb3157321e7a5c434">fuse_lowlevel.h</a>
+</li>
+<li>fuse_set_getcontext_func()
+: <a class="el" href="fuse_8h.html#adbd6a1fa417b704972554ed983e67b85">fuse.h</a>
+</li>
+<li>fuse_set_signal_handlers()
+: <a class="el" href="fuse__common_8h.html#a292dccc3c7b1799cb054efa2ba0c774b">fuse_common.h</a>
+</li>
+<li>fuse_setup()
+: <a class="el" href="fuse_8h.html#ab6dc1548ab6f04f048927dc09882563d">fuse.h</a>
+</li>
+<li>fuse_start_cleanup_thread()
+: <a class="el" href="fuse_8h.html#a4b2246caec521ec4ac84093f8c4b616d">fuse.h</a>
+</li>
+<li>fuse_stop_cleanup_thread()
+: <a class="el" href="fuse_8h.html#ad37fd69ba40d5c261f16e207e4a5b0ed">fuse.h</a>
+</li>
+<li>fuse_teardown()
+: <a class="el" href="fuse_8h.html#a87c736a7e6ee86348a9fdf83f6635199">fuse.h</a>
+</li>
+<li>fuse_unmount()
+: <a class="el" href="fuse__common_8h.html#a1b6448c8529f9fac068a35ef7a279d4d">fuse_common.h</a>
+</li>
+<li>fuse_version()
+: <a class="el" href="fuse__common_8h.html#ae04b2f721003f5540c71be65396c53c8">fuse_common.h</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,106 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Globals</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li class="current"><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li><a href="globals.html"><span>All</span></a></li>
+      <li><a href="globals_func.html"><span>Functions</span></a></li>
+      <li><a href="globals_type.html"><span>Typedefs</span></a></li>
+      <li><a href="globals_enum.html"><span>Enumerations</span></a></li>
+      <li><a href="globals_eval.html"><span>Enumerator</span></a></li>
+      <li class="current"><a href="globals_defs.html"><span>Macros</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+&#160;<ul>
+<li>FUSE_ARGS_INIT
+: <a class="el" href="fuse__opt_8h.html#a9bea40fe56b18be9aa110185ab7387ed">fuse_opt.h</a>
+</li>
+<li>FUSE_CAP_ASYNC_READ
+: <a class="el" href="fuse__common_8h.html#a4e1bacbb44d6dca9a82255c8069c3d69">fuse_common.h</a>
+</li>
+<li>FUSE_IOCTL_COMPAT
+: <a class="el" href="fuse__common_8h.html#ade38f8e8c463cd40af5bfeeebfa99486">fuse_common.h</a>
+</li>
+<li>fuse_main
+: <a class="el" href="fuse_8h.html#a61755930843c427b79622eda0ad8f083">fuse.h</a>
+</li>
+<li>FUSE_MAJOR_VERSION
+: <a class="el" href="fuse__common_8h.html#a2779d57c512b7b948992858653e95f0e">fuse_common.h</a>
+</li>
+<li>FUSE_MINOR_VERSION
+: <a class="el" href="fuse__common_8h.html#a8571aa4ec96e1685d31eeff07cb2f163">fuse_common.h</a>
+</li>
+<li>FUSE_OPT_END
+: <a class="el" href="fuse__opt_8h.html#aca35962e17d189ceb5447f8eea11bd33">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY
+: <a class="el" href="fuse__opt_8h.html#a371d830a8aedd9e3f96d9bb31876a8f1">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_DISCARD
+: <a class="el" href="fuse__opt_8h.html#a6e97b6ce492f1baaaf0a4eb4970c9a2f">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_KEEP
+: <a class="el" href="fuse__opt_8h.html#a8533ff341f910c1bd05f10c8fcc35a04">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_NONOPT
+: <a class="el" href="fuse__opt_8h.html#a632b025441794a4e6fe59b7ab53bbfc4">fuse_opt.h</a>
+</li>
+<li>FUSE_OPT_KEY_OPT
+: <a class="el" href="fuse__opt_8h.html#a48cb1aea482de904a848651360117748">fuse_opt.h</a>
+</li>
+<li>FUSE_REGISTER_MODULE
+: <a class="el" href="fuse_8h.html#af335784cf29289c7583f3312d98d2bcd">fuse.h</a>
+</li>
+<li>FUSE_ROOT_ID
+: <a class="el" href="fuse__lowlevel_8h.html#a14d7299559cf05272b838cfc6388ef91">fuse_lowlevel.h</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,70 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Globals</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li class="current"><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li><a href="globals.html"><span>All</span></a></li>
+      <li><a href="globals_func.html"><span>Functions</span></a></li>
+      <li><a href="globals_type.html"><span>Typedefs</span></a></li>
+      <li class="current"><a href="globals_enum.html"><span>Enumerations</span></a></li>
+      <li><a href="globals_eval.html"><span>Enumerator</span></a></li>
+      <li><a href="globals_defs.html"><span>Macros</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+&#160;<ul>
+<li>fuse_buf_copy_flags
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18">fuse_common.h</a>
+</li>
+<li>fuse_buf_flags
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58">fuse_common.h</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,85 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Globals</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li class="current"><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li><a href="globals.html"><span>All</span></a></li>
+      <li><a href="globals_func.html"><span>Functions</span></a></li>
+      <li><a href="globals_type.html"><span>Typedefs</span></a></li>
+      <li><a href="globals_enum.html"><span>Enumerations</span></a></li>
+      <li class="current"><a href="globals_eval.html"><span>Enumerator</span></a></li>
+      <li><a href="globals_defs.html"><span>Macros</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+&#160;<ul>
+<li>FUSE_BUF_FD_RETRY
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58af89b4b00a2d4a06d8458b320c2cb28cf">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_FD_SEEK
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58ad67d5c6075febad0594f06d46d02bfa9">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_FORCE_SPLICE
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18a375767de945f5178e8949d284abf1f5b">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_IS_FD
+: <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58affd5b3b7e9cdd5f89b3126eea96e033b">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_NO_SPLICE
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18adcef8052c48f314d4d9f9f05a5b4f838">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_SPLICE_MOVE
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18af239e556066a5d73b3ff542216b157b9">fuse_common.h</a>
+</li>
+<li>FUSE_BUF_SPLICE_NONBLOCK
+: <a class="el" href="fuse__common_8h.html#aec0ad71a3e8c357ebe7e87cdecbdbe18a32ec833f1eb4b5cd9283cf9d93021037">fuse_common.h</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,353 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Globals</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li class="current"><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li><a href="globals.html"><span>All</span></a></li>
+      <li class="current"><a href="globals_func.html"><span>Functions</span></a></li>
+      <li><a href="globals_type.html"><span>Typedefs</span></a></li>
+      <li><a href="globals_enum.html"><span>Enumerations</span></a></li>
+      <li><a href="globals_eval.html"><span>Enumerator</span></a></li>
+      <li><a href="globals_defs.html"><span>Macros</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow4" class="tabs3">
+    <ul class="tablist">
+      <li class="current"><a href="#index_f"><span>f</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+&#160;
+
+<h3><a class="anchor" id="index_f"></a>- f -</h3><ul>
+<li>fuse_add_direntry()
+: <a class="el" href="fuse__lowlevel_8h.html#ad1957bcc8ece8c90f16c42c4daf3053f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_buf_copy()
+: <a class="el" href="fuse__common_8h.html#a9ca301390fb5e85b85153abb1891a3f7">fuse_common.h</a>
+</li>
+<li>fuse_buf_size()
+: <a class="el" href="fuse__common_8h.html#a4327f41b2fe1ca84151b407169bd86c0">fuse_common.h</a>
+</li>
+<li>fuse_chan_bufsize()
+: <a class="el" href="fuse__lowlevel_8h.html#ab2018fab0f56f1b15f6e5fd9ff63641c">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_data()
+: <a class="el" href="fuse__lowlevel_8h.html#a50696378a60c9b5daea8de2fbcf1dc5d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_destroy()
+: <a class="el" href="fuse__lowlevel_8h.html#a7a88655f900be214db61844337879fa5">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_fd()
+: <a class="el" href="fuse__lowlevel_8h.html#aed5405bd1725a4da8610ce1a1fe49307">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_new()
+: <a class="el" href="fuse__lowlevel_8h.html#a0a9a9cd6bffbd37ee1971b3dfe183140">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_recv()
+: <a class="el" href="fuse__lowlevel_8h.html#afa1748ec47595b3ab7be93ad29e55fcb">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_send()
+: <a class="el" href="fuse__lowlevel_8h.html#ad53f74694d7c8605d956d48ab04b55e9">fuse_lowlevel.h</a>
+</li>
+<li>fuse_chan_session()
+: <a class="el" href="fuse__lowlevel_8h.html#a0d0c57c5be8fe4884c10270fcaad4710">fuse_lowlevel.h</a>
+</li>
+<li>fuse_clean_cache()
+: <a class="el" href="fuse_8h.html#a90f104e6d4e01480161a3300bddbecbe">fuse.h</a>
+</li>
+<li>fuse_daemonize()
+: <a class="el" href="fuse__common_8h.html#af1857d2209952f49a762aff39f3cd8bd">fuse_common.h</a>
+</li>
+<li>fuse_destroy()
+: <a class="el" href="fuse_8h.html#a0d47cac8a295efd5370d7af059e4d14f">fuse.h</a>
+</li>
+<li>fuse_exit()
+: <a class="el" href="fuse_8h.html#a9024935b211288c1869dc7566895d739">fuse.h</a>
+</li>
+<li>fuse_exited()
+: <a class="el" href="fuse_8h.html#a3035da06904362a9e924d77c2e460258">fuse.h</a>
+</li>
+<li>fuse_fs_new()
+: <a class="el" href="fuse_8h.html#ad4b0e6955b2fd720542c6c3262fb8761">fuse.h</a>
+</li>
+<li>fuse_get_context()
+: <a class="el" href="fuse_8h.html#a9a0f2a6603cb1e21f5e4c1aec84a3bcc">fuse.h</a>
+</li>
+<li>fuse_get_session()
+: <a class="el" href="fuse_8h.html#a03baa193b5bfcbe625afbc62e9b97e91">fuse.h</a>
+</li>
+<li>fuse_getgroups()
+: <a class="el" href="fuse_8h.html#a04273db088e57d8242caa388193b6958">fuse.h</a>
+</li>
+<li>fuse_interrupted()
+: <a class="el" href="fuse_8h.html#a0514ca828e6a02a330dcf037292c8803">fuse.h</a>
+</li>
+<li>fuse_invalidate()
+: <a class="el" href="fuse_8h.html#a390d7e520ea2be2471ffa366cbc1f37d">fuse.h</a>
+</li>
+<li>fuse_loop()
+: <a class="el" href="fuse_8h.html#a6ea805c47ccc960497dfd64e12081159">fuse.h</a>
+</li>
+<li>fuse_loop_mt()
+: <a class="el" href="fuse_8h.html#a79387240dad1f77417fd178f4b9ef0a0">fuse.h</a>
+</li>
+<li>fuse_loop_mt_proc()
+: <a class="el" href="fuse_8h.html#aadced4bb8ad64e622a2d0b9e6738c97b">fuse.h</a>
+</li>
+<li>fuse_lowlevel_new()
+: <a class="el" href="fuse__lowlevel_8h.html#ab71e91777def283987cd8a504e926d01">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_delete()
+: <a class="el" href="fuse__lowlevel_8h.html#a94893b3eb83fe2a218e80e43089670a1">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_inval_entry()
+: <a class="el" href="fuse__lowlevel_8h.html#ac250195a1e88bb7c1d10340558b30c8f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_inval_inode()
+: <a class="el" href="fuse__lowlevel_8h.html#a05b0e5326257af22062d90809801b730">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_poll()
+: <a class="el" href="fuse__lowlevel_8h.html#ab078685b1f480188031fc40aa2e2fbca">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_retrieve()
+: <a class="el" href="fuse__lowlevel_8h.html#a8b2a260132708b581b00e1066b43faa8">fuse_lowlevel.h</a>
+</li>
+<li>fuse_lowlevel_notify_store()
+: <a class="el" href="fuse__lowlevel_8h.html#a4d12f831402f7f25de8bef2d2a82f402">fuse_lowlevel.h</a>
+</li>
+<li>fuse_main_real()
+: <a class="el" href="fuse_8h.html#a2098b9d60626bf749801d12f2d0d6fd3">fuse.h</a>
+</li>
+<li>fuse_mount()
+: <a class="el" href="fuse__common_8h.html#a30d394a6127b20455bf5a4899e56e759">fuse_common.h</a>
+</li>
+<li>fuse_new()
+: <a class="el" href="fuse_8h.html#a5326844946defe4a50b3f4320786a0f4">fuse.h</a>
+</li>
+<li>fuse_opt_add_arg()
+: <a class="el" href="fuse__opt_8h.html#a21602e6a0fff64fc9c7b642d12382094">fuse_opt.h</a>
+</li>
+<li>fuse_opt_add_opt()
+: <a class="el" href="fuse__opt_8h.html#aaae525d5e959c5394bc323be0c1d02b0">fuse_opt.h</a>
+</li>
+<li>fuse_opt_add_opt_escaped()
+: <a class="el" href="fuse__opt_8h.html#a51a00d087d08bef250a53b9e4979b1cd">fuse_opt.h</a>
+</li>
+<li>fuse_opt_free_args()
+: <a class="el" href="fuse__opt_8h.html#a2cdf272429ab3869a5162976141b287d">fuse_opt.h</a>
+</li>
+<li>fuse_opt_insert_arg()
+: <a class="el" href="fuse__opt_8h.html#adb2922444d67f58e4233d21320386bc0">fuse_opt.h</a>
+</li>
+<li>fuse_opt_match()
+: <a class="el" href="fuse__opt_8h.html#af16c684bd2b10b7ac0ae299afa1e0e06">fuse_opt.h</a>
+</li>
+<li>fuse_opt_parse()
+: <a class="el" href="fuse__opt_8h.html#a539ef1f571c34f516c60c4cbe2901c0e">fuse_opt.h</a>
+</li>
+<li>fuse_parse_cmdline()
+: <a class="el" href="fuse__common_8h.html#a971bb6dbde8b6d47dfd5c1fab8b30a1d">fuse_common.h</a>
+</li>
+<li>fuse_pollhandle_destroy()
+: <a class="el" href="fuse__common_8h.html#adf5027f8a38b2efc03858efd7fdc756a">fuse_common.h</a>
+</li>
+<li>fuse_process_cmd()
+: <a class="el" href="fuse_8h.html#a638b7477f87a2aca57ef0a5c4ca1d500">fuse.h</a>
+</li>
+<li>fuse_read_cmd()
+: <a class="el" href="fuse_8h.html#aa5aaa31ed710ea1afe9467f10d523b21">fuse.h</a>
+</li>
+<li>fuse_register_module()
+: <a class="el" href="fuse_8h.html#ad6380ea6c7cb4a4a4cf421d808ce2b66">fuse.h</a>
+</li>
+<li>fuse_remove_signal_handlers()
+: <a class="el" href="fuse__common_8h.html#aeb674bbc11074c4fe520b952d6bfdd30">fuse_common.h</a>
+</li>
+<li>fuse_reply_attr()
+: <a class="el" href="fuse__lowlevel_8h.html#ad28378dc569019c32acdb4995d70be18">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_bmap()
+: <a class="el" href="fuse__lowlevel_8h.html#a65431e8196e0533257acad767f7b074f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_buf()
+: <a class="el" href="fuse__lowlevel_8h.html#a300a88b63ab7c8ca92853a97486448c0">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_create()
+: <a class="el" href="fuse__lowlevel_8h.html#abea78d22349198f8370d7cb91fbf05ed">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_data()
+: <a class="el" href="fuse__lowlevel_8h.html#a1242694fe0fb6e253a88b57795987302">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_entry()
+: <a class="el" href="fuse__lowlevel_8h.html#a672c45e126cd240f4bcd59bf9b7e3708">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_err()
+: <a class="el" href="fuse__lowlevel_8h.html#a2553c03f9a63c75e609e67f90a3a5d88">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_ioctl()
+: <a class="el" href="fuse__lowlevel_8h.html#adf7f34f470c04f276b7091ad3b3dcb31">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_ioctl_iov()
+: <a class="el" href="fuse__lowlevel_8h.html#a37381eb84c39e5fe3af9f3ef507aeeb7">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_ioctl_retry()
+: <a class="el" href="fuse__lowlevel_8h.html#a940683d07df12c24f56b4363aed90e4d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_iov()
+: <a class="el" href="fuse__lowlevel_8h.html#a5fbbf591a55f09c02cd54d34bdbfe0e9">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_lock()
+: <a class="el" href="fuse__lowlevel_8h.html#a135eda9b7d36fb4eaae2de58526d4f85">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_none()
+: <a class="el" href="fuse__lowlevel_8h.html#a85ae91390a6704dc26f8d80fed7d5678">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_open()
+: <a class="el" href="fuse__lowlevel_8h.html#a170f8c6b953d70928e83bcecee43bfdc">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_poll()
+: <a class="el" href="fuse__lowlevel_8h.html#a2172d260d34c76c25cd601870aee4220">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_readlink()
+: <a class="el" href="fuse__lowlevel_8h.html#a5a5872d7f73f0bd593e00788a4c7bbb7">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_statfs()
+: <a class="el" href="fuse__lowlevel_8h.html#aa1d95ec3ca674253baac3639ea10f0ff">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_write()
+: <a class="el" href="fuse__lowlevel_8h.html#aa3cfa73f61d6ef461ab5a3fbf859eb97">fuse_lowlevel.h</a>
+</li>
+<li>fuse_reply_xattr()
+: <a class="el" href="fuse__lowlevel_8h.html#afed32e5d3e1f54d390103f79ebb8bd42">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_ctx()
+: <a class="el" href="fuse__lowlevel_8h.html#ad1d1963190eb93ae5667d32d2b387ca1">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_getgroups()
+: <a class="el" href="fuse__lowlevel_8h.html#a57f4dabcf044aafcdba6c4682b3a1869">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_interrupt_func()
+: <a class="el" href="fuse__lowlevel_8h.html#ab3cdb9744f033e37a72984489343940f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_interrupted()
+: <a class="el" href="fuse__lowlevel_8h.html#a52674fc627647f33e63c74267f0f1f9d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_req_userdata()
+: <a class="el" href="fuse__lowlevel_8h.html#aab00273c65d124e44abcf2374f9c504b">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_add_chan()
+: <a class="el" href="fuse__lowlevel_8h.html#adcc40a021ee1a21752e3c622f3d3692d">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_data()
+: <a class="el" href="fuse__lowlevel_8h.html#ac58f69b8c0f7e9fbd45280fb1d68d9f5">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_destroy()
+: <a class="el" href="fuse__lowlevel_8h.html#a08b5503c4e9656f9c4bc88331233cc65">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_exit()
+: <a class="el" href="fuse__lowlevel_8h.html#a198429f3fbc23ef29ef9971271827690">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_exited()
+: <a class="el" href="fuse__lowlevel_8h.html#a41b12193fa1520ff658d65679f4e513c">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_loop()
+: <a class="el" href="fuse__lowlevel_8h.html#a5f1e538aa3287e251afbe985438c4249">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_loop_mt()
+: <a class="el" href="fuse__lowlevel_8h.html#afeffdee79e361c96b10ce798c56ed2cc">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_new()
+: <a class="el" href="fuse__lowlevel_8h.html#a28b7d09c6e87e3e375743c2ef6e06f0f">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_next_chan()
+: <a class="el" href="fuse__lowlevel_8h.html#a8a6664baeee7a580928f959fd4968d5c">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_process()
+: <a class="el" href="fuse__lowlevel_8h.html#a210cb96700171ccbb5fe84a42b4613d8">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_process_buf()
+: <a class="el" href="fuse__lowlevel_8h.html#a58da9b49939ed7e60c906d99bbf7b21a">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_receive_buf()
+: <a class="el" href="fuse__lowlevel_8h.html#a7f7f424f58729d08af8ab7be91d93478">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_remove_chan()
+: <a class="el" href="fuse__lowlevel_8h.html#a93cb94614503b2249d15629c447dddb9">fuse_lowlevel.h</a>
+</li>
+<li>fuse_session_reset()
+: <a class="el" href="fuse__lowlevel_8h.html#ab3d015de77ae0edeb3157321e7a5c434">fuse_lowlevel.h</a>
+</li>
+<li>fuse_set_getcontext_func()
+: <a class="el" href="fuse_8h.html#adbd6a1fa417b704972554ed983e67b85">fuse.h</a>
+</li>
+<li>fuse_set_signal_handlers()
+: <a class="el" href="fuse__common_8h.html#a292dccc3c7b1799cb054efa2ba0c774b">fuse_common.h</a>
+</li>
+<li>fuse_setup()
+: <a class="el" href="fuse_8h.html#ab6dc1548ab6f04f048927dc09882563d">fuse.h</a>
+</li>
+<li>fuse_start_cleanup_thread()
+: <a class="el" href="fuse_8h.html#a4b2246caec521ec4ac84093f8c4b616d">fuse.h</a>
+</li>
+<li>fuse_stop_cleanup_thread()
+: <a class="el" href="fuse_8h.html#ad37fd69ba40d5c261f16e207e4a5b0ed">fuse.h</a>
+</li>
+<li>fuse_teardown()
+: <a class="el" href="fuse_8h.html#a87c736a7e6ee86348a9fdf83f6635199">fuse.h</a>
+</li>
+<li>fuse_unmount()
+: <a class="el" href="fuse__common_8h.html#a1b6448c8529f9fac068a35ef7a279d4d">fuse_common.h</a>
+</li>
+<li>fuse_version()
+: <a class="el" href="fuse__common_8h.html#ae04b2f721003f5540c71be65396c53c8">fuse_common.h</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,82 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Globals</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li class="current"><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="files.html"><span>File&#160;List</span></a></li>
+      <li class="current"><a href="globals.html"><span>Globals</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow3" class="tabs2">
+    <ul class="tablist">
+      <li><a href="globals.html"><span>All</span></a></li>
+      <li><a href="globals_func.html"><span>Functions</span></a></li>
+      <li class="current"><a href="globals_type.html"><span>Typedefs</span></a></li>
+      <li><a href="globals_enum.html"><span>Enumerations</span></a></li>
+      <li><a href="globals_eval.html"><span>Enumerator</span></a></li>
+      <li><a href="globals_defs.html"><span>Macros</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="contents">
+&#160;<ul>
+<li>fuse_fill_dir_t
+: <a class="el" href="fuse_8h.html#ae2a2054f9852fd6020c26a1bcc7f1042">fuse.h</a>
+</li>
+<li>fuse_ino_t
+: <a class="el" href="fuse__lowlevel_8h.html#ab419149c707451eaf61b75afb852e016">fuse_lowlevel.h</a>
+</li>
+<li>fuse_interrupt_func_t
+: <a class="el" href="fuse__lowlevel_8h.html#a5bb8b555b1d9d8a38b8c6cac28d51f1e">fuse_lowlevel.h</a>
+</li>
+<li>fuse_opt_proc_t
+: <a class="el" href="fuse__opt_8h.html#a975525ccd73368c818ef2e3e917aeb33">fuse_opt.h</a>
+</li>
+<li>fuse_processor_t
+: <a class="el" href="fuse_8h.html#ab27948e20743f4c153f6ba6d71ca7182">fuse.h</a>
+</li>
+<li>fuse_req_t
+: <a class="el" href="fuse__lowlevel_8h.html#a33e2aa4a8905a05397292ae047cd2257">fuse_lowlevel.h</a>
+</li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,50 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: Main Page</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li class="current"><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="headertitle">
+<div class="title">fuse Documentation</div>  </div>
+</div><!--header-->
+<div class="contents">
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,115 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_args Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_args Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_opt.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a501883d1eababa08e05b0c802b31e11d"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__args.html#a501883d1eababa08e05b0c802b31e11d">argc</a></td></tr>
+<tr class="separator:a501883d1eababa08e05b0c802b31e11d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a6f90bec2356aff03de79baaca65276b6"><td class="memItemLeft" align="right" valign="top">char **&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__args.html#a6f90bec2356aff03de79baaca65276b6">argv</a></td></tr>
+<tr class="separator:a6f90bec2356aff03de79baaca65276b6"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a3fdc7eb5448d89a4ecbabba88cbafe5f"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__args.html#a3fdc7eb5448d89a4ecbabba88cbafe5f">allocated</a></td></tr>
+<tr class="separator:a3fdc7eb5448d89a4ecbabba88cbafe5f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Argument list </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a3fdc7eb5448d89a4ecbabba88cbafe5f"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_args::allocated</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Is 'argv' allocated? </p>
+
+</div>
+</div>
+<a class="anchor" id="a501883d1eababa08e05b0c802b31e11d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_args::argc</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Argument count </p>
+
+</div>
+</div>
+<a class="anchor" id="a6f90bec2356aff03de79baaca65276b6"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">char** fuse_args::argv</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Argument vector. NULL terminated </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__opt_8h.html">fuse_opt.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,149 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_buf Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_buf Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_common.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:afb58c1e18f434d1d4edb784d00e2e13d"><td class="memItemLeft" align="right" valign="top">size_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__buf.html#afb58c1e18f434d1d4edb784d00e2e13d">size</a></td></tr>
+<tr class="separator:afb58c1e18f434d1d4edb784d00e2e13d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1928e204554f2d37cb8dac28a8a2f28c"><td class="memItemLeft" align="right" valign="top">enum <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58">fuse_buf_flags</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__buf.html#a1928e204554f2d37cb8dac28a8a2f28c">flags</a></td></tr>
+<tr class="separator:a1928e204554f2d37cb8dac28a8a2f28c"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a537f80b7703cbfc860dfaf4b86de79ae"><td class="memItemLeft" align="right" valign="top">void *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__buf.html#a537f80b7703cbfc860dfaf4b86de79ae">mem</a></td></tr>
+<tr class="separator:a537f80b7703cbfc860dfaf4b86de79ae"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a62b2ae82904ac4355142984b9dd90d68"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__buf.html#a62b2ae82904ac4355142984b9dd90d68">fd</a></td></tr>
+<tr class="separator:a62b2ae82904ac4355142984b9dd90d68"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a8de23b7869b06b9a9caef6beb7c9e88e"><td class="memItemLeft" align="right" valign="top">off_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__buf.html#a8de23b7869b06b9a9caef6beb7c9e88e">pos</a></td></tr>
+<tr class="separator:a8de23b7869b06b9a9caef6beb7c9e88e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Single data buffer</p>
+<p>Generic data buffer for I/O, extended attributes, etc... Data may be supplied as a memory pointer or as a file descriptor </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a62b2ae82904ac4355142984b9dd90d68"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_buf::fd</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>File descriptor</p>
+<p>Used if FUSE_BUF_IS_FD flag is set. </p>
+
+</div>
+</div>
+<a class="anchor" id="a1928e204554f2d37cb8dac28a8a2f28c"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">enum <a class="el" href="fuse__common_8h.html#a5e36b839c4dbf0439bd85b61c7213a58">fuse_buf_flags</a> fuse_buf::flags</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Buffer flags </p>
+
+</div>
+</div>
+<a class="anchor" id="a537f80b7703cbfc860dfaf4b86de79ae"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void* fuse_buf::mem</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Memory pointer</p>
+<p>Used unless FUSE_BUF_IS_FD flag is set. </p>
+
+</div>
+</div>
+<a class="anchor" id="a8de23b7869b06b9a9caef6beb7c9e88e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">off_t fuse_buf::pos</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>File position</p>
+<p>Used if FUSE_BUF_FD_SEEK flag is set. </p>
+
+</div>
+</div>
+<a class="anchor" id="afb58c1e18f434d1d4edb784d00e2e13d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">size_t fuse_buf::size</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Size of data in bytes </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__common_8h.html">fuse_common.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,132 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_bufvec Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_bufvec Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_common.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:ac303661a9c39ade1feeb05d8238b4ed6"><td class="memItemLeft" align="right" valign="top">size_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__bufvec.html#ac303661a9c39ade1feeb05d8238b4ed6">count</a></td></tr>
+<tr class="separator:ac303661a9c39ade1feeb05d8238b4ed6"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a41cc18cb303ee16d20b3ae1ebb0ef830"><td class="memItemLeft" align="right" valign="top">size_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__bufvec.html#a41cc18cb303ee16d20b3ae1ebb0ef830">idx</a></td></tr>
+<tr class="separator:a41cc18cb303ee16d20b3ae1ebb0ef830"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a0fbb583168d52562f0f848562ecf63bc"><td class="memItemLeft" align="right" valign="top">size_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__bufvec.html#a0fbb583168d52562f0f848562ecf63bc">off</a></td></tr>
+<tr class="separator:a0fbb583168d52562f0f848562ecf63bc"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a754caca61fdf8107d28b510505a033bb"><td class="memItemLeft" align="right" valign="top">struct <a class="el" href="structfuse__buf.html">fuse_buf</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__bufvec.html#a754caca61fdf8107d28b510505a033bb">buf</a> [1]</td></tr>
+<tr class="separator:a754caca61fdf8107d28b510505a033bb"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Data buffer vector</p>
+<p>An array of data buffers, each containing a memory pointer or a file descriptor.</p>
+<p>Allocate dynamically to add more than one buffer. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a754caca61fdf8107d28b510505a033bb"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct <a class="el" href="structfuse__buf.html">fuse_buf</a> fuse_bufvec::buf[1]</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Array of buffers </p>
+
+</div>
+</div>
+<a class="anchor" id="ac303661a9c39ade1feeb05d8238b4ed6"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">size_t fuse_bufvec::count</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Number of buffers in the array </p>
+
+</div>
+</div>
+<a class="anchor" id="a41cc18cb303ee16d20b3ae1ebb0ef830"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">size_t fuse_bufvec::idx</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Index of current buffer within the array </p>
+
+</div>
+</div>
+<a class="anchor" id="a0fbb583168d52562f0f848562ecf63bc"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">size_t fuse_bufvec::off</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Current offset within the current buffer </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__common_8h.html">fuse_common.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,141 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_chan_ops Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_chan_ops Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_lowlevel.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a622c80d319253941c6f71963261bff39"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__chan__ops.html#a622c80d319253941c6f71963261bff39">receive</a> )(struct fuse_chan **chp, char *buf, size_t size)</td></tr>
+<tr class="separator:a622c80d319253941c6f71963261bff39"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a5dadbc392d24d80a53c71d50daa0b59c"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__chan__ops.html#a5dadbc392d24d80a53c71d50daa0b59c">send</a> )(struct fuse_chan *ch, const struct iovec iov[], size_t count)</td></tr>
+<tr class="separator:a5dadbc392d24d80a53c71d50daa0b59c"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a5df2257938552c436142f1c790667f74"><td class="memItemLeft" align="right" valign="top">void(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__chan__ops.html#a5df2257938552c436142f1c790667f74">destroy</a> )(struct fuse_chan *ch)</td></tr>
+<tr class="separator:a5df2257938552c436142f1c790667f74"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Channel operations</p>
+<p>This is used in channel creation </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a5df2257938552c436142f1c790667f74"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void(* fuse_chan_ops::destroy)(struct fuse_chan *ch)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Destroy the channel</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">ch</td><td>the channel </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="a622c80d319253941c6f71963261bff39"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_chan_ops::receive)(struct fuse_chan **chp, char *buf, size_t size)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Hook for receiving a raw request</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">ch</td><td>pointer to the channel </td></tr>
+    <tr><td class="paramname">buf</td><td>the buffer to store the request in </td></tr>
+    <tr><td class="paramname">size</td><td>the size of the buffer </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the actual size of the raw request, or -1 on error </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a5dadbc392d24d80a53c71d50daa0b59c"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_chan_ops::send)(struct fuse_chan *ch, const struct iovec iov[], size_t count)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Hook for sending a raw reply</p>
+<p>A return value of -ENOENT means, that the request was interrupted, and the reply was discarded</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">ch</td><td>the channel </td></tr>
+    <tr><td class="paramname">iov</td><td>vector of blocks </td></tr>
+    <tr><td class="paramname">count</td><td>the number of blocks in vector </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>zero on success, -errno on failure </dd></dl>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__lowlevel_8h.html">fuse_lowlevel.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,221 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_conn_info Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_conn_info Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_common.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a69c606abe81d16214d14ab58bad60062"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#a69c606abe81d16214d14ab58bad60062">proto_major</a></td></tr>
+<tr class="separator:a69c606abe81d16214d14ab58bad60062"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a7a99196bc17f9b91622f6c1353da5f85"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#a7a99196bc17f9b91622f6c1353da5f85">proto_minor</a></td></tr>
+<tr class="separator:a7a99196bc17f9b91622f6c1353da5f85"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a25c9b670226641a2ccdb6bd0c74082b6"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#a25c9b670226641a2ccdb6bd0c74082b6">async_read</a></td></tr>
+<tr class="separator:a25c9b670226641a2ccdb6bd0c74082b6"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad5009eace718861580e1260d241432d9"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#ad5009eace718861580e1260d241432d9">max_write</a></td></tr>
+<tr class="separator:ad5009eace718861580e1260d241432d9"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:acb560435478ca7bfb3dbf7df4c0f2dfe"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#acb560435478ca7bfb3dbf7df4c0f2dfe">max_readahead</a></td></tr>
+<tr class="separator:acb560435478ca7bfb3dbf7df4c0f2dfe"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a8a1c61f5d7cc14249fb6971165bb958e"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#a8a1c61f5d7cc14249fb6971165bb958e">capable</a></td></tr>
+<tr class="separator:a8a1c61f5d7cc14249fb6971165bb958e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:af45de81548b591f3004353a324e4e04d"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#af45de81548b591f3004353a324e4e04d">want</a></td></tr>
+<tr class="separator:af45de81548b591f3004353a324e4e04d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a5f9e695735727343448ae1e1a86dfa03"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#a5f9e695735727343448ae1e1a86dfa03">max_background</a></td></tr>
+<tr class="separator:a5f9e695735727343448ae1e1a86dfa03"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a2ce707ca8bfd6f6669557db7f37bb1ad"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#a2ce707ca8bfd6f6669557db7f37bb1ad">congestion_threshold</a></td></tr>
+<tr class="separator:a2ce707ca8bfd6f6669557db7f37bb1ad"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ac036677ef99574c0faba807b0cfee0de"><td class="memItemLeft" align="right" valign="top">unsigned&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__conn__info.html#ac036677ef99574c0faba807b0cfee0de">reserved</a> [23]</td></tr>
+<tr class="separator:ac036677ef99574c0faba807b0cfee0de"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Connection information, passed to the -&gt;init() method</p>
+<p>Some of the elements are read-write, these can be changed to indicate the value requested by the filesystem. The requested value must usually be smaller than the indicated value. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a25c9b670226641a2ccdb6bd0c74082b6"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::async_read</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Is asynchronous read supported (read-write) </p>
+
+</div>
+</div>
+<a class="anchor" id="a8a1c61f5d7cc14249fb6971165bb958e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::capable</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Capability flags, that the kernel supports </p>
+
+</div>
+</div>
+<a class="anchor" id="a2ce707ca8bfd6f6669557db7f37bb1ad"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::congestion_threshold</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Kernel congestion threshold parameter </p>
+
+</div>
+</div>
+<a class="anchor" id="a5f9e695735727343448ae1e1a86dfa03"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::max_background</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Maximum number of backgrounded requests </p>
+
+</div>
+</div>
+<a class="anchor" id="acb560435478ca7bfb3dbf7df4c0f2dfe"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::max_readahead</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Maximum readahead </p>
+
+</div>
+</div>
+<a class="anchor" id="ad5009eace718861580e1260d241432d9"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::max_write</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Maximum size of the write buffer </p>
+
+</div>
+</div>
+<a class="anchor" id="a69c606abe81d16214d14ab58bad60062"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::proto_major</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Major version of the protocol (read-only) </p>
+
+</div>
+</div>
+<a class="anchor" id="a7a99196bc17f9b91622f6c1353da5f85"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::proto_minor</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Minor version of the protocol (read-only) </p>
+
+</div>
+</div>
+<a class="anchor" id="ac036677ef99574c0faba807b0cfee0de"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::reserved[23]</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>For future use. </p>
+
+</div>
+</div>
+<a class="anchor" id="af45de81548b591f3004353a324e4e04d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned fuse_conn_info::want</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Capability flags, that the filesystem wants to enable </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__common_8h.html">fuse_common.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,161 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_context Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_context Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a8872cbd7e8d0269fb5cbd1ed40e60a19"><td class="memItemLeft" align="right" valign="top">struct fuse *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__context.html#a8872cbd7e8d0269fb5cbd1ed40e60a19">fuse</a></td></tr>
+<tr class="separator:a8872cbd7e8d0269fb5cbd1ed40e60a19"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a3b71993170253c519e85736524201bf4"><td class="memItemLeft" align="right" valign="top">uid_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__context.html#a3b71993170253c519e85736524201bf4">uid</a></td></tr>
+<tr class="separator:a3b71993170253c519e85736524201bf4"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab131a0e5df17a04126ba88b7614a5cf8"><td class="memItemLeft" align="right" valign="top">gid_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__context.html#ab131a0e5df17a04126ba88b7614a5cf8">gid</a></td></tr>
+<tr class="separator:ab131a0e5df17a04126ba88b7614a5cf8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a79fb9aba1169e9a1cdbc6377ae1b3a6a"><td class="memItemLeft" align="right" valign="top">pid_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__context.html#a79fb9aba1169e9a1cdbc6377ae1b3a6a">pid</a></td></tr>
+<tr class="separator:a79fb9aba1169e9a1cdbc6377ae1b3a6a"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a198911619cb8ee1a0b11302b94b6027e"><td class="memItemLeft" align="right" valign="top">void *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__context.html#a198911619cb8ee1a0b11302b94b6027e">private_data</a></td></tr>
+<tr class="separator:a198911619cb8ee1a0b11302b94b6027e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ac02329c0eacbd034fd0b44b1c0cb2c81"><td class="memItemLeft" align="right" valign="top">mode_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__context.html#ac02329c0eacbd034fd0b44b1c0cb2c81">umask</a></td></tr>
+<tr class="separator:ac02329c0eacbd034fd0b44b1c0cb2c81"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Extra context that may be needed by some filesystems</p>
+<p>The uid, gid and pid fields are not filled in case of a writepage operation. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a8872cbd7e8d0269fb5cbd1ed40e60a19"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse* fuse_context::fuse</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Pointer to the fuse object </p>
+
+</div>
+</div>
+<a class="anchor" id="ab131a0e5df17a04126ba88b7614a5cf8"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">gid_t fuse_context::gid</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Group ID of the calling process </p>
+
+</div>
+</div>
+<a class="anchor" id="a79fb9aba1169e9a1cdbc6377ae1b3a6a"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">pid_t fuse_context::pid</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Thread ID of the calling process </p>
+
+</div>
+</div>
+<a class="anchor" id="a198911619cb8ee1a0b11302b94b6027e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void* fuse_context::private_data</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Private filesystem data </p>
+
+</div>
+</div>
+<a class="anchor" id="a3b71993170253c519e85736524201bf4"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">uid_t fuse_context::uid</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>User ID of the calling process </p>
+
+</div>
+</div>
+<a class="anchor" id="ac02329c0eacbd034fd0b44b1c0cb2c81"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">mode_t fuse_context::umask</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Umask of the calling process (introduced in version 2.8) </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse_8h.html">fuse.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,130 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_ctx Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_ctx Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_lowlevel.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:abf920c4533df81789fd284aa05ee5771"><td class="memItemLeft" align="right" valign="top">uid_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__ctx.html#abf920c4533df81789fd284aa05ee5771">uid</a></td></tr>
+<tr class="separator:abf920c4533df81789fd284aa05ee5771"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a923348304ee26adb3a43c31a4bac9583"><td class="memItemLeft" align="right" valign="top">gid_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__ctx.html#a923348304ee26adb3a43c31a4bac9583">gid</a></td></tr>
+<tr class="separator:a923348304ee26adb3a43c31a4bac9583"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a056667c9ce324cb56b833e981aef8b5b"><td class="memItemLeft" align="right" valign="top">pid_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__ctx.html#a056667c9ce324cb56b833e981aef8b5b">pid</a></td></tr>
+<tr class="separator:a056667c9ce324cb56b833e981aef8b5b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aa6932619b51a5bfe4d1362ac4c1d2ce8"><td class="memItemLeft" align="right" valign="top">mode_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__ctx.html#aa6932619b51a5bfe4d1362ac4c1d2ce8">umask</a></td></tr>
+<tr class="separator:aa6932619b51a5bfe4d1362ac4c1d2ce8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Additional context associated with requests </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a923348304ee26adb3a43c31a4bac9583"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">gid_t fuse_ctx::gid</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Group ID of the calling process </p>
+
+</div>
+</div>
+<a class="anchor" id="a056667c9ce324cb56b833e981aef8b5b"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">pid_t fuse_ctx::pid</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Thread ID of the calling process </p>
+
+</div>
+</div>
+<a class="anchor" id="abf920c4533df81789fd284aa05ee5771"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">uid_t fuse_ctx::uid</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>User ID of the calling process </p>
+
+</div>
+</div>
+<a class="anchor" id="aa6932619b51a5bfe4d1362ac4c1d2ce8"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">mode_t fuse_ctx::umask</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Umask of the calling process (introduced in version 2.8) </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__lowlevel_8h.html">fuse_lowlevel.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,149 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_entry_param Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_entry_param Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_lowlevel.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a285ba89754871772d940fa4fb736bce3"><td class="memItemLeft" align="right" valign="top"><a class="el" href="fuse__lowlevel_8h.html#ab419149c707451eaf61b75afb852e016">fuse_ino_t</a>&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__entry__param.html#a285ba89754871772d940fa4fb736bce3">ino</a></td></tr>
+<tr class="separator:a285ba89754871772d940fa4fb736bce3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a6481786ffc9fcf968df41953d3f0bf98"><td class="memItemLeft" align="right" valign="top">unsigned long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__entry__param.html#a6481786ffc9fcf968df41953d3f0bf98">generation</a></td></tr>
+<tr class="separator:a6481786ffc9fcf968df41953d3f0bf98"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:adcdee37c96ad18380a47cdbe96a323b9"><td class="memItemLeft" align="right" valign="top">struct stat&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__entry__param.html#adcdee37c96ad18380a47cdbe96a323b9">attr</a></td></tr>
+<tr class="separator:adcdee37c96ad18380a47cdbe96a323b9"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aa797a9f4152cae506ba479af8bbe2eb7"><td class="memItemLeft" align="right" valign="top">double&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__entry__param.html#aa797a9f4152cae506ba479af8bbe2eb7">attr_timeout</a></td></tr>
+<tr class="separator:aa797a9f4152cae506ba479af8bbe2eb7"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a281b39b72e7ec574ba40d7341fd22c1d"><td class="memItemLeft" align="right" valign="top">double&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__entry__param.html#a281b39b72e7ec574ba40d7341fd22c1d">entry_timeout</a></td></tr>
+<tr class="separator:a281b39b72e7ec574ba40d7341fd22c1d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Directory entry parameters supplied to <a class="el" href="fuse__lowlevel_8h.html#a672c45e126cd240f4bcd59bf9b7e3708">fuse_reply_entry()</a> </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="adcdee37c96ad18380a47cdbe96a323b9"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct stat fuse_entry_param::attr</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Inode attributes.</p>
+<p>Even if attr_timeout == 0, attr must be correct. For example, for open(), FUSE uses attr.st_size from lookup() to determine how many bytes to request. If this value is not correct, incorrect data will be returned. </p>
+
+</div>
+</div>
+<a class="anchor" id="aa797a9f4152cae506ba479af8bbe2eb7"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">double fuse_entry_param::attr_timeout</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Validity timeout (in seconds) for the attributes </p>
+
+</div>
+</div>
+<a class="anchor" id="a281b39b72e7ec574ba40d7341fd22c1d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">double fuse_entry_param::entry_timeout</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Validity timeout (in seconds) for the name </p>
+
+</div>
+</div>
+<a class="anchor" id="a6481786ffc9fcf968df41953d3f0bf98"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned long fuse_entry_param::generation</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Generation number for this entry.</p>
+<p>If the file system will be exported over NFS, the ino/generation pairs need to be unique over the file system's lifetime (rather than just the mount time). So if the file system reuses an inode after it has been deleted, it must assign a new, previously unused generation number to the inode at the same time.</p>
+<p>The generation must be non-zero, otherwise FUSE will treat it as an error. </p>
+
+</div>
+</div>
+<a class="anchor" id="a285ba89754871772d940fa4fb736bce3"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname"><a class="el" href="fuse__lowlevel_8h.html#ab419149c707451eaf61b75afb852e016">fuse_ino_t</a> fuse_entry_param::ino</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Unique inode number</p>
+<p>In lookup, zero means negative entry (from version 2.5) Returning ENOENT also means negative entry, but by setting zero ino the kernel may cache negative entries for entry_timeout seconds. </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__lowlevel_8h.html">fuse_lowlevel.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,221 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_file_info Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_file_info Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_common.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:ae7d31802727be19670193a411647bca5"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#ae7d31802727be19670193a411647bca5">flags</a></td></tr>
+<tr class="separator:ae7d31802727be19670193a411647bca5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a62d0083192d16484ac3136af3710cc11"><td class="memItemLeft" align="right" valign="top">unsigned long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#a62d0083192d16484ac3136af3710cc11">fh_old</a></td></tr>
+<tr class="separator:a62d0083192d16484ac3136af3710cc11"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ac58a8634699eb8ed8d424cd4413dd75b"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#ac58a8634699eb8ed8d424cd4413dd75b">writepage</a></td></tr>
+<tr class="separator:ac58a8634699eb8ed8d424cd4413dd75b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a03b59a10e62963d9affa34ad78bd144a"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#a03b59a10e62963d9affa34ad78bd144a">direct_io</a>: 1</td></tr>
+<tr class="separator:a03b59a10e62963d9affa34ad78bd144a"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a23a64eaecbf83f99aba8ee79e6de2780"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#a23a64eaecbf83f99aba8ee79e6de2780">keep_cache</a>: 1</td></tr>
+<tr class="separator:a23a64eaecbf83f99aba8ee79e6de2780"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a9c1571cb4b6be75827f48aac5891606c"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#a9c1571cb4b6be75827f48aac5891606c">flush</a>: 1</td></tr>
+<tr class="separator:a9c1571cb4b6be75827f48aac5891606c"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a272022c57a6a79dd8f98ef597786e154"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#a272022c57a6a79dd8f98ef597786e154">nonseekable</a>: 1</td></tr>
+<tr class="separator:a272022c57a6a79dd8f98ef597786e154"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ac320b22a715b226cc175d622307150e3"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#ac320b22a715b226cc175d622307150e3">padding</a>: 27</td></tr>
+<tr class="separator:ac320b22a715b226cc175d622307150e3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a45314d0b92a8d4c9de33d996aa59ada8"><td class="memItemLeft" align="right" valign="top">uint64_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#a45314d0b92a8d4c9de33d996aa59ada8">fh</a></td></tr>
+<tr class="separator:a45314d0b92a8d4c9de33d996aa59ada8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a3575f36b21f406c211c41c8c31323688"><td class="memItemLeft" align="right" valign="top">uint64_t&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__file__info.html#a3575f36b21f406c211c41c8c31323688">lock_owner</a></td></tr>
+<tr class="separator:a3575f36b21f406c211c41c8c31323688"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Information about open files</p>
+<p>Changed in version 2.5 </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a03b59a10e62963d9affa34ad78bd144a"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_file_info::direct_io</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Can be filled in by open, to use direct I/O on this file. Introduced in version 2.4 </p>
+
+</div>
+</div>
+<a class="anchor" id="a45314d0b92a8d4c9de33d996aa59ada8"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">uint64_t fuse_file_info::fh</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>File handle. May be filled in by filesystem in open(). Available in all other file operations </p>
+
+</div>
+</div>
+<a class="anchor" id="a62d0083192d16484ac3136af3710cc11"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned long fuse_file_info::fh_old</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Old file handle, don't use </p>
+
+</div>
+</div>
+<a class="anchor" id="ae7d31802727be19670193a411647bca5"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_file_info::flags</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Open flags. Available in open() and release() </p>
+
+</div>
+</div>
+<a class="anchor" id="a9c1571cb4b6be75827f48aac5891606c"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_file_info::flush</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Indicates a flush operation. Set in flush operation, also maybe set in highlevel lock operation and lowlevel release operation. Introduced in version 2.6 </p>
+
+</div>
+</div>
+<a class="anchor" id="a23a64eaecbf83f99aba8ee79e6de2780"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_file_info::keep_cache</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Can be filled in by open, to indicate, that cached file data need not be invalidated. Introduced in version 2.4 </p>
+
+</div>
+</div>
+<a class="anchor" id="a3575f36b21f406c211c41c8c31323688"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">uint64_t fuse_file_info::lock_owner</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Lock owner id. Available in locking operations and flush </p>
+
+</div>
+</div>
+<a class="anchor" id="a272022c57a6a79dd8f98ef597786e154"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_file_info::nonseekable</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Can be filled in by open, to indicate that the file is not seekable. Introduced in version 2.8 </p>
+
+</div>
+</div>
+<a class="anchor" id="ac320b22a715b226cc175d622307150e3"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_file_info::padding</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Padding. Do not use </p>
+
+</div>
+</div>
+<a class="anchor" id="ac58a8634699eb8ed8d424cd4413dd75b"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_file_info::writepage</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>In case of a write operation indicates if this was caused by a writepage </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__common_8h.html">fuse_common.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,112 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_module Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_module Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:abc7b2bc3480bbb94a4eb9c1d910a0385"><td class="memItemLeft" align="right" valign="top">const char *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__module.html#abc7b2bc3480bbb94a4eb9c1d910a0385">name</a></td></tr>
+<tr class="separator:abc7b2bc3480bbb94a4eb9c1d910a0385"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a433d1857217f025aaf561fb95ffadae5"><td class="memItemLeft" align="right" valign="top">struct fuse_fs *(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__module.html#a433d1857217f025aaf561fb95ffadae5">factory</a> )(struct <a class="el" href="structfuse__args.html">fuse_args</a> *args, struct fuse_fs *fs[])</td></tr>
+<tr class="separator:a433d1857217f025aaf561fb95ffadae5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Filesystem module</p>
+<p>Filesystem modules are registered with the <a class="el" href="fuse_8h.html#af335784cf29289c7583f3312d98d2bcd">FUSE_REGISTER_MODULE()</a> macro.</p>
+<p>If the "-omodules=modname:..." option is present, filesystem objects are created and pushed onto the stack with the 'factory' function. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a433d1857217f025aaf561fb95ffadae5"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">struct fuse_fs*(* fuse_module::factory)(struct <a class="el" href="structfuse__args.html">fuse_args</a> *args, struct fuse_fs *fs[])</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Factory for creating filesystem objects</p>
+<p>The function may use and remove options from 'args' that belong to this module.</p>
+<p>For now the 'fs' vector always contains exactly one filesystem. This is the filesystem which will be below the newly created filesystem in the stack.</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">args</td><td>the command line arguments </td></tr>
+    <tr><td class="paramname">fs</td><td>NULL terminated filesystem object vector </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>the new filesystem object </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="abc7b2bc3480bbb94a4eb9c1d910a0385"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const char* fuse_module::name</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Name of filesystem </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse_8h.html">fuse.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,867 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_operations Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_operations Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a7a4c5d8eaf7179d819618c0cf3f73724"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a7a4c5d8eaf7179d819618c0cf3f73724">getattr</a> )(const char *, struct stat *)</td></tr>
+<tr class="separator:a7a4c5d8eaf7179d819618c0cf3f73724"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab4ce6e6d69dfde3ec550f22d932c5633"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ab4ce6e6d69dfde3ec550f22d932c5633">readlink</a> )(const char *, char *, size_t)</td></tr>
+<tr class="separator:ab4ce6e6d69dfde3ec550f22d932c5633"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1465eb2268cec2bb5ed11cb09bbda42f"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a1465eb2268cec2bb5ed11cb09bbda42f">mknod</a> )(const char *, mode_t, dev_t)</td></tr>
+<tr class="separator:a1465eb2268cec2bb5ed11cb09bbda42f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a0a38aa6ca60e945772d5d21b0c1c8916"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a0a38aa6ca60e945772d5d21b0c1c8916">mkdir</a> )(const char *, mode_t)</td></tr>
+<tr class="separator:a0a38aa6ca60e945772d5d21b0c1c8916"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a8bf63301a9d6e94311fa10480993801e"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a8bf63301a9d6e94311fa10480993801e">unlink</a> )(const char *)</td></tr>
+<tr class="separator:a8bf63301a9d6e94311fa10480993801e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ac59578d18db12f0142ae1ab6e8812d55"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ac59578d18db12f0142ae1ab6e8812d55">rmdir</a> )(const char *)</td></tr>
+<tr class="separator:ac59578d18db12f0142ae1ab6e8812d55"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab86022391e56a8ad3211cf754b5b5ebe"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ab86022391e56a8ad3211cf754b5b5ebe">symlink</a> )(const char *, const char *)</td></tr>
+<tr class="separator:ab86022391e56a8ad3211cf754b5b5ebe"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aa777cbddc91887b117ac414e9a2d3cb5"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#aa777cbddc91887b117ac414e9a2d3cb5">rename</a> )(const char *, const char *)</td></tr>
+<tr class="separator:aa777cbddc91887b117ac414e9a2d3cb5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1b234c43e826c6a690d80ea895a17f61"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a1b234c43e826c6a690d80ea895a17f61">link</a> )(const char *, const char *)</td></tr>
+<tr class="separator:a1b234c43e826c6a690d80ea895a17f61"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a7e75d299efe3a401e8473af7028e5cc5"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a7e75d299efe3a401e8473af7028e5cc5">chmod</a> )(const char *, mode_t)</td></tr>
+<tr class="separator:a7e75d299efe3a401e8473af7028e5cc5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a40421f8a43e903582c49897894f4692d"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a40421f8a43e903582c49897894f4692d">chown</a> )(const char *, uid_t, gid_t)</td></tr>
+<tr class="separator:a40421f8a43e903582c49897894f4692d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a8efb50b9cd975ba8c4c450248caff6ed"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a8efb50b9cd975ba8c4c450248caff6ed">truncate</a> )(const char *, off_t)</td></tr>
+<tr class="separator:a8efb50b9cd975ba8c4c450248caff6ed"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:acb7452acad1002d418409892b6e54c2e"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#acb7452acad1002d418409892b6e54c2e">utime</a> )(const char *, struct utimbuf *)</td></tr>
+<tr class="separator:acb7452acad1002d418409892b6e54c2e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a14b98c3f7ab97cc2ef8f9b1d9dc0709d"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">open</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a14b98c3f7ab97cc2ef8f9b1d9dc0709d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a2a1c6b4ce1845de56863f8b7939501b5"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a2a1c6b4ce1845de56863f8b7939501b5">read</a> )(const char *, char *, size_t, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a2a1c6b4ce1845de56863f8b7939501b5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a897d1ece4b8b04c92d97b97b2dbf9768"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a897d1ece4b8b04c92d97b97b2dbf9768">write</a> )(const char *, const char *, size_t, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a897d1ece4b8b04c92d97b97b2dbf9768"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a4e765e29122e7b6b533dc99849a52655"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a4e765e29122e7b6b533dc99849a52655">statfs</a> )(const char *, struct statvfs *)</td></tr>
+<tr class="separator:a4e765e29122e7b6b533dc99849a52655"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad4ec9c309072a92dd82ddb20efa4ab14"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ad4ec9c309072a92dd82ddb20efa4ab14">flush</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:ad4ec9c309072a92dd82ddb20efa4ab14"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:abac8718cdfc1ee273a44831a27393419"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#abac8718cdfc1ee273a44831a27393419">release</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:abac8718cdfc1ee273a44831a27393419"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a92bdd6f43ba390a54ac360541c56b528"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a92bdd6f43ba390a54ac360541c56b528">fsync</a> )(const char *, int, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a92bdd6f43ba390a54ac360541c56b528"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a988ced7091c2821daa208e6c96d8b598"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a988ced7091c2821daa208e6c96d8b598">setxattr</a> )(const char *, const char *, const char *, size_t, int)</td></tr>
+<tr class="separator:a988ced7091c2821daa208e6c96d8b598"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ae21503c64fe2990c8a599f5ba339a8f2"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ae21503c64fe2990c8a599f5ba339a8f2">getxattr</a> )(const char *, const char *, char *, size_t)</td></tr>
+<tr class="separator:ae21503c64fe2990c8a599f5ba339a8f2"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab4a9c361ce48406f07d5a08ab03f5de8"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ab4a9c361ce48406f07d5a08ab03f5de8">listxattr</a> )(const char *, char *, size_t)</td></tr>
+<tr class="separator:ab4a9c361ce48406f07d5a08ab03f5de8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a5e54de801a0e0d7019e4579112ecc477"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a5e54de801a0e0d7019e4579112ecc477">removexattr</a> )(const char *, const char *)</td></tr>
+<tr class="separator:a5e54de801a0e0d7019e4579112ecc477"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1813889bc5e6e0087a936b7abe8b923f"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a1813889bc5e6e0087a936b7abe8b923f">opendir</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a1813889bc5e6e0087a936b7abe8b923f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a0f634deda31d1e1c42664585ae820076"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a0f634deda31d1e1c42664585ae820076">readdir</a> )(const char *, void *, <a class="el" href="fuse_8h.html#ae2a2054f9852fd6020c26a1bcc7f1042">fuse_fill_dir_t</a>, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a0f634deda31d1e1c42664585ae820076"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a729e53d36acc05a7a8985a1a3bbfac1e"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a729e53d36acc05a7a8985a1a3bbfac1e">releasedir</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a729e53d36acc05a7a8985a1a3bbfac1e"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aba5cc1fe9a63ec152ceb19656f243256"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#aba5cc1fe9a63ec152ceb19656f243256">fsyncdir</a> )(const char *, int, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:aba5cc1fe9a63ec152ceb19656f243256"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:adc6dc71274f185de72217e38d62142c4"><td class="memItemLeft" align="right" valign="top">void *(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#adc6dc71274f185de72217e38d62142c4">init</a> )(struct <a class="el" href="structfuse__conn__info.html">fuse_conn_info</a> *conn)</td></tr>
+<tr class="separator:adc6dc71274f185de72217e38d62142c4"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ac41d37ab860204fe4bd7612f9fb036c5"><td class="memItemLeft" align="right" valign="top">void(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ac41d37ab860204fe4bd7612f9fb036c5">destroy</a> )(void *)</td></tr>
+<tr class="separator:ac41d37ab860204fe4bd7612f9fb036c5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a2248db35e200265f7fb9a18348229858"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a2248db35e200265f7fb9a18348229858">access</a> )(const char *, int)</td></tr>
+<tr class="separator:a2248db35e200265f7fb9a18348229858"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a97243e0f9268a96236bc3b6f2bacee17"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a97243e0f9268a96236bc3b6f2bacee17">create</a> )(const char *, mode_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a97243e0f9268a96236bc3b6f2bacee17"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1e492882859740f13cbf3344cf963c70"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a1e492882859740f13cbf3344cf963c70">ftruncate</a> )(const char *, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a1e492882859740f13cbf3344cf963c70"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a573d79862df591c98e1685225a4cd3a5"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a573d79862df591c98e1685225a4cd3a5">fgetattr</a> )(const char *, struct stat *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a573d79862df591c98e1685225a4cd3a5"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1c3fff5cf0c1c2003d117e764b9a76fd"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a1c3fff5cf0c1c2003d117e764b9a76fd">lock</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, int cmd, struct <a class="el" href="structfuse__operations.html#ad5968d566dab370974043fcf4271eb25">flock</a> *)</td></tr>
+<tr class="separator:a1c3fff5cf0c1c2003d117e764b9a76fd"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a79955861cc5eb006954476607ef28944"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a79955861cc5eb006954476607ef28944">utimens</a> )(const char *, const struct timespec tv[2])</td></tr>
+<tr class="separator:a79955861cc5eb006954476607ef28944"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ae3f3482e33a0eada0292350d76b82901"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ae3f3482e33a0eada0292350d76b82901">bmap</a> )(const char *, size_t blocksize, uint64_t *idx)</td></tr>
+<tr class="separator:ae3f3482e33a0eada0292350d76b82901"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:acf5f08abeb39ab627fe1043d9a67cc09"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#acf5f08abeb39ab627fe1043d9a67cc09">flag_nullpath_ok</a>:1</td></tr>
+<tr class="separator:acf5f08abeb39ab627fe1043d9a67cc09"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:abd0d90b9b500f6607f9aad9ae07784d8"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#abd0d90b9b500f6607f9aad9ae07784d8">flag_nopath</a>:1</td></tr>
+<tr class="separator:abd0d90b9b500f6607f9aad9ae07784d8"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a0ca87db7234e774e39de7b323e03455d"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a0ca87db7234e774e39de7b323e03455d">flag_utime_omit_ok</a>:1</td></tr>
+<tr class="separator:a0ca87db7234e774e39de7b323e03455d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ab54bb9753d457ceff8240f67b1b6b72d"><td class="memItemLeft" align="right" valign="top">unsigned int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ab54bb9753d457ceff8240f67b1b6b72d">flag_reserved</a>:29</td></tr>
+<tr class="separator:ab54bb9753d457ceff8240f67b1b6b72d"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a37f0612d67a6b76bf10fe6a71b0e3b5b"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a37f0612d67a6b76bf10fe6a71b0e3b5b">ioctl</a> )(const char *, int cmd, void *arg, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, unsigned int flags, void *data)</td></tr>
+<tr class="separator:a37f0612d67a6b76bf10fe6a71b0e3b5b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a2c02838d30391c09dd5213edc61e106a"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a2c02838d30391c09dd5213edc61e106a">poll</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, struct fuse_pollhandle *ph, unsigned *reventsp)</td></tr>
+<tr class="separator:a2c02838d30391c09dd5213edc61e106a"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a89f400083a03ddcc43e47ce126b6761f"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a89f400083a03ddcc43e47ce126b6761f">write_buf</a> )(const char *, struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *buf, off_t off, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a89f400083a03ddcc43e47ce126b6761f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a1ecbe844d937ffbbe135958bcb28a719"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a1ecbe844d937ffbbe135958bcb28a719">read_buf</a> )(const char *, struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> **bufp, size_t size, off_t off, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a1ecbe844d937ffbbe135958bcb28a719"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:ad5968d566dab370974043fcf4271eb25"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#ad5968d566dab370974043fcf4271eb25">flock</a> )(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, int op)</td></tr>
+<tr class="separator:ad5968d566dab370974043fcf4271eb25"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a4fa8203e4bfa71d62c15deb5dffe4867"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__operations.html#a4fa8203e4bfa71d62c15deb5dffe4867">fallocate</a> )(const char *, int, off_t, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td></tr>
+<tr class="separator:a4fa8203e4bfa71d62c15deb5dffe4867"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>The file system operations:</p>
+<p>Most of these should work very similarly to the well known UNIX file system operations. A major exception is that instead of returning an error in 'errno', the operation should return the negated error value (-errno) directly.</p>
+<p>All methods are optional, but some are essential for a useful filesystem (e.g. getattr). Open, flush, release, fsync, opendir, releasedir, fsyncdir, access, create, ftruncate, fgetattr, lock, init and destroy are special purpose methods, without which a full featured filesystem can still be implemented.</p>
+<p>Almost all operations take a path which can be of any length.</p>
+<p>Changed in fuse 2.8.0 (regardless of API version) Previously, paths were limited to a length of PATH_MAX.</p>
+<p>See <a href="http://fuse.sourceforge.net/wiki/">http://fuse.sourceforge.net/wiki/</a> for more information. There is also a snapshot of the relevant wiki pages in the doc/ folder. </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a2248db35e200265f7fb9a18348229858"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::access)(const char *, int)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Check file access permissions</p>
+<p>This will be called for the <a class="el" href="structfuse__operations.html#a2248db35e200265f7fb9a18348229858">access()</a> system call. If the 'default_permissions' mount option is given, this method is not called.</p>
+<p>This method is not called under Linux kernel versions 2.4.x</p>
+<p>Introduced in version 2.5 </p>
+
+</div>
+</div>
+<a class="anchor" id="ae3f3482e33a0eada0292350d76b82901"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::bmap)(const char *, size_t blocksize, uint64_t *idx)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Map block index within file to block index within device</p>
+<p>Note: This makes sense only for block device backed filesystems mounted with the 'blkdev' option</p>
+<p>Introduced in version 2.6 </p>
+
+</div>
+</div>
+<a class="anchor" id="a7e75d299efe3a401e8473af7028e5cc5"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::chmod)(const char *, mode_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Change the permission bits of a file </p>
+
+</div>
+</div>
+<a class="anchor" id="a40421f8a43e903582c49897894f4692d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::chown)(const char *, uid_t, gid_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Change the owner and group of a file </p>
+
+</div>
+</div>
+<a class="anchor" id="a97243e0f9268a96236bc3b6f2bacee17"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::create)(const char *, mode_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create and open a file</p>
+<p>If the file does not exist, first create it with the specified mode, and then open it.</p>
+<p>If this method is not implemented or under Linux kernel versions earlier than 2.6.15, the <a class="el" href="structfuse__operations.html#a1465eb2268cec2bb5ed11cb09bbda42f">mknod()</a> and <a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">open()</a> methods will be called instead.</p>
+<p>Introduced in version 2.5 </p>
+
+</div>
+</div>
+<a class="anchor" id="ac41d37ab860204fe4bd7612f9fb036c5"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void(* fuse_operations::destroy)(void *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Clean up filesystem</p>
+<p>Called on filesystem exit.</p>
+<p>Introduced in version 2.3 </p>
+
+</div>
+</div>
+<a class="anchor" id="a4fa8203e4bfa71d62c15deb5dffe4867"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::fallocate)(const char *, int, off_t, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Allocates space for an open file</p>
+<p>This function ensures that required space is allocated for specified file. If this function returns success then any subsequent write request to specified range is guaranteed not to fail because of lack of space on the file system media.</p>
+<p>Introduced in version 2.9.1 </p>
+
+</div>
+</div>
+<a class="anchor" id="a573d79862df591c98e1685225a4cd3a5"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::fgetattr)(const char *, struct stat *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get attributes from an open file</p>
+<p>This method is called instead of the <a class="el" href="structfuse__operations.html#a7a4c5d8eaf7179d819618c0cf3f73724">getattr()</a> method if the file information is available.</p>
+<p>Currently this is only called after the <a class="el" href="structfuse__operations.html#a97243e0f9268a96236bc3b6f2bacee17">create()</a> method if that is implemented (see above). Later it may be called for invocations of fstat() too.</p>
+<p>Introduced in version 2.5 </p>
+
+</div>
+</div>
+<a class="anchor" id="abd0d90b9b500f6607f9aad9ae07784d8"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_operations::flag_nopath</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Flag indicating that the path need not be calculated for the following operations:</p>
+<p>read, write, flush, release, fsync, readdir, releasedir, fsyncdir, ftruncate, fgetattr, lock, ioctl and poll</p>
+<p>Closely related to flag_nullpath_ok, but if this flag is set then the path will not be calculaged even if the file wasn't unlinked. However the path can still be non-NULL if it needs to be calculated for some other reason. </p>
+
+</div>
+</div>
+<a class="anchor" id="acf5f08abeb39ab627fe1043d9a67cc09"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_operations::flag_nullpath_ok</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Flag indicating that the filesystem can accept a NULL path as the first argument for the following operations:</p>
+<p>read, write, flush, release, fsync, readdir, releasedir, fsyncdir, ftruncate, fgetattr, lock, ioctl and poll</p>
+<p>If this flag is set these operations continue to work on unlinked files even if "-ohard_remove" option was specified. </p>
+
+</div>
+</div>
+<a class="anchor" id="ab54bb9753d457ceff8240f67b1b6b72d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_operations::flag_reserved</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Reserved flags, don't set </p>
+
+</div>
+</div>
+<a class="anchor" id="a0ca87db7234e774e39de7b323e03455d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned int fuse_operations::flag_utime_omit_ok</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Flag indicating that the filesystem accepts special UTIME_NOW and UTIME_OMIT values in its utimens operation. </p>
+
+</div>
+</div>
+<a class="anchor" id="ad5968d566dab370974043fcf4271eb25"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::flock)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, int op)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Perform BSD file locking operation</p>
+<p>The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN</p>
+<p>Nonblocking requests will be indicated by ORing LOCK_NB to the above operations</p>
+<p>For more information see the flock(2) manual page.</p>
+<p>Additionally fi-&gt;owner will be set to a value unique to this open file. This same value will be supplied to -&gt;<a class="el" href="structfuse__operations.html#abac8718cdfc1ee273a44831a27393419">release()</a> when the file is released.</p>
+<p>Note: if this method is not implemented, the kernel will still allow file locking to work locally. Hence it is only interesting for network filesystems and similar.</p>
+<p>Introduced in version 2.9 </p>
+
+</div>
+</div>
+<a class="anchor" id="ad4ec9c309072a92dd82ddb20efa4ab14"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::flush)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Possibly flush cached data</p>
+<p>BIG NOTE: This is not equivalent to <a class="el" href="structfuse__operations.html#a92bdd6f43ba390a54ac360541c56b528">fsync()</a>. It's not a request to sync dirty data.</p>
+<p>Flush is called on each close() of a file descriptor. So if a filesystem wants to return write errors in close() and the file has cached dirty data, this is a good place to write back data and return any errors. Since many applications ignore close() errors this is not always useful.</p>
+<p>NOTE: The <a class="el" href="structfuse__operations.html#ad4ec9c309072a92dd82ddb20efa4ab14">flush()</a> method may be called more than once for each <a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">open()</a>. This happens if more than one file descriptor refers to an opened file due to dup(), dup2() or fork() calls. It is not possible to determine if a flush is final, so each flush should be treated equally. Multiple write-flush sequences are relatively rare, so this shouldn't be a problem.</p>
+<p>Filesystems shouldn't assume that flush will always be called after some writes, or that if will be called at all.</p>
+<p>Changed in version 2.2 </p>
+
+</div>
+</div>
+<a class="anchor" id="a92bdd6f43ba390a54ac360541c56b528"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::fsync)(const char *, int, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Synchronize file contents</p>
+<p>If the datasync parameter is non-zero, then only the user data should be flushed, not the meta data.</p>
+<p>Changed in version 2.2 </p>
+
+</div>
+</div>
+<a class="anchor" id="aba5cc1fe9a63ec152ceb19656f243256"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::fsyncdir)(const char *, int, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Synchronize directory contents</p>
+<p>If the datasync parameter is non-zero, then only the user data should be flushed, not the meta data</p>
+<p>Introduced in version 2.3 </p>
+
+</div>
+</div>
+<a class="anchor" id="a1e492882859740f13cbf3344cf963c70"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::ftruncate)(const char *, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Change the size of an open file</p>
+<p>This method is called instead of the <a class="el" href="structfuse__operations.html#a8efb50b9cd975ba8c4c450248caff6ed">truncate()</a> method if the truncation was invoked from an <a class="el" href="structfuse__operations.html#a1e492882859740f13cbf3344cf963c70">ftruncate()</a> system call.</p>
+<p>If this method is not implemented or under Linux kernel versions earlier than 2.6.15, the <a class="el" href="structfuse__operations.html#a8efb50b9cd975ba8c4c450248caff6ed">truncate()</a> method will be called instead.</p>
+<p>Introduced in version 2.5 </p>
+
+</div>
+</div>
+<a class="anchor" id="a7a4c5d8eaf7179d819618c0cf3f73724"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::getattr)(const char *, struct stat *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get file attributes.</p>
+<p>Similar to stat(). The 'st_dev' and 'st_blksize' fields are ignored. The 'st_ino' field is ignored except if the 'use_ino' mount option is given. </p>
+
+</div>
+</div>
+<a class="anchor" id="ae21503c64fe2990c8a599f5ba339a8f2"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::getxattr)(const char *, const char *, char *, size_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get extended attributes </p>
+
+</div>
+</div>
+<a class="anchor" id="adc6dc71274f185de72217e38d62142c4"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void*(* fuse_operations::init)(struct <a class="el" href="structfuse__conn__info.html">fuse_conn_info</a> *conn)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Initialize filesystem</p>
+<p>The return value will passed in the private_data field of <a class="el" href="structfuse__context.html">fuse_context</a> to all file operations and as a parameter to the <a class="el" href="structfuse__operations.html#ac41d37ab860204fe4bd7612f9fb036c5">destroy()</a> method.</p>
+<p>Introduced in version 2.3 Changed in version 2.6 </p>
+
+</div>
+</div>
+<a class="anchor" id="a37f0612d67a6b76bf10fe6a71b0e3b5b"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::ioctl)(const char *, int cmd, void *arg, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, unsigned int flags, void *data)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Ioctl</p>
+<p>flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in 64bit environment. The size and direction of data is determined by <em>IOC</em>*() decoding of cmd. For _IOC_NONE, data will be NULL, for _IOC_WRITE data is out area, for _IOC_READ in area and if both are set in/out area. In all non-NULL cases, the area is of _IOC_SIZE(cmd) bytes.</p>
+<p>If flags has FUSE_IOCTL_DIR then the <a class="el" href="structfuse__file__info.html">fuse_file_info</a> refers to a directory file handle.</p>
+<p>Introduced in version 2.8 </p>
+
+</div>
+</div>
+<a class="anchor" id="a1b234c43e826c6a690d80ea895a17f61"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::link)(const char *, const char *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create a hard link to a file </p>
+
+</div>
+</div>
+<a class="anchor" id="ab4a9c361ce48406f07d5a08ab03f5de8"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::listxattr)(const char *, char *, size_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>List extended attributes </p>
+
+</div>
+</div>
+<a class="anchor" id="a1c3fff5cf0c1c2003d117e764b9a76fd"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::lock)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, int cmd, struct <a class="el" href="structfuse__operations.html#ad5968d566dab370974043fcf4271eb25">flock</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Perform POSIX file locking operation</p>
+<p>The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW.</p>
+<p>For the meaning of fields in 'struct flock' see the man page for fcntl(2). The l_whence field will always be set to SEEK_SET.</p>
+<p>For checking lock ownership, the 'fuse_file_info-&gt;owner' argument must be used.</p>
+<p>For F_GETLK operation, the library will first check currently held locks, and if a conflicting lock is found it will return information without calling this method. This ensures, that for local locks the l_pid field is correctly filled in. The results may not be accurate in case of race conditions and in the presence of hard links, but it's unlikely that an application would rely on accurate GETLK results in these cases. If a conflicting lock is not found, this method will be called, and the filesystem may fill out l_pid by a meaningful value, or it may leave this field zero.</p>
+<p>For F_SETLK and F_SETLKW the l_pid field will be set to the pid of the process performing the locking operation.</p>
+<p>Note: if this method is not implemented, the kernel will still allow file locking to work locally. Hence it is only interesting for network filesystems and similar.</p>
+<p>Introduced in version 2.6 </p>
+
+</div>
+</div>
+<a class="anchor" id="a0a38aa6ca60e945772d5d21b0c1c8916"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::mkdir)(const char *, mode_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create a directory</p>
+<p>Note that the mode argument may not have the type specification bits set, i.e. S_ISDIR(mode) can be false. To obtain the correct directory type bits use mode|S_IFDIR </p>
+
+</div>
+</div>
+<a class="anchor" id="a1465eb2268cec2bb5ed11cb09bbda42f"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::mknod)(const char *, mode_t, dev_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create a file node</p>
+<p>This is called for creation of all non-directory, non-symlink nodes. If the filesystem defines a <a class="el" href="structfuse__operations.html#a97243e0f9268a96236bc3b6f2bacee17">create()</a> method, then for regular files that will be called instead. </p>
+
+</div>
+</div>
+<a class="anchor" id="a14b98c3f7ab97cc2ef8f9b1d9dc0709d"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::open)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>File open operation</p>
+<p>No creation (O_CREAT, O_EXCL) and by default also no truncation (O_TRUNC) flags will be passed to <a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">open()</a>. If an application specifies O_TRUNC, fuse first calls <a class="el" href="structfuse__operations.html#a8efb50b9cd975ba8c4c450248caff6ed">truncate()</a> and then <a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">open()</a>. Only if 'atomic_o_trunc' has been specified and kernel version is 2.6.24 or later, O_TRUNC is passed on to open.</p>
+<p>Unless the 'default_permissions' mount option is given, open should check if the operation is permitted for the given flags. Optionally open may also return an arbitrary filehandle in the <a class="el" href="structfuse__file__info.html">fuse_file_info</a> structure, which will be passed to all file operations.</p>
+<p>Changed in version 2.2 </p>
+
+</div>
+</div>
+<a class="anchor" id="a1813889bc5e6e0087a936b7abe8b923f"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::opendir)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Open directory</p>
+<p>Unless the 'default_permissions' mount option is given, this method should check if opendir is permitted for this directory. Optionally opendir may also return an arbitrary filehandle in the <a class="el" href="structfuse__file__info.html">fuse_file_info</a> structure, which will be passed to readdir, closedir and fsyncdir.</p>
+<p>Introduced in version 2.3 </p>
+
+</div>
+</div>
+<a class="anchor" id="a2c02838d30391c09dd5213edc61e106a"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::poll)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *, struct fuse_pollhandle *ph, unsigned *reventsp)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Poll for IO readiness events</p>
+<p>Note: If ph is non-NULL, the client should notify when IO readiness events occur by calling fuse_notify_poll() with the specified ph.</p>
+<p>Regardless of the number of times poll with a non-NULL ph is received, single notification is enough to clear all. Notifying more times incurs overhead but doesn't harm correctness.</p>
+<p>The callee is responsible for destroying ph with <a class="el" href="fuse__common_8h.html#adf5027f8a38b2efc03858efd7fdc756a">fuse_pollhandle_destroy()</a> when no longer in use.</p>
+<p>Introduced in version 2.8 </p>
+
+</div>
+</div>
+<a class="anchor" id="a2a1c6b4ce1845de56863f8b7939501b5"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::read)(const char *, char *, size_t, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Read data from an open file</p>
+<p>Read should return exactly the number of bytes requested except on EOF or error, otherwise the rest of the data will be substituted with zeroes. An exception to this is when the 'direct_io' mount option is specified, in which case the return value of the read system call will reflect the return value of this operation.</p>
+<p>Changed in version 2.2 </p>
+
+</div>
+</div>
+<a class="anchor" id="a1ecbe844d937ffbbe135958bcb28a719"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::read_buf)(const char *, struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> **bufp, size_t size, off_t off, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Store data from an open file in a buffer</p>
+<p>Similar to the <a class="el" href="structfuse__operations.html#a2a1c6b4ce1845de56863f8b7939501b5">read()</a> method, but data is stored and returned in a generic buffer.</p>
+<p>No actual copying of data has to take place, the source file descriptor may simply be stored in the buffer for later data transfer.</p>
+<p>The buffer must be allocated dynamically and stored at the location pointed to by bufp. If the buffer contains memory regions, they too must be allocated using malloc(). The allocated memory will be freed by the caller.</p>
+<p>Introduced in version 2.9 </p>
+
+</div>
+</div>
+<a class="anchor" id="a0f634deda31d1e1c42664585ae820076"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::readdir)(const char *, void *, <a class="el" href="fuse_8h.html#ae2a2054f9852fd6020c26a1bcc7f1042">fuse_fill_dir_t</a>, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Read directory</p>
+<p>This supersedes the old getdir() interface. New applications should use this.</p>
+<p>The filesystem may choose between two modes of operation:</p>
+<p>1) The readdir implementation ignores the offset parameter, and passes zero to the filler function's offset. The filler function will not return '1' (unless an error happens), so the whole directory is read in a single readdir operation. This works just like the old getdir() method.</p>
+<p>2) The readdir implementation keeps track of the offsets of the directory entries. It uses the offset parameter and always passes non-zero offset to the filler function. When the buffer is full (or an error happens) the filler function will return '1'.</p>
+<p>Introduced in version 2.3 </p>
+
+</div>
+</div>
+<a class="anchor" id="ab4ce6e6d69dfde3ec550f22d932c5633"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::readlink)(const char *, char *, size_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Read the target of a symbolic link</p>
+<p>The buffer should be filled with a null terminated string. The buffer size argument includes the space for the terminating null character. If the linkname is too long to fit in the buffer, it should be truncated. The return value should be 0 for success. </p>
+
+</div>
+</div>
+<a class="anchor" id="abac8718cdfc1ee273a44831a27393419"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::release)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Release an open file</p>
+<p>Release is called when there are no more references to an open file: all file descriptors are closed and all memory mappings are unmapped.</p>
+<p>For every <a class="el" href="structfuse__operations.html#a14b98c3f7ab97cc2ef8f9b1d9dc0709d">open()</a> call there will be exactly one <a class="el" href="structfuse__operations.html#abac8718cdfc1ee273a44831a27393419">release()</a> call with the same flags and file descriptor. It is possible to have a file opened more than once, in which case only the last release will mean, that no more reads/writes will happen on the file. The return value of release is ignored.</p>
+<p>Changed in version 2.2 </p>
+
+</div>
+</div>
+<a class="anchor" id="a729e53d36acc05a7a8985a1a3bbfac1e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::releasedir)(const char *, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Release directory</p>
+<p>Introduced in version 2.3 </p>
+
+</div>
+</div>
+<a class="anchor" id="a5e54de801a0e0d7019e4579112ecc477"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::removexattr)(const char *, const char *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Remove extended attributes </p>
+
+</div>
+</div>
+<a class="anchor" id="aa777cbddc91887b117ac414e9a2d3cb5"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::rename)(const char *, const char *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Rename a file </p>
+
+</div>
+</div>
+<a class="anchor" id="ac59578d18db12f0142ae1ab6e8812d55"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::rmdir)(const char *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Remove a directory </p>
+
+</div>
+</div>
+<a class="anchor" id="a988ced7091c2821daa208e6c96d8b598"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::setxattr)(const char *, const char *, const char *, size_t, int)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Set extended attributes </p>
+
+</div>
+</div>
+<a class="anchor" id="a4e765e29122e7b6b533dc99849a52655"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::statfs)(const char *, struct statvfs *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Get file system statistics</p>
+<p>The 'f_frsize', 'f_favail', 'f_fsid' and 'f_flag' fields are ignored</p>
+<p>Replaced 'struct statfs' parameter with 'struct statvfs' in version 2.5 </p>
+
+</div>
+</div>
+<a class="anchor" id="ab86022391e56a8ad3211cf754b5b5ebe"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::symlink)(const char *, const char *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Create a symbolic link </p>
+
+</div>
+</div>
+<a class="anchor" id="a8efb50b9cd975ba8c4c450248caff6ed"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::truncate)(const char *, off_t)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Change the size of a file </p>
+
+</div>
+</div>
+<a class="anchor" id="a8bf63301a9d6e94311fa10480993801e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::unlink)(const char *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Remove a file </p>
+
+</div>
+</div>
+<a class="anchor" id="acb7452acad1002d418409892b6e54c2e"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::utime)(const char *, struct utimbuf *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Change the access and/or modification times of a file</p>
+<p>Deprecated, use <a class="el" href="structfuse__operations.html#a79955861cc5eb006954476607ef28944">utimens()</a> instead. </p>
+
+</div>
+</div>
+<a class="anchor" id="a79955861cc5eb006954476607ef28944"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::utimens)(const char *, const struct timespec tv[2])</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Change the access and modification times of a file with nanosecond resolution</p>
+<p>This supersedes the old <a class="el" href="structfuse__operations.html#acb7452acad1002d418409892b6e54c2e">utime()</a> interface. New applications should use this.</p>
+<p>See the utimensat(2) man page for details.</p>
+<p>Introduced in version 2.6 </p>
+
+</div>
+</div>
+<a class="anchor" id="a897d1ece4b8b04c92d97b97b2dbf9768"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::write)(const char *, const char *, size_t, off_t, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Write data to an open file</p>
+<p>Write should return exactly the number of bytes requested except on error. An exception to this is when the 'direct_io' mount option is specified (see read operation).</p>
+<p>Changed in version 2.2 </p>
+
+</div>
+</div>
+<a class="anchor" id="a89f400083a03ddcc43e47ce126b6761f"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_operations::write_buf)(const char *, struct <a class="el" href="structfuse__bufvec.html">fuse_bufvec</a> *buf, off_t off, struct <a class="el" href="structfuse__file__info.html">fuse_file_info</a> *)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Write contents of buffer to an open file</p>
+<p>Similar to the <a class="el" href="structfuse__operations.html#a897d1ece4b8b04c92d97b97b2dbf9768">write()</a> method, but data is supplied in a generic buffer. Use <a class="el" href="fuse__common_8h.html#a9ca301390fb5e85b85153abb1891a3f7">fuse_buf_copy()</a> to transfer data to the destination.</p>
+<p>Introduced in version 2.9 </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse_8h.html">fuse.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,136 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_opt Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_opt Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_opt.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a215255be3ed5c0f6c3e0d5dcc96d7b12"><td class="memItemLeft" align="right" valign="top">const char *&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__opt.html#a215255be3ed5c0f6c3e0d5dcc96d7b12">templ</a></td></tr>
+<tr class="separator:a215255be3ed5c0f6c3e0d5dcc96d7b12"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a333dcd849a3bd54df06084a69b5a8d39"><td class="memItemLeft" align="right" valign="top">unsigned long&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__opt.html#a333dcd849a3bd54df06084a69b5a8d39">offset</a></td></tr>
+<tr class="separator:a333dcd849a3bd54df06084a69b5a8d39"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aeb76339e1ce6948ad94bd2d4d5d01e20"><td class="memItemLeft" align="right" valign="top">int&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__opt.html#aeb76339e1ce6948ad94bd2d4d5d01e20">value</a></td></tr>
+<tr class="separator:aeb76339e1ce6948ad94bd2d4d5d01e20"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Option description</p>
+<p>This structure describes a single option, and action associated with it, in case it matches.</p>
+<p>More than one such match may occur, in which case the action for each match is executed.</p>
+<p>There are three possible actions in case of a match:</p>
+<p>i) An integer (int or unsigned) variable determined by 'offset' is set to 'value'</p>
+<p>ii) The processing function is called, with 'value' as the key</p>
+<p>iii) An integer (any) or string (char *) variable determined by 'offset' is set to the value of an option parameter</p>
+<p>'offset' should normally be either set to</p>
+<ul>
+<li>'offsetof(struct foo, member)' actions i) and iii)</li>
+<li>-1 action ii)</li>
+</ul>
+<p>The 'offsetof()' macro is defined in the &lt;stddef.h&gt; header.</p>
+<p>The template determines which options match, and also have an effect on the action. Normally the action is either i) or ii), but if a format is present in the template, then action iii) is performed.</p>
+<p>The types of templates are:</p>
+<p>1) "-x", "-foo", "--foo", "--foo-bar", etc. These match only themselves. Invalid values are "--" and anything beginning with "-o"</p>
+<p>2) "foo", "foo-bar", etc. These match "-ofoo", "-ofoo-bar" or the relevant option in a comma separated option list</p>
+<p>3) "bar=", "--foo=", etc. These are variations of 1) and 2) which have a parameter</p>
+<p>4) "bar=%s", "--foo=%lu", etc. Same matching as above but perform action iii).</p>
+<p>5) "-x ", etc. Matches either "-xparam" or "-x param" as two separate arguments</p>
+<p>6) "-x %s", etc. Combination of 4) and 5)</p>
+<p>If the format is "%s", memory is allocated for the string unlike with scanf(). </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="a333dcd849a3bd54df06084a69b5a8d39"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">unsigned long fuse_opt::offset</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Offset of variable within 'data' parameter of <a class="el" href="fuse__opt_8h.html#a539ef1f571c34f516c60c4cbe2901c0e">fuse_opt_parse()</a> or -1 </p>
+
+</div>
+</div>
+<a class="anchor" id="a215255be3ed5c0f6c3e0d5dcc96d7b12"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">const char* fuse_opt::templ</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Matching template and optional parameter formatting </p>
+
+</div>
+</div>
+<a class="anchor" id="aeb76339e1ce6948ad94bd2d4d5d01e20"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int fuse_opt::value</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Value to set the variable to, or to be passed as 'key' to the processing function. Ignored if template has a format </p>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__opt_8h.html">fuse_opt.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,160 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
+<meta http-equiv="X-UA-Compatible" content="IE=9"/>
+<meta name="generator" content="Doxygen 1.8.8"/>
+<title>fuse: fuse_session_ops Struct Reference</title>
+<link href="tabs.css" rel="stylesheet" type="text/css"/>
+<script type="text/javascript" src="jquery.js"></script>
+<script type="text/javascript" src="dynsections.js"></script>
+<link href="doxygen.css" rel="stylesheet" type="text/css" />
+</head>
+<body>
+<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
+<div id="titlearea">
+<table cellspacing="0" cellpadding="0">
+ <tbody>
+ <tr style="height: 56px;">
+  <td style="padding-left: 0.5em;">
+   <div id="projectname">fuse
+   </div>
+  </td>
+ </tr>
+ </tbody>
+</table>
+</div>
+<!-- end header part -->
+<!-- Generated by Doxygen 1.8.8 -->
+  <div id="navrow1" class="tabs">
+    <ul class="tablist">
+      <li><a href="index.html"><span>Main&#160;Page</span></a></li>
+      <li class="current"><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="files.html"><span>Files</span></a></li>
+    </ul>
+  </div>
+  <div id="navrow2" class="tabs2">
+    <ul class="tablist">
+      <li><a href="annotated.html"><span>Data&#160;Structures</span></a></li>
+      <li><a href="functions.html"><span>Data&#160;Fields</span></a></li>
+    </ul>
+  </div>
+</div><!-- top -->
+<div class="header">
+  <div class="summary">
+<a href="#pub-attribs">Data Fields</a>  </div>
+  <div class="headertitle">
+<div class="title">fuse_session_ops Struct Reference</div>  </div>
+</div><!--header-->
+<div class="contents">
+
+<p><code>#include &lt;fuse_lowlevel.h&gt;</code></p>
+<table class="memberdecls">
+<tr class="heading"><td colspan="2"><h2 class="groupheader"><a name="pub-attribs"></a>
+Data Fields</h2></td></tr>
+<tr class="memitem:a8ed15bc86f9e32444cd0b80d605f227f"><td class="memItemLeft" align="right" valign="top">void(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__session__ops.html#a8ed15bc86f9e32444cd0b80d605f227f">process</a> )(void *data, const char *buf, size_t len, struct fuse_chan *ch)</td></tr>
+<tr class="separator:a8ed15bc86f9e32444cd0b80d605f227f"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:aeb6548d5e59314ae6c83b905993710e3"><td class="memItemLeft" align="right" valign="top">void(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__session__ops.html#aeb6548d5e59314ae6c83b905993710e3">exit</a> )(void *data, int val)</td></tr>
+<tr class="separator:aeb6548d5e59314ae6c83b905993710e3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:a6307bc12276d867dcb06ade8744cf02b"><td class="memItemLeft" align="right" valign="top">int(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__session__ops.html#a6307bc12276d867dcb06ade8744cf02b">exited</a> )(void *data)</td></tr>
+<tr class="separator:a6307bc12276d867dcb06ade8744cf02b"><td class="memSeparator" colspan="2">&#160;</td></tr>
+<tr class="memitem:afee317cbaa077d50fd19245924ddfff3"><td class="memItemLeft" align="right" valign="top">void(*&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structfuse__session__ops.html#afee317cbaa077d50fd19245924ddfff3">destroy</a> )(void *data)</td></tr>
+<tr class="separator:afee317cbaa077d50fd19245924ddfff3"><td class="memSeparator" colspan="2">&#160;</td></tr>
+</table>
+<a name="details" id="details"></a><h2 class="groupheader">Detailed Description</h2>
+<div class="textblock"><p>Session operations</p>
+<p>This is used in session creation </p>
+</div><h2 class="groupheader">Field Documentation</h2>
+<a class="anchor" id="afee317cbaa077d50fd19245924ddfff3"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void(* fuse_session_ops::destroy)(void *data)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Hook for cleaning up the channel on destroy (optional)</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">data</td><td>user data passed to <a class="el" href="fuse__lowlevel_8h.html#a28b7d09c6e87e3e375743c2ef6e06f0f">fuse_session_new()</a> </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="aeb6548d5e59314ae6c83b905993710e3"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void(* fuse_session_ops::exit)(void *data, int val)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Hook for session exit and reset (optional)</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">data</td><td>user data passed to <a class="el" href="fuse__lowlevel_8h.html#a28b7d09c6e87e3e375743c2ef6e06f0f">fuse_session_new()</a> </td></tr>
+    <tr><td class="paramname">val</td><td>exited status (1 - exited, 0 - not exited) </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<a class="anchor" id="a6307bc12276d867dcb06ade8744cf02b"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">int(* fuse_session_ops::exited)(void *data)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Hook for querying the current exited status (optional)</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">data</td><td>user data passed to <a class="el" href="fuse__lowlevel_8h.html#a28b7d09c6e87e3e375743c2ef6e06f0f">fuse_session_new()</a> </td></tr>
+  </table>
+  </dd>
+</dl>
+<dl class="section return"><dt>Returns</dt><dd>1 if exited, 0 if not exited </dd></dl>
+
+</div>
+</div>
+<a class="anchor" id="a8ed15bc86f9e32444cd0b80d605f227f"></a>
+<div class="memitem">
+<div class="memproto">
+      <table class="memname">
+        <tr>
+          <td class="memname">void(* fuse_session_ops::process)(void *data, const char *buf, size_t len, struct fuse_chan *ch)</td>
+        </tr>
+      </table>
+</div><div class="memdoc">
+<p>Hook to process a request (mandatory)</p>
+<dl class="params"><dt>Parameters</dt><dd>
+  <table class="params">
+    <tr><td class="paramname">data</td><td>user data passed to <a class="el" href="fuse__lowlevel_8h.html#a28b7d09c6e87e3e375743c2ef6e06f0f">fuse_session_new()</a> </td></tr>
+    <tr><td class="paramname">buf</td><td>buffer containing the raw request </td></tr>
+    <tr><td class="paramname">len</td><td>request length </td></tr>
+    <tr><td class="paramname">ch</td><td>channel on which the request was received </td></tr>
+  </table>
+  </dd>
+</dl>
+
+</div>
+</div>
+<hr/>The documentation for this struct was generated from the following file:<ul>
+<li>include/<a class="el" href="fuse__lowlevel_8h.html">fuse_lowlevel.h</a></li>
+</ul>
+</div><!-- contents -->
+<!-- start footer part -->
+<hr class="footer"/><address class="footer"><small>
+Generated on Sat Apr 23 2016 09:43:20 for fuse by &#160;<a href="http://www.doxygen.org/index.html">
+<img class="footer" src="doxygen.png" alt="doxygen"/>
+</a> 1.8.8
+</small></address>
+</body>
+</html>
@@ -0,0 +1,60 @@
+.tabs, .tabs2, .tabs3 {
+    background-image: url('tab_b.png');
+    width: 100%;
+    z-index: 101;
+    font-size: 13px;
+    font-family: 'Lucida Grande',Geneva,Helvetica,Arial,sans-serif;
+}
+
+.tabs2 {
+    font-size: 10px;
+}
+.tabs3 {
+    font-size: 9px;
+}
+
+.tablist {
+    margin: 0;
+    padding: 0;
+    display: table;
+}
+
+.tablist li {
+    float: left;
+    display: table-cell;
+    background-image: url('tab_b.png');
+    line-height: 36px;
+    list-style: none;
+}
+
+.tablist a {
+    display: block;
+    padding: 0 20px;
+    font-weight: bold;
+    background-image:url('tab_s.png');
+    background-repeat:no-repeat;
+    background-position:right;
+    color: #283A5D;
+    text-shadow: 0px 1px 1px rgba(255, 255, 255, 0.9);
+    text-decoration: none;
+    outline: none;
+}
+
+.tabs3 .tablist a {
+    padding: 0 10px;
+}
+
+.tablist a:hover {
+    background-image: url('tab_h.png');
+    background-repeat:repeat-x;
+    color: #fff;
+    text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);
+    text-decoration: none;
+}
+
+.tablist li.current a {
+    background-image: url('tab_a.png');
+    background-repeat:repeat-x;
+    color: #fff;
+    text-shadow: 0px 1px 1px rgba(0, 0, 0, 1.0);
+}
@@ -0,0 +1,423 @@
+Definitions
+~~~~~~~~~~~
+
+Userspace filesystem:
+
+  A filesystem in which data and metadata are provided by an ordinary
+  userspace process.  The filesystem can be accessed normally through
+  the kernel interface.
+
+Filesystem daemon:
+
+  The process(es) providing the data and metadata of the filesystem.
+
+Non-privileged mount (or user mount):
+
+  A userspace filesystem mounted by a non-privileged (non-root) user.
+  The filesystem daemon is running with the privileges of the mounting
+  user.  NOTE: this is not the same as mounts allowed with the "user"
+  option in /etc/fstab, which is not discussed here.
+
+Filesystem connection:
+
+  A connection between the filesystem daemon and the kernel.  The
+  connection exists until either the daemon dies, or the filesystem is
+  umounted.  Note that detaching (or lazy umounting) the filesystem
+  does _not_ break the connection, in this case it will exist until
+  the last reference to the filesystem is released.
+
+Mount owner:
+
+  The user who does the mounting.
+
+User:
+
+  The user who is performing filesystem operations.
+
+What is FUSE?
+~~~~~~~~~~~~~
+
+FUSE is a userspace filesystem framework.  It consists of a kernel
+module (fuse.ko), a userspace library (libfuse.*) and a mount utility
+(fusermount).
+
+One of the most important features of FUSE is allowing secure,
+non-privileged mounts.  This opens up new possibilities for the use of
+filesystems.  A good example is sshfs: a secure network filesystem
+using the sftp protocol.
+
+The userspace library and utilities are available from the FUSE
+homepage:
+
+  http://fuse.sourceforge.net/
+
+Filesystem type
+~~~~~~~~~~~~~~~
+
+The filesystem type given to mount(2) can be one of the following:
+
+'fuse'
+
+  This is the usual way to mount a FUSE filesystem.  The first
+  argument of the mount system call may contain an arbitrary string,
+  which is not interpreted by the kernel.
+
+'fuseblk'
+
+  The filesystem is block device based.  The first argument of the
+  mount system call is interpreted as the name of the device.
+
+Mount options
+~~~~~~~~~~~~~
+
+'fd=N'
+
+  The file descriptor to use for communication between the userspace
+  filesystem and the kernel.  The file descriptor must have been
+  obtained by opening the FUSE device ('/dev/fuse').
+
+'rootmode=M'
+
+  The file mode of the filesystem's root in octal representation.
+
+'user_id=N'
+
+  The numeric user id of the mount owner.
+
+'group_id=N'
+
+  The numeric group id of the mount owner.
+
+'default_permissions'
+
+  By default FUSE doesn't check file access permissions, the
+  filesystem is free to implement it's access policy or leave it to
+  the underlying file access mechanism (e.g. in case of network
+  filesystems).  This option enables permission checking, restricting
+  access based on file mode.  It is usually useful together with the
+  'allow_other' mount option.
+
+'allow_other'
+
+  This option overrides the security measure restricting file access
+  to the user mounting the filesystem.  This option is by default only
+  allowed to root, but this restriction can be removed with a
+  (userspace) configuration option.
+
+'max_read=N'
+
+  With this option the maximum size of read operations can be set.
+  The default is infinite.  Note that the size of read requests is
+  limited anyway to 32 pages (which is 128kbyte on i386).
+
+'blksize=N'
+
+  Set the block size for the filesystem.  The default is 512.  This
+  option is only valid for 'fuseblk' type mounts.
+
+Control filesystem
+~~~~~~~~~~~~~~~~~~
+
+There's a control filesystem for FUSE, which can be mounted by:
+
+  mount -t fusectl none /sys/fs/fuse/connections
+
+Mounting it under the '/sys/fs/fuse/connections' directory makes it
+backwards compatible with earlier versions.
+
+Under the fuse control filesystem each connection has a directory
+named by a unique number.
+
+For each connection the following files exist within this directory:
+
+ 'waiting'
+
+  The number of requests which are waiting to be transferred to
+  userspace or being processed by the filesystem daemon.  If there is
+  no filesystem activity and 'waiting' is non-zero, then the
+  filesystem is hung or deadlocked.
+
+ 'abort'
+
+  Writing anything into this file will abort the filesystem
+  connection.  This means that all waiting requests will be aborted an
+  error returned for all aborted and new requests.
+
+Only the owner of the mount may read or write these files.
+
+Interrupting filesystem operations
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If a process issuing a FUSE filesystem request is interrupted, the
+following will happen:
+
+  1) If the request is not yet sent to userspace AND the signal is
+     fatal (SIGKILL or unhandled fatal signal), then the request is
+     dequeued and returns immediately.
+
+  2) If the request is not yet sent to userspace AND the signal is not
+     fatal, then an 'interrupted' flag is set for the request.  When
+     the request has been successfully transferred to userspace and
+     this flag is set, an INTERRUPT request is queued.
+
+  3) If the request is already sent to userspace, then an INTERRUPT
+     request is queued.
+
+INTERRUPT requests take precedence over other requests, so the
+userspace filesystem will receive queued INTERRUPTs before any others.
+
+The userspace filesystem may ignore the INTERRUPT requests entirely,
+or may honor them by sending a reply to the _original_ request, with
+the error set to EINTR.
+
+It is also possible that there's a race between processing the
+original request and it's INTERRUPT request.  There are two possibilities:
+
+  1) The INTERRUPT request is processed before the original request is
+     processed
+
+  2) The INTERRUPT request is processed after the original request has
+     been answered
+
+If the filesystem cannot find the original request, it should wait for
+some timeout and/or a number of new requests to arrive, after which it
+should reply to the INTERRUPT request with an EAGAIN error.  In case
+1) the INTERRUPT request will be requeued.  In case 2) the INTERRUPT
+reply will be ignored.
+
+Aborting a filesystem connection
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+It is possible to get into certain situations where the filesystem is
+not responding.  Reasons for this may be:
+
+  a) Broken userspace filesystem implementation
+
+  b) Network connection down
+
+  c) Accidental deadlock
+
+  d) Malicious deadlock
+
+(For more on c) and d) see later sections)
+
+In either of these cases it may be useful to abort the connection to
+the filesystem.  There are several ways to do this:
+
+  - Kill the filesystem daemon.  Works in case of a) and b)
+
+  - Kill the filesystem daemon and all users of the filesystem.  Works
+    in all cases except some malicious deadlocks
+
+  - Use forced umount (umount -f).  Works in all cases but only if
+    filesystem is still attached (it hasn't been lazy unmounted)
+
+  - Abort filesystem through the FUSE control filesystem.  Most
+    powerful method, always works.
+
+How do non-privileged mounts work?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Since the mount() system call is a privileged operation, a helper
+program (fusermount) is needed, which is installed setuid root.
+
+The implication of providing non-privileged mounts is that the mount
+owner must not be able to use this capability to compromise the
+system.  Obvious requirements arising from this are:
+
+ A) mount owner should not be able to get elevated privileges with the
+    help of the mounted filesystem
+
+ B) mount owner should not get illegitimate access to information from
+    other users' and the super user's processes
+
+ C) mount owner should not be able to induce undesired behavior in
+    other users' or the super user's processes
+
+How are requirements fulfilled?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+ A) The mount owner could gain elevated privileges by either:
+
+     1) creating a filesystem containing a device file, then opening
+	this device
+
+     2) creating a filesystem containing a suid or sgid application,
+	then executing this application
+
+    The solution is not to allow opening device files and ignore
+    setuid and setgid bits when executing programs.  To ensure this
+    fusermount always adds "nosuid" and "nodev" to the mount options
+    for non-privileged mounts.
+
+ B) If another user is accessing files or directories in the
+    filesystem, the filesystem daemon serving requests can record the
+    exact sequence and timing of operations performed.  This
+    information is otherwise inaccessible to the mount owner, so this
+    counts as an information leak.
+
+    The solution to this problem will be presented in point 2) of C).
+
+ C) There are several ways in which the mount owner can induce
+    undesired behavior in other users' processes, such as:
+
+     1) mounting a filesystem over a file or directory which the mount
+        owner could otherwise not be able to modify (or could only
+        make limited modifications).
+
+        This is solved in fusermount, by checking the access
+        permissions on the mountpoint and only allowing the mount if
+        the mount owner can do unlimited modification (has write
+        access to the mountpoint, and mountpoint is not a "sticky"
+        directory)
+
+     2) Even if 1) is solved the mount owner can change the behavior
+        of other users' processes.
+
+         i) It can slow down or indefinitely delay the execution of a
+           filesystem operation creating a DoS against the user or the
+           whole system.  For example a suid application locking a
+           system file, and then accessing a file on the mount owner's
+           filesystem could be stopped, and thus causing the system
+           file to be locked forever.
+
+         ii) It can present files or directories of unlimited length, or
+           directory structures of unlimited depth, possibly causing a
+           system process to eat up diskspace, memory or other
+           resources, again causing DoS.
+
+	The solution to this as well as B) is not to allow processes
+	to access the filesystem, which could otherwise not be
+	monitored or manipulated by the mount owner.  Since if the
+	mount owner can ptrace a process, it can do all of the above
+	without using a FUSE mount, the same criteria as used in
+	ptrace can be used to check if a process is allowed to access
+	the filesystem or not.
+
+	Note that the ptrace check is not strictly necessary to
+	prevent B/2/i, it is enough to check if mount owner has enough
+	privilege to send signal to the process accessing the
+	filesystem, since SIGSTOP can be used to get a similar effect.
+
+I think these limitations are unacceptable?
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+If a sysadmin trusts the users enough, or can ensure through other
+measures, that system processes will never enter non-privileged
+mounts, it can relax the last limitation with a "user_allow_other"
+config option.  If this config option is set, the mounting user can
+add the "allow_other" mount option which disables the check for other
+users' processes.
+
+Kernel - userspace interface
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The following diagram shows how a filesystem operation (in this
+example unlink) is performed in FUSE.
+
+NOTE: everything in this description is greatly simplified
+
+ |  "rm /mnt/fuse/file"               |  FUSE filesystem daemon
+ |                                    |
+ |                                    |  >sys_read()
+ |                                    |    >fuse_dev_read()
+ |                                    |      >request_wait()
+ |                                    |        [sleep on fc->waitq]
+ |                                    |
+ |  >sys_unlink()                     |
+ |    >fuse_unlink()                  |
+ |      [get request from             |
+ |       fc->unused_list]             |
+ |      >request_send()               |
+ |        [queue req on fc->pending]  |
+ |        [wake up fc->waitq]         |        [woken up]
+ |        >request_wait_answer()      |
+ |          [sleep on req->waitq]     |
+ |                                    |      <request_wait()
+ |                                    |      [remove req from fc->pending]
+ |                                    |      [copy req to read buffer]
+ |                                    |      [add req to fc->processing]
+ |                                    |    <fuse_dev_read()
+ |                                    |  <sys_read()
+ |                                    |
+ |                                    |  [perform unlink]
+ |                                    |
+ |                                    |  >sys_write()
+ |                                    |    >fuse_dev_write()
+ |                                    |      [look up req in fc->processing]
+ |                                    |      [remove from fc->processing]
+ |                                    |      [copy write buffer to req]
+ |          [woken up]                |      [wake up req->waitq]
+ |                                    |    <fuse_dev_write()
+ |                                    |  <sys_write()
+ |        <request_wait_answer()      |
+ |      <request_send()               |
+ |      [add request to               |
+ |       fc->unused_list]             |
+ |    <fuse_unlink()                  |
+ |  <sys_unlink()                     |
+
+There are a couple of ways in which to deadlock a FUSE filesystem.
+Since we are talking about unprivileged userspace programs,
+something must be done about these.
+
+Scenario 1 -  Simple deadlock
+-----------------------------
+
+ |  "rm /mnt/fuse/file"               |  FUSE filesystem daemon
+ |                                    |
+ |  >sys_unlink("/mnt/fuse/file")     |
+ |    [acquire inode semaphore        |
+ |     for "file"]                    |
+ |    >fuse_unlink()                  |
+ |      [sleep on req->waitq]         |
+ |                                    |  <sys_read()
+ |                                    |  >sys_unlink("/mnt/fuse/file")
+ |                                    |    [acquire inode semaphore
+ |                                    |     for "file"]
+ |                                    |    *DEADLOCK*
+
+The solution for this is to allow the filesystem to be aborted.
+
+Scenario 2 - Tricky deadlock
+----------------------------
+
+This one needs a carefully crafted filesystem.  It's a variation on
+the above, only the call back to the filesystem is not explicit,
+but is caused by a pagefault.
+
+ |  Kamikaze filesystem thread 1      |  Kamikaze filesystem thread 2
+ |                                    |
+ |  [fd = open("/mnt/fuse/file")]     |  [request served normally]
+ |  [mmap fd to 'addr']               |
+ |  [close fd]                        |  [FLUSH triggers 'magic' flag]
+ |  [read a byte from addr]           |
+ |    >do_page_fault()                |
+ |      [find or create page]         |
+ |      [lock page]                   |
+ |      >fuse_readpage()              |
+ |         [queue READ request]       |
+ |         [sleep on req->waitq]      |
+ |                                    |  [read request to buffer]
+ |                                    |  [create reply header before addr]
+ |                                    |  >sys_write(addr - headerlength)
+ |                                    |    >fuse_dev_write()
+ |                                    |      [look up req in fc->processing]
+ |                                    |      [remove from fc->processing]
+ |                                    |      [copy write buffer to req]
+ |                                    |        >do_page_fault()
+ |                                    |           [find or create page]
+ |                                    |           [lock page]
+ |                                    |           * DEADLOCK *
+
+Solution is basically the same as above.
+
+An additional problem is that while the write buffer is being copied
+to the request, the request must not be interrupted/aborted.  This is
+because the destination address of the copy may not be valid after the
+request has returned.
+
+This is solved with doing the copy atomically, and allowing abort
+while the page(s) belonging to the write buffer are faulted with
+get_user_pages().  The 'req->locked' flag indicates when the copy is
+taking place, and abort is delayed until this flag is unset.
@@ -0,0 +1,161 @@
+.TH fuse "8"
+.SH NAME
+fuse \- format and options for the fuse file systems
+.SH DESCRIPTION
+FUSE (Filesystem in Userspace) is a simple interface for userspace programs to export a virtual filesystem to the Linux kernel. FUSE also aims to provide a secure method for non privileged users to create and mount their own filesystem implementations.
+.SH CONFIGURATION
+Some options regarding mount policy can be set in the file \fI/etc/fuse.conf\fP. Currently these options are:
+.TP
+\fBmount_max = NNN\fP
+Set the maximum number of FUSE mounts allowed to non-root users. The default is 1000.
+.TP
+\fBuser_allow_other\fP
+Allow non-root users to specify the \fBallow_other\fP or \fBallow_root\fP mount options (see below).
+.SH OPTIONS
+Most of the generic mount options described in \fBmount\fP are supported (\fBro\fP, \fBrw\fP, \fBsuid\fP, \fBnosuid\fP, \fBdev\fP, \fBnodev\fP, \fBexec\fP, \fBnoexec\fP, \fBatime\fP, \fBnoatime\fP, \fBsync\fP, \fBasync\fP, \fBdirsync\fP). Filesystems are mounted with \fBnodev,nosuid\fP by default, which can only be overridden by a privileged user.
+.SS "General mount options:"
+These are FUSE specific mount options that can be specified for all filesystems:
+.TP
+\fBdefault_permissions\fP
+By default FUSE doesn't check file access permissions, the filesystem is free to implement it's access policy or leave it to the underlying file access mechanism (e.g. in case of network filesystems). This option enables permission checking, restricting access based on file mode.  This is option is usually useful together with the \fBallow_other\fP mount option.
+.TP
+\fBallow_other\fP
+This option overrides the security measure restricting file access to the user mounting the filesystem.  So all users (including root) can access the files.  This option is by default only allowed to root, but this restriction can be removed with a configuration option described in the previous section.
+.TP
+\fBallow_root\fP
+This option is similar to \fBallow_other\fP but file access is limited to the user mounting the filesystem and root.  This option and \fBallow_other\fP are mutually exclusive.
+.TP
+\fBkernel_cache\fP
+This option disables flushing the cache of the file contents on every \fBopen\fP(2).  This should only be enabled on filesystems, where the file data is never changed externally (not through the mounted FUSE filesystem).  Thus it is not suitable for network filesystems and other \fIintermediate\fP filesystems.
+
+\fBNOTE\fP: if this option is not specified (and neither \fBdirect_io\fP) data is still cached after the \fBopen\fP(2), so a \fBread\fP(2) system call will not always initiate a read operation.
+.TP
+\fBauto_cache\fP
+This option enables automatic flushing of the data cache on \fBopen\fP(2). The cache will only be flushed if the modification time or the size of the file has changed.
+.TP
+\fBlarge_read\fP
+Issue large read requests.  This can improve performance for some filesystems, but can also degrade performance. This option is only useful on 2.4.X kernels, as on 2.6 kernels requests size is automatically determined for optimum performance.
+.TP
+\fBdirect_io\fP
+This option disables the use of page cache (file content cache) in the kernel for this filesystem. This has several affects:
+.IP 1.
+Each \fBread\fP(2) or \fBwrite\fP(2) system call will initiate one or more read or write operations, data will not be cached in the kernel.
+.IP 2.
+The return value of the read() and write() system calls will correspond to the return values of the read and write operations. This is useful for example if the file size is not known in advance (before reading it).
+.TP
+\fBmax_read=N\fP
+With this option the maximum size of read operations can be set. The default is infinite. Note that the size of read requests is limited anyway to 32 pages (which is 128kbyte on i386).
+.TP
+\fBmax_readahead=N\fN
+Set the maximum number of bytes to read-ahead.  The default is determined by the kernel. On linux-2.6.22 or earlier it's 131072 (128kbytes)
+.TP
+\fBmax_write=N\fP
+Set the maximum number of bytes in a single write operation. The default is 128kbytes.  Note, that due to various limitations, the size of write requests can be much smaller (4kbytes). This limitation will be removed in the future.
+.TP
+\fBasync_read\fP
+Perform reads asynchronously. This is the default
+.TP
+\fBsync_read\fP
+Perform all reads (even read-ahead) synchronously.
+.TP
+\fBhard_remove\fP
+The default behavior is that if an open file is deleted, the file is renamed to a hidden file (\fB.fuse_hiddenXXX\fP), and only removed when the file is finally released.  This relieves the filesystem implementation of having to deal with this problem.  This option disables the hiding behavior, and files are removed immediately in an unlink operation (or in a rename operation which overwrites an existing file).
+
+It is recommended that you not use the hard_remove option. When hard_remove is set, the following libc functions fail on unlinked files (returning errno of \fBENOENT\fP): \fBread\fP(2), \fBwrite\fP(2), \fBfsync\fP(2), \fBclose\fP(2), \fBf*xattr\fP(2), \fBftruncate\fP(2), \fBfstat\fP(2), \fBfchmod\fP(2), \fBfchown\fP(2)
+.TP
+\fBdebug\fP
+Turns on debug information printing by the library.
+.TP
+\fBfsname=NAME\fP
+Sets the filesystem source (first field in \fI/etc/mtab\fP). The default is the mount program name.
+.TP
+\fBsubtype=TYPE\fP
+Sets the filesystem type (third field in \fI/etc/mtab\fP). The default is the mount program name. If the kernel suppports it, \fI/etc/mtab\fP and \fI/proc/mounts\fP will show the filesystem type as \fBfuse.TYPE\fP
+
+If the kernel doesn't support subtypes, the source filed will be \fBTYPE#NAME\fP, or if \fBfsname\fP option is not specified, just \fBTYPE\fP.
+.TP
+\fBuse_ino\fP
+Honor the \fIst_ino\fP field in kernel functions \fBgetattr()\fP and \fBfill_dir()\fP. This value is used to fill in the
+\fIst_ino\fP field in the \fBstat\fP(2), \fBlstat\fP(2), \fBfstat\fP(2) functions and the \fId_ino\fP field in the \fBreaddir\fP(2) function. The filesystem does not have to guarantee uniqueness, however some applications rely on this value being unique for the whole filesystem.
+.TP
+\fBreaddir_ino\fP
+If \fBuse_ino\fP option is not given, still try to fill in the \fId_ino\fP field in \fBreaddir\fP(2). If the name was previously looked up, and is still in the cache, the inode number found there will be used. Otherwise it will be set to \fB-1\fP.  If \fBuse_ino\fP option is given, this option is ignored.
+.TP
+\fBnonempty\fP
+Allows mounts over a non-empty file or directory. By default these  mounts are rejected to prevent accidental covering up of data, which could for example prevent automatic backup.
+.TP
+\fBumask=M\fP
+Override the permission bits in \fIst_mode\fP set by the filesystem. The resulting permission bits are the ones missing from the given umask value.  The value is given in octal representation.
+.TP
+\fBuid=N\fP
+Override the \fIst_uid\fP field set by the filesystem (N is numeric).
+.TP
+\fBgid=N\fP
+Override the \fIst_gid\fP field set by the filesystem (N is numeric).
+.TP
+\fBblkdev\fP
+Mount a filesystem backed by a block device.  This is a privileged option. The device must be specified with the \fBfsname=NAME\fP option.
+.TP
+\fBentry_timeout=T\fP
+The timeout in seconds for which name lookups will be cached. The default is 1.0 second. For all the timeout options, it is possible to give fractions of a second as well (e.g. \fBentry_timeout=2.8\fP)
+.TP
+\fBnegative_timeout=T\fP
+The timeout in seconds for which a negative lookup will be cached. This means, that if file did not exist (lookup retuned \fBENOENT\fP), the lookup will only be redone after the timeout, and the file/directory will be assumed to not exist until then.  The default is 0.0 second, meaning that caching negative lookups are disabled.
+.TP
+\fBattr_timeout=T\fP
+The timeout in seconds for which file/directory attributes are cached.  The default is 1.0 second.
+.TP
+\fBac_attr_timeout=T\fP
+The timeout in seconds for which file attributes are cached for the purpose of checking if \fBauto_cache\fP should flush the file data on  open. The default is the value of \fBattr_timeout\fP
+.TP
+\fBintr\fP
+Allow requests to be interrupted.  Turning on this option may result in unexpected behavior, if the filesystem does not support request interruption.
+.TP
+\fBintr_signal=NUM\fP
+Specify which signal number to send to the filesystem when a request is interrupted.  The default is hardcoded to USR1.
+.TP
+\fBmodules=M1[:M2...]\fP
+Add modules to the filesystem stack.  Modules are pushed in the order they are specified, with the original filesystem being on the bottom of the stack.
+.SH FUSE MODULES (STACKING)
+Modules are filesystem stacking support to high level API. Filesystem modules can be built into libfuse or loaded from shared object
+.SS "iconv"
+Perform file name character set conversion.  Options are:
+.TP
+\fBfrom_code=CHARSET\fP
+Character set to convert from (see \fBiconv -l\fP for a list of possible values). Default is \fBUTF-8\fP.
+.TP
+\fBto_code=CHARSET\fP
+Character set to convert to.  Default is determined by the current locale.
+.SS "subdir"
+Prepend a given directory to each path. Options are:
+.TP
+\fBsubdir=DIR\fP
+Directory to prepend to all paths.  This option is \fImandatory\fP.
+.TP
+\fBrellinks\fP
+Transform absolute symlinks into relative
+.TP
+\fBnorellinks\fP
+Do not transform absolute symlinks into relative.  This is the default.
+.SH SECURITY
+The fusermount program is installed set-user-gid to fuse. This is done to allow users from fuse group to mount
+their own filesystem implementations.
+There must however be some limitations, in order to prevent Bad User from
+doing nasty things.  Currently those limitations are:
+.IP 1.
+The user can only mount on a mountpoint, for which it has write permission
+.IP 2.
+The mountpoint is not a sticky directory which isn't owned by the user (like \fI/tmp\fP usually is)
+.IP 3.
+No other user (including root) can access the contents of the mounted filesystem.
+.SH NOTE
+FUSE filesystems are unmounted using the \fBfusermount\fP(1) command (\fBfusermount -u mountpoint\fP).
+.SH "AUTHORS"
+.LP
+The main author of FUSE is Miklos Szeredi <mszeredi@inf.bme.hu>.
+.LP
+This man page was written by Bastien Roucaries <roucaries.bastien+debian@gmail.com> for the
+Debian GNU/Linux distribution (but it may be used by others) from README file.
+.SH SEE ALSO
+fusermount(1)
+mount(8)
@@ -0,0 +1,28 @@
+.TH ULOCKMGR_SERVER 1 2011\-10\-23 2.8.6 "Filesystem in Userspace (FUSE)"
+
+.SH NAME
+\fBulockmgr_server\fR \- Lock Manager Server for FUSE filesystems
+
+.SH SYNOPSIS
+\fBulockmgr_server\fR
+
+.SH DESCRIPTION
+Filesystem in Userspace (FUSE) is a simple interface for userspace programs to export a virtual filesystem to the Linux kernel. It also aims to provide a secure method for non privileged users to create and mount their own filesystem implementations.
+.PP
+\fBulockmgr_server\fR is the Userspace Lock Manager Server for FUSE filesystems.
+
+.SH OPTIONS
+\fBulockmgr_server\fR has no options.
+
+.SH SEE ALSO
+\fIfusermount\fR(1),
+\fImount\fR(8),
+\fImount.fuse\fR(8).
+
+.SH HOMEPAGE
+More information about ulockmgr_server and the FUSE project can be found at <\fIhttp://fuse.sourceforge.net/\fR>.
+
+.SH AUTHOR
+FUSE was written by Miklos Szeredi <\fImiklos@szeredi.hu\fR>.
+.PP
+This manual page was written by Daniel Baumann <\fIdaniel.baumann@progress\-technologies.net\fR>.
@@ -0,0 +1,17 @@
+## Process this file with automake to produce Makefile.in
+
+AM_CPPFLAGS = -I$(top_srcdir)/include -D_FILE_OFFSET_BITS=64 -D_REENTRANT
+noinst_HEADERS = fioc.h
+noinst_PROGRAMS = fusexmp fusexmp_fh null hello hello_ll fioc fioclient \
+		  fsel fselclient cusexmp
+
+LDADD = ../lib/libfuse.la
+fusexmp_fh_LDADD = ../lib/libfuse.la ../lib/libulockmgr.la
+
+fioclient_CPPFLAGS =
+fioclient_LDFLAGS =
+fioclient_LDADD =
+fselclient_CPPFLAGS =
+fselclient_LDFLAGS =
+fselclient_LDADD =
+
@@ -0,0 +1,294 @@
+/*
+  CUSE example: Character device in Userspace
+  Copyright (C) 2008-2009  SUSE Linux Products GmbH
+  Copyright (C) 2008-2009  Tejun Heo <tj@kernel.org>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall cusexmp.c `pkg-config fuse --cflags --libs` -o cusexmp
+*/
+
+#define FUSE_USE_VERSION 29
+
+#include <cuse_lowlevel.h>
+#include <fuse_opt.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "fioc.h"
+
+static void *cusexmp_buf;
+static size_t cusexmp_size;
+
+static const char *usage =
+"usage: cusexmp [options]\n"
+"\n"
+"options:\n"
+"    --help|-h             print this help message\n"
+"    --maj=MAJ|-M MAJ      device major number\n"
+"    --min=MIN|-m MIN      device minor number\n"
+"    --name=NAME|-n NAME   device name (mandatory)\n"
+"\n";
+
+static int cusexmp_resize(size_t new_size)
+{
+	void *new_buf;
+
+	if (new_size == cusexmp_size)
+		return 0;
+
+	new_buf = realloc(cusexmp_buf, new_size);
+	if (!new_buf && new_size)
+		return -ENOMEM;
+
+	if (new_size > cusexmp_size)
+		memset(new_buf + cusexmp_size, 0, new_size - cusexmp_size);
+
+	cusexmp_buf = new_buf;
+	cusexmp_size = new_size;
+
+	return 0;
+}
+
+static int cusexmp_expand(size_t new_size)
+{
+	if (new_size > cusexmp_size)
+		return cusexmp_resize(new_size);
+	return 0;
+}
+
+static void cusexmp_open(fuse_req_t req, struct fuse_file_info *fi)
+{
+	fuse_reply_open(req, fi);
+}
+
+static void cusexmp_read(fuse_req_t req, size_t size, off_t off,
+			 struct fuse_file_info *fi)
+{
+	(void)fi;
+
+	if (off >= cusexmp_size)
+		off = cusexmp_size;
+	if (size > cusexmp_size - off)
+		size = cusexmp_size - off;
+
+	fuse_reply_buf(req, cusexmp_buf + off, size);
+}
+
+static void cusexmp_write(fuse_req_t req, const char *buf, size_t size,
+			  off_t off, struct fuse_file_info *fi)
+{
+	(void)fi;
+
+	if (cusexmp_expand(off + size)) {
+		fuse_reply_err(req, ENOMEM);
+		return;
+	}
+
+	memcpy(cusexmp_buf + off, buf, size);
+	fuse_reply_write(req, size);
+}
+
+static void fioc_do_rw(fuse_req_t req, void *addr, const void *in_buf,
+		       size_t in_bufsz, size_t out_bufsz, int is_read)
+{
+	const struct fioc_rw_arg *arg;
+	struct iovec in_iov[2], out_iov[3], iov[3];
+	size_t cur_size;
+
+	/* read in arg */
+	in_iov[0].iov_base = addr;
+	in_iov[0].iov_len = sizeof(*arg);
+	if (!in_bufsz) {
+		fuse_reply_ioctl_retry(req, in_iov, 1, NULL, 0);
+		return;
+	}
+	arg = in_buf;
+	in_buf += sizeof(*arg);
+	in_bufsz -= sizeof(*arg);
+
+	/* prepare size outputs */
+	out_iov[0].iov_base =
+		addr + (unsigned long)&(((struct fioc_rw_arg *)0)->prev_size);
+	out_iov[0].iov_len = sizeof(arg->prev_size);
+
+	out_iov[1].iov_base =
+		addr + (unsigned long)&(((struct fioc_rw_arg *)0)->new_size);
+	out_iov[1].iov_len = sizeof(arg->new_size);
+
+	/* prepare client buf */
+	if (is_read) {
+		out_iov[2].iov_base = arg->buf;
+		out_iov[2].iov_len = arg->size;
+		if (!out_bufsz) {
+			fuse_reply_ioctl_retry(req, in_iov, 1, out_iov, 3);
+			return;
+		}
+	} else {
+		in_iov[1].iov_base = arg->buf;
+		in_iov[1].iov_len = arg->size;
+		if (arg->size && !in_bufsz) {
+			fuse_reply_ioctl_retry(req, in_iov, 2, out_iov, 2);
+			return;
+		}
+	}
+
+	/* we're all set */
+	cur_size = cusexmp_size;
+	iov[0].iov_base = &cur_size;
+	iov[0].iov_len = sizeof(cur_size);
+
+	iov[1].iov_base = &cusexmp_size;
+	iov[1].iov_len = sizeof(cusexmp_size);
+
+	if (is_read) {
+		size_t off = arg->offset;
+		size_t size = arg->size;
+
+		if (off >= cusexmp_size)
+			off = cusexmp_size;
+		if (size > cusexmp_size - off)
+			size = cusexmp_size - off;
+
+		iov[2].iov_base = cusexmp_buf + off;
+		iov[2].iov_len = size;
+		fuse_reply_ioctl_iov(req, size, iov, 3);
+	} else {
+		if (cusexmp_expand(arg->offset + in_bufsz)) {
+			fuse_reply_err(req, ENOMEM);
+			return;
+		}
+
+		memcpy(cusexmp_buf + arg->offset, in_buf, in_bufsz);
+		fuse_reply_ioctl_iov(req, in_bufsz, iov, 2);
+	}
+}
+
+static void cusexmp_ioctl(fuse_req_t req, int cmd, void *arg,
+			  struct fuse_file_info *fi, unsigned flags,
+			  const void *in_buf, size_t in_bufsz, size_t out_bufsz)
+{
+	int is_read = 0;
+
+	(void)fi;
+
+	if (flags & FUSE_IOCTL_COMPAT) {
+		fuse_reply_err(req, ENOSYS);
+		return;
+	}
+
+	switch (cmd) {
+	case FIOC_GET_SIZE:
+		if (!out_bufsz) {
+			struct iovec iov = { arg, sizeof(size_t) };
+
+			fuse_reply_ioctl_retry(req, NULL, 0, &iov, 1);
+		} else
+			fuse_reply_ioctl(req, 0, &cusexmp_size,
+					 sizeof(cusexmp_size));
+		break;
+
+	case FIOC_SET_SIZE:
+		if (!in_bufsz) {
+			struct iovec iov = { arg, sizeof(size_t) };
+
+			fuse_reply_ioctl_retry(req, &iov, 1, NULL, 0);
+		} else {
+			cusexmp_resize(*(size_t *)in_buf);
+			fuse_reply_ioctl(req, 0, NULL, 0);
+		}
+		break;
+
+	case FIOC_READ:
+		is_read = 1;
+	case FIOC_WRITE:
+		fioc_do_rw(req, arg, in_buf, in_bufsz, out_bufsz, is_read);
+		break;
+
+	default:
+		fuse_reply_err(req, EINVAL);
+	}
+}
+
+struct cusexmp_param {
+	unsigned		major;
+	unsigned		minor;
+	char			*dev_name;
+	int			is_help;
+};
+
+#define CUSEXMP_OPT(t, p) { t, offsetof(struct cusexmp_param, p), 1 }
+
+static const struct fuse_opt cusexmp_opts[] = {
+	CUSEXMP_OPT("-M %u",		major),
+	CUSEXMP_OPT("--maj=%u",		major),
+	CUSEXMP_OPT("-m %u",		minor),
+	CUSEXMP_OPT("--min=%u",		minor),
+	CUSEXMP_OPT("-n %s",		dev_name),
+	CUSEXMP_OPT("--name=%s",	dev_name),
+	FUSE_OPT_KEY("-h",		0),
+	FUSE_OPT_KEY("--help",		0),
+	FUSE_OPT_END
+};
+
+static int cusexmp_process_arg(void *data, const char *arg, int key,
+			       struct fuse_args *outargs)
+{
+	struct cusexmp_param *param = data;
+
+	(void)outargs;
+	(void)arg;
+
+	switch (key) {
+	case 0:
+		param->is_help = 1;
+		fprintf(stderr, "%s", usage);
+		return fuse_opt_add_arg(outargs, "-ho");
+	default:
+		return 1;
+	}
+}
+
+static const struct cuse_lowlevel_ops cusexmp_clop = {
+	.open		= cusexmp_open,
+	.read		= cusexmp_read,
+	.write		= cusexmp_write,
+	.ioctl		= cusexmp_ioctl,
+};
+
+int main(int argc, char **argv)
+{
+	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
+	struct cusexmp_param param = { 0, 0, NULL, 0 };
+	char dev_name[128] = "DEVNAME=";
+	const char *dev_info_argv[] = { dev_name };
+	struct cuse_info ci;
+
+	if (fuse_opt_parse(&args, &param, cusexmp_opts, cusexmp_process_arg)) {
+		printf("failed to parse option\n");
+		return 1;
+	}
+
+	if (!param.is_help) {
+		if (!param.dev_name) {
+			fprintf(stderr, "Error: device name missing\n");
+			return 1;
+		}
+		strncat(dev_name, param.dev_name, sizeof(dev_name) - 9);
+	}
+
+	memset(&ci, 0, sizeof(ci));
+	ci.dev_major = param.major;
+	ci.dev_minor = param.minor;
+	ci.dev_info_argc = 1;
+	ci.dev_info_argv = dev_info_argv;
+	ci.flags = CUSE_UNRESTRICTED_IOCTL;
+
+	return cuse_lowlevel_main(args.argc, args.argv, &ci, &cusexmp_clop,
+				  NULL);
+}
@@ -0,0 +1,211 @@
+/*
+  FUSE fioc: FUSE ioctl example
+  Copyright (C) 2008       SUSE Linux Products GmbH
+  Copyright (C) 2008       Tejun Heo <teheo@suse.de>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall fioc.c `pkg-config fuse --cflags --libs` -o fioc
+*/
+
+#define FUSE_USE_VERSION 26
+
+#include <fuse.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+
+#include "fioc.h"
+
+#define FIOC_NAME	"fioc"
+
+enum {
+	FIOC_NONE,
+	FIOC_ROOT,
+	FIOC_FILE,
+};
+
+static void *fioc_buf;
+static size_t fioc_size;
+
+static int fioc_resize(size_t new_size)
+{
+	void *new_buf;
+
+	if (new_size == fioc_size)
+		return 0;
+
+	new_buf = realloc(fioc_buf, new_size);
+	if (!new_buf && new_size)
+		return -ENOMEM;
+
+	if (new_size > fioc_size)
+		memset(new_buf + fioc_size, 0, new_size - fioc_size);
+
+	fioc_buf = new_buf;
+	fioc_size = new_size;
+
+	return 0;
+}
+
+static int fioc_expand(size_t new_size)
+{
+	if (new_size > fioc_size)
+		return fioc_resize(new_size);
+	return 0;
+}
+
+static int fioc_file_type(const char *path)
+{
+	if (strcmp(path, "/") == 0)
+		return FIOC_ROOT;
+	if (strcmp(path, "/" FIOC_NAME) == 0)
+		return FIOC_FILE;
+	return FIOC_NONE;
+}
+
+static int fioc_getattr(const char *path, struct stat *stbuf)
+{
+	stbuf->st_uid = getuid();
+	stbuf->st_gid = getgid();
+	stbuf->st_atime = stbuf->st_mtime = time(NULL);
+
+	switch (fioc_file_type(path)) {
+	case FIOC_ROOT:
+		stbuf->st_mode = S_IFDIR | 0755;
+		stbuf->st_nlink = 2;
+		break;
+	case FIOC_FILE:
+		stbuf->st_mode = S_IFREG | 0644;
+		stbuf->st_nlink = 1;
+		stbuf->st_size = fioc_size;
+		break;
+	case FIOC_NONE:
+		return -ENOENT;
+	}
+
+	return 0;
+}
+
+static int fioc_open(const char *path, struct fuse_file_info *fi)
+{
+	(void) fi;
+
+	if (fioc_file_type(path) != FIOC_NONE)
+		return 0;
+	return -ENOENT;
+}
+
+static int fioc_do_read(char *buf, size_t size, off_t offset)
+{
+	if (offset >= fioc_size)
+		return 0;
+
+	if (size > fioc_size - offset)
+		size = fioc_size - offset;
+
+	memcpy(buf, fioc_buf + offset, size);
+
+	return size;
+}
+
+static int fioc_read(const char *path, char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	(void) fi;
+
+	if (fioc_file_type(path) != FIOC_FILE)
+		return -EINVAL;
+
+	return fioc_do_read(buf, size, offset);
+}
+
+static int fioc_do_write(const char *buf, size_t size, off_t offset)
+{
+	if (fioc_expand(offset + size))
+		return -ENOMEM;
+
+	memcpy(fioc_buf + offset, buf, size);
+
+	return size;
+}
+
+static int fioc_write(const char *path, const char *buf, size_t size,
+		      off_t offset, struct fuse_file_info *fi)
+{
+	(void) fi;
+
+	if (fioc_file_type(path) != FIOC_FILE)
+		return -EINVAL;
+
+	return fioc_do_write(buf, size, offset);
+}
+
+static int fioc_truncate(const char *path, off_t size)
+{
+	if (fioc_file_type(path) != FIOC_FILE)
+		return -EINVAL;
+
+	return fioc_resize(size);
+}
+
+static int fioc_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+			off_t offset, struct fuse_file_info *fi)
+{
+	(void) fi;
+	(void) offset;
+
+	if (fioc_file_type(path) != FIOC_ROOT)
+		return -ENOENT;
+
+	filler(buf, ".", NULL, 0);
+	filler(buf, "..", NULL, 0);
+	filler(buf, FIOC_NAME, NULL, 0);
+
+	return 0;
+}
+
+static int fioc_ioctl(const char *path, int cmd, void *arg,
+		      struct fuse_file_info *fi, unsigned int flags, void *data)
+{
+	(void) arg;
+	(void) fi;
+	(void) flags;
+
+	if (fioc_file_type(path) != FIOC_FILE)
+		return -EINVAL;
+
+	if (flags & FUSE_IOCTL_COMPAT)
+		return -ENOSYS;
+
+	switch (cmd) {
+	case FIOC_GET_SIZE:
+		*(size_t *)data = fioc_size;
+		return 0;
+
+	case FIOC_SET_SIZE:
+		fioc_resize(*(size_t *)data);
+		return 0;
+	}
+
+	return -EINVAL;
+}
+
+static struct fuse_operations fioc_oper = {
+	.getattr	= fioc_getattr,
+	.readdir	= fioc_readdir,
+	.truncate	= fioc_truncate,
+	.open		= fioc_open,
+	.read		= fioc_read,
+	.write		= fioc_write,
+	.ioctl		= fioc_ioctl,
+};
+
+int main(int argc, char *argv[])
+{
+	return fuse_main(argc, argv, &fioc_oper, NULL);
+}
@@ -0,0 +1,32 @@
+/*
+  FUSE-ioctl: ioctl support for FUSE
+  Copyright (C) 2008       SUSE Linux Products GmbH
+  Copyright (C) 2008       Tejun Heo <teheo@suse.de>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+*/
+
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <sys/ioctl.h>
+
+enum {
+	FIOC_GET_SIZE	= _IOR('E', 0, size_t),
+	FIOC_SET_SIZE	= _IOW('E', 1, size_t),
+
+	/*
+	 * The following two ioctls don't follow usual encoding rules
+	 * and transfer variable amount of data.
+	 */
+	FIOC_READ	= _IO('E', 2),
+	FIOC_WRITE	= _IO('E', 3),
+};
+
+struct fioc_rw_arg {
+	off_t		offset;
+	void		*buf;
+	size_t		size;
+	size_t		prev_size;	/* out param for previous total size */
+	size_t		new_size;	/* out param for new total size */
+};
@@ -0,0 +1,122 @@
+/*
+  FUSE fioclient: FUSE ioctl example client
+  Copyright (C) 2008       SUSE Linux Products GmbH
+  Copyright (C) 2008       Tejun Heo <teheo@suse.de>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall fioclient.c -o fioclient
+*/
+
+#include <sys/types.h>
+#include <sys/fcntl.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <errno.h>
+#include "fioc.h"
+
+const char *usage =
+"Usage: fioclient FIOC_FILE COMMAND\n"
+"\n"
+"COMMANDS\n"
+"  s [SIZE]     : get size if SIZE is omitted, set size otherwise\n"
+"  r SIZE [OFF] : read SIZE bytes @ OFF (dfl 0) and output to stdout\n"
+"  w SIZE [OFF] : write SIZE bytes @ OFF (dfl 0) from stdin\n"
+"\n";
+
+static int do_rw(int fd, int is_read, size_t size, off_t offset,
+		 size_t *prev_size, size_t *new_size)
+{
+	struct fioc_rw_arg arg = { .offset = offset };
+	ssize_t ret;
+
+	arg.buf = calloc(1, size);
+	if (!arg.buf) {
+		fprintf(stderr, "failed to allocated %zu bytes\n", size);
+		return -1;
+	}
+
+	if (is_read) {
+		arg.size = size;
+		ret = ioctl(fd, FIOC_READ, &arg);
+		if (ret >= 0)
+			fwrite(arg.buf, 1, ret, stdout);
+	} else {
+		arg.size = fread(arg.buf, 1, size, stdin);
+		fprintf(stderr, "Writing %zu bytes\n", arg.size);
+		ret = ioctl(fd, FIOC_WRITE, &arg);
+	}
+
+	if (ret >= 0) {
+		*prev_size = arg.prev_size;
+		*new_size = arg.new_size;
+	} else
+		perror("ioctl");
+
+	free(arg.buf);
+	return ret;
+}
+
+int main(int argc, char **argv)
+{
+	size_t param[2] = { };
+	size_t size, prev_size = 0, new_size = 0;
+	char cmd;
+	int fd, i, rc;
+
+	if (argc < 3)
+		goto usage;
+
+	fd = open(argv[1], O_RDWR);
+	if (fd < 0) {
+		perror("open");
+		return 1;
+	}
+
+	cmd = tolower(argv[2][0]);
+	argc -= 3;
+	argv += 3;
+
+	for (i = 0; i < argc; i++) {
+		char *endp;
+		param[i] = strtoul(argv[i], &endp, 0);
+		if (endp == argv[i] || *endp != '\0')
+			goto usage;
+	}
+
+	switch (cmd) {
+	case 's':
+		if (!argc) {
+			if (ioctl(fd, FIOC_GET_SIZE, &size)) {
+				perror("ioctl");
+				return 1;
+			}
+			printf("%zu\n", size);
+		} else {
+			size = param[0];
+			if (ioctl(fd, FIOC_SET_SIZE, &size)) {
+				perror("ioctl");
+				return 1;
+			}
+		}
+		return 0;
+
+	case 'r':
+	case 'w':
+		rc = do_rw(fd, cmd == 'r', param[0], param[1],
+			   &prev_size, &new_size);
+		if (rc < 0)
+			return 1;
+		fprintf(stderr, "transferred %d bytes (%zu -> %zu)\n",
+			rc, prev_size, new_size);
+		return 0;
+	}
+
+ usage:
+	fprintf(stderr, "%s", usage);
+	return 1;
+}
@@ -0,0 +1,278 @@
+/*
+  FUSE fsel: FUSE select example
+  Copyright (C) 2008       SUSE Linux Products GmbH
+  Copyright (C) 2008       Tejun Heo <teheo@suse.de>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall fsel.c `pkg-config fuse --cflags --libs` -o fsel
+*/
+
+#define FUSE_USE_VERSION 29
+
+#include <fuse.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <time.h>
+#include <pthread.h>
+#include <poll.h>
+
+/*
+ * fsel_open_mask is used to limit the number of opens to 1 per file.
+ * This is to use file index (0-F) as fh as poll support requires
+ * unique fh per open file.  Lifting this would require proper open
+ * file management.
+ */
+static unsigned fsel_open_mask;
+static const char fsel_hex_map[] = "0123456789ABCDEF";
+static struct fuse *fsel_fuse;	/* needed for poll notification */
+
+#define FSEL_CNT_MAX	10	/* each file can store upto 10 chars */
+#define FSEL_FILES	16
+
+static pthread_mutex_t fsel_mutex;	/* protects notify_mask and cnt array */
+static unsigned fsel_poll_notify_mask;	/* poll notification scheduled? */
+static struct fuse_pollhandle *fsel_poll_handle[FSEL_FILES]; /* poll notify handles */
+static unsigned fsel_cnt[FSEL_FILES];	/* nbytes stored in each file */
+
+static int fsel_path_index(const char *path)
+{
+	char ch = path[1];
+
+	if (strlen(path) != 2 || path[0] != '/' || !isxdigit(ch) || islower(ch))
+		return -1;
+	return ch <= '9' ? ch - '0' : ch - 'A' + 10;
+}
+
+static int fsel_getattr(const char *path, struct stat *stbuf)
+{
+	int idx;
+
+	memset(stbuf, 0, sizeof(struct stat));
+
+	if (strcmp(path, "/") == 0) {
+		stbuf->st_mode = S_IFDIR | 0555;
+		stbuf->st_nlink = 2;
+		return 0;
+	}
+
+	idx = fsel_path_index(path);
+	if (idx < 0)
+		return -ENOENT;
+
+	stbuf->st_mode = S_IFREG | 0444;
+	stbuf->st_nlink = 1;
+	stbuf->st_size = fsel_cnt[idx];
+	return 0;
+}
+
+static int fsel_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+			off_t offset, struct fuse_file_info *fi)
+{
+	char name[2] = { };
+	int i;
+
+	(void) offset;
+	(void) fi;
+
+	if (strcmp(path, "/") != 0)
+		return -ENOENT;
+
+	for (i = 0; i < FSEL_FILES; i++) {
+		name[0] = fsel_hex_map[i];
+		filler(buf, name, NULL, 0);
+	}
+
+	return 0;
+}
+
+static int fsel_open(const char *path, struct fuse_file_info *fi)
+{
+	int idx = fsel_path_index(path);
+
+	if (idx < 0)
+		return -ENOENT;
+	if ((fi->flags & 3) != O_RDONLY)
+		return -EACCES;
+	if (fsel_open_mask & (1 << idx))
+		return -EBUSY;
+	fsel_open_mask |= (1 << idx);
+
+	/*
+	 * fsel files are nonseekable somewhat pipe-like files which
+	 * gets filled up periodically by producer thread and consumed
+	 * on read.  Tell FUSE as such.
+	 */
+	fi->fh = idx;
+	fi->direct_io = 1;
+	fi->nonseekable = 1;
+
+	return 0;
+}
+
+static int fsel_release(const char *path, struct fuse_file_info *fi)
+{
+	int idx = fi->fh;
+
+	(void) path;
+
+	fsel_open_mask &= ~(1 << idx);
+	return 0;
+}
+
+static int fsel_read(const char *path, char *buf, size_t size, off_t offset,
+		     struct fuse_file_info *fi)
+{
+	int idx = fi->fh;
+
+	(void) path;
+	(void) offset;
+
+	pthread_mutex_lock(&fsel_mutex);
+	if (fsel_cnt[idx] < size)
+		size = fsel_cnt[idx];
+	printf("READ   %X transferred=%zu cnt=%u\n", idx, size, fsel_cnt[idx]);
+	fsel_cnt[idx] -= size;
+	pthread_mutex_unlock(&fsel_mutex);
+
+	memset(buf, fsel_hex_map[idx], size);
+	return size;
+}
+
+static int fsel_poll(const char *path, struct fuse_file_info *fi,
+		     struct fuse_pollhandle *ph, unsigned *reventsp)
+{
+	static unsigned polled_zero;
+	int idx = fi->fh;
+
+	(void) path;
+
+	/*
+	 * Poll notification requires pointer to struct fuse which
+	 * can't be obtained when using fuse_main().  As notification
+	 * happens only after poll is called, fill it here from
+	 * fuse_context.
+	 */
+	if (!fsel_fuse) {
+		struct fuse_context *cxt = fuse_get_context();
+		if (cxt)
+			fsel_fuse = cxt->fuse;
+	}
+
+	pthread_mutex_lock(&fsel_mutex);
+
+	if (ph != NULL) {
+		struct fuse_pollhandle *oldph = fsel_poll_handle[idx];
+
+		if (oldph)
+			fuse_pollhandle_destroy(oldph);
+
+		fsel_poll_notify_mask |= (1 << idx);
+		fsel_poll_handle[idx] = ph;
+	}
+
+	if (fsel_cnt[idx]) {
+		*reventsp |= POLLIN;
+		printf("POLL   %X cnt=%u polled_zero=%u\n",
+		       idx, fsel_cnt[idx], polled_zero);
+		polled_zero = 0;
+	} else
+		polled_zero++;
+
+	pthread_mutex_unlock(&fsel_mutex);
+	return 0;
+}
+
+static struct fuse_operations fsel_oper = {
+	.getattr	= fsel_getattr,
+	.readdir	= fsel_readdir,
+	.open		= fsel_open,
+	.release	= fsel_release,
+	.read		= fsel_read,
+	.poll		= fsel_poll,
+};
+
+static void *fsel_producer(void *data)
+{
+	const struct timespec interval = { 0, 250000000 };
+	unsigned idx = 0, nr = 1;
+
+	(void) data;
+
+	while (1) {
+		int i, t;
+
+		pthread_mutex_lock(&fsel_mutex);
+
+		/*
+		 * This is the main producer loop which is executed
+		 * ever 500ms.  On each iteration, it fills one byte
+		 * to 1, 2 or 4 files and sends poll notification if
+		 * requested.
+		 */
+		for (i = 0, t = idx; i < nr;
+		     i++, t = (t + FSEL_FILES / nr) % FSEL_FILES) {
+			if (fsel_cnt[t] == FSEL_CNT_MAX)
+				continue;
+
+			fsel_cnt[t]++;
+			if (fsel_fuse && (fsel_poll_notify_mask & (1 << t))) {
+				struct fuse_pollhandle *ph;
+
+				printf("NOTIFY %X\n", t);
+				ph = fsel_poll_handle[t];
+				fuse_notify_poll(ph);
+				fuse_pollhandle_destroy(ph);
+				fsel_poll_notify_mask &= ~(1 << t);
+				fsel_poll_handle[t] = NULL;
+			}
+		}
+
+		idx = (idx + 1) % FSEL_FILES;
+		if (idx == 0)
+			nr = (nr * 2) % 7;	/* cycle through 1, 2 and 4 */
+
+		pthread_mutex_unlock(&fsel_mutex);
+
+		nanosleep(&interval, NULL);
+	}
+
+	return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+	pthread_t producer;
+	pthread_attr_t attr;
+	int ret;
+
+	errno = pthread_mutex_init(&fsel_mutex, NULL);
+	if (errno) {
+		perror("pthread_mutex_init");
+		return 1;
+	}
+
+	errno = pthread_attr_init(&attr);
+	if (errno) {
+		perror("pthread_attr_init");
+		return 1;
+	}
+
+	errno = pthread_create(&producer, &attr, fsel_producer, NULL);
+	if (errno) {
+		perror("pthread_create");
+		return 1;
+	}
+
+	ret = fuse_main(argc, argv, &fsel_oper, NULL);
+
+	pthread_cancel(producer);
+	pthread_join(producer, NULL);
+
+	return ret;
+}
@@ -0,0 +1,72 @@
+/*
+  FUSE fselclient: FUSE select example client
+  Copyright (C) 2008       SUSE Linux Products GmbH
+  Copyright (C) 2008       Tejun Heo <teheo@suse.de>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall fselclient.c -o fselclient
+*/
+
+#include <sys/select.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#define FSEL_FILES	16
+
+int main(void)
+{
+	static const char hex_map[FSEL_FILES] = "0123456789ABCDEF";
+	int fds[FSEL_FILES];
+	int i, nfds;
+
+	for (i = 0; i < FSEL_FILES; i++) {
+		char name[] = { hex_map[i], '\0' };
+		fds[i] = open(name, O_RDONLY);
+		if (fds[i] < 0) {
+			perror("open");
+			return 1;
+		}
+	}
+	nfds = fds[FSEL_FILES - 1] + 1;
+
+	while (1) {
+		static char buf[4096];
+		fd_set rfds;
+		int rc;
+
+		FD_ZERO(&rfds);
+		for (i = 0; i < FSEL_FILES; i++)
+			FD_SET(fds[i], &rfds);
+
+		rc = select(nfds, &rfds, NULL, NULL, NULL);
+
+		if (rc < 0) {
+			perror("select");
+			return 1;
+		}
+
+		for (i = 0; i < FSEL_FILES; i++) {
+			if (!FD_ISSET(fds[i], &rfds)) {
+				printf("_:   ");
+				continue;
+			}
+			printf("%X:", i);
+			rc = read(fds[i], buf, sizeof(buf));
+			if (rc < 0) {
+				perror("read");
+				return 1;
+			}
+			printf("%02d ", rc);
+		}
+		printf("\n");
+	}
+}
@@ -0,0 +1,412 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+  Copyright (C) 2011       Sebastian Pipping <sebastian@pipping.org>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall fusexmp.c `pkg-config fuse --cflags --libs` -o fusexmp
+*/
+
+#define FUSE_USE_VERSION 26
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifdef linux
+/* For pread()/pwrite()/utimensat() */
+#define _XOPEN_SOURCE 700
+#endif
+
+#include <fuse.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/time.h>
+#ifdef HAVE_SETXATTR
+#include <sys/xattr.h>
+#endif
+
+static int xmp_getattr(const char *path, struct stat *stbuf)
+{
+	int res;
+
+	res = lstat(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_access(const char *path, int mask)
+{
+	int res;
+
+	res = access(path, mask);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_readlink(const char *path, char *buf, size_t size)
+{
+	int res;
+
+	res = readlink(path, buf, size - 1);
+	if (res == -1)
+		return -errno;
+
+	buf[res] = '\0';
+	return 0;
+}
+
+
+static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+		       off_t offset, struct fuse_file_info *fi)
+{
+	DIR *dp;
+	struct dirent *de;
+
+	(void) offset;
+	(void) fi;
+
+	dp = opendir(path);
+	if (dp == NULL)
+		return -errno;
+
+	while ((de = readdir(dp)) != NULL) {
+		struct stat st;
+		memset(&st, 0, sizeof(st));
+		st.st_ino = de->d_ino;
+		st.st_mode = de->d_type << 12;
+		if (filler(buf, de->d_name, &st, 0))
+			break;
+	}
+
+	closedir(dp);
+	return 0;
+}
+
+static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
+{
+	int res;
+
+	/* On Linux this could just be 'mknod(path, mode, rdev)' but this
+	   is more portable */
+	if (S_ISREG(mode)) {
+		res = open(path, O_CREAT | O_EXCL | O_WRONLY, mode);
+		if (res >= 0)
+			res = close(res);
+	} else if (S_ISFIFO(mode))
+		res = mkfifo(path, mode);
+	else
+		res = mknod(path, mode, rdev);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_mkdir(const char *path, mode_t mode)
+{
+	int res;
+
+	res = mkdir(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_unlink(const char *path)
+{
+	int res;
+
+	res = unlink(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rmdir(const char *path)
+{
+	int res;
+
+	res = rmdir(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_symlink(const char *from, const char *to)
+{
+	int res;
+
+	res = symlink(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rename(const char *from, const char *to)
+{
+	int res;
+
+	res = rename(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_link(const char *from, const char *to)
+{
+	int res;
+
+	res = link(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chmod(const char *path, mode_t mode)
+{
+	int res;
+
+	res = chmod(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+{
+	int res;
+
+	res = lchown(path, uid, gid);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_truncate(const char *path, off_t size)
+{
+	int res;
+
+	res = truncate(path, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+#ifdef HAVE_UTIMENSAT
+static int xmp_utimens(const char *path, const struct timespec ts[2])
+{
+	int res;
+
+	/* don't use utime/utimes since they follow symlinks */
+	res = utimensat(0, path, ts, AT_SYMLINK_NOFOLLOW);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+#endif
+
+static int xmp_open(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+
+	res = open(path, fi->flags);
+	if (res == -1)
+		return -errno;
+
+	close(res);
+	return 0;
+}
+
+static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
+		    struct fuse_file_info *fi)
+{
+	int fd;
+	int res;
+
+	(void) fi;
+	fd = open(path, O_RDONLY);
+	if (fd == -1)
+		return -errno;
+
+	res = pread(fd, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	close(fd);
+	return res;
+}
+
+static int xmp_write(const char *path, const char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	int fd;
+	int res;
+
+	(void) fi;
+	fd = open(path, O_WRONLY);
+	if (fd == -1)
+		return -errno;
+
+	res = pwrite(fd, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	close(fd);
+	return res;
+}
+
+static int xmp_statfs(const char *path, struct statvfs *stbuf)
+{
+	int res;
+
+	res = statvfs(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_release(const char *path, struct fuse_file_info *fi)
+{
+	/* Just a stub.	 This method is optional and can safely be left
+	   unimplemented */
+
+	(void) path;
+	(void) fi;
+	return 0;
+}
+
+static int xmp_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+	/* Just a stub.	 This method is optional and can safely be left
+	   unimplemented */
+
+	(void) path;
+	(void) isdatasync;
+	(void) fi;
+	return 0;
+}
+
+#ifdef HAVE_POSIX_FALLOCATE
+static int xmp_fallocate(const char *path, int mode,
+			off_t offset, off_t length, struct fuse_file_info *fi)
+{
+	int fd;
+	int res;
+
+	(void) fi;
+
+	if (mode)
+		return -EOPNOTSUPP;
+
+	fd = open(path, O_WRONLY);
+	if (fd == -1)
+		return -errno;
+
+	res = -posix_fallocate(fd, offset, length);
+
+	close(fd);
+	return res;
+}
+#endif
+
+#ifdef HAVE_SETXATTR
+/* xattr operations are optional and can safely be left unimplemented */
+static int xmp_setxattr(const char *path, const char *name, const char *value,
+			size_t size, int flags)
+{
+	int res = lsetxattr(path, name, value, size, flags);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+
+static int xmp_getxattr(const char *path, const char *name, char *value,
+			size_t size)
+{
+	int res = lgetxattr(path, name, value, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_listxattr(const char *path, char *list, size_t size)
+{
+	int res = llistxattr(path, list, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_removexattr(const char *path, const char *name)
+{
+	int res = lremovexattr(path, name);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+#endif /* HAVE_SETXATTR */
+
+static struct fuse_operations xmp_oper = {
+	.getattr	= xmp_getattr,
+	.access		= xmp_access,
+	.readlink	= xmp_readlink,
+	.readdir	= xmp_readdir,
+	.mknod		= xmp_mknod,
+	.mkdir		= xmp_mkdir,
+	.symlink	= xmp_symlink,
+	.unlink		= xmp_unlink,
+	.rmdir		= xmp_rmdir,
+	.rename		= xmp_rename,
+	.link		= xmp_link,
+	.chmod		= xmp_chmod,
+	.chown		= xmp_chown,
+	.truncate	= xmp_truncate,
+#ifdef HAVE_UTIMENSAT
+	.utimens	= xmp_utimens,
+#endif
+	.open		= xmp_open,
+	.read		= xmp_read,
+	.write		= xmp_write,
+	.statfs		= xmp_statfs,
+	.release	= xmp_release,
+	.fsync		= xmp_fsync,
+#ifdef HAVE_POSIX_FALLOCATE
+	.fallocate	= xmp_fallocate,
+#endif
+#ifdef HAVE_SETXATTR
+	.setxattr	= xmp_setxattr,
+	.getxattr	= xmp_getxattr,
+	.listxattr	= xmp_listxattr,
+	.removexattr	= xmp_removexattr,
+#endif
+};
+
+int main(int argc, char *argv[])
+{
+	umask(0);
+	return fuse_main(argc, argv, &xmp_oper, NULL);
+}
@@ -0,0 +1,567 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+  Copyright (C) 2011       Sebastian Pipping <sebastian@pipping.org>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall fusexmp_fh.c `pkg-config fuse --cflags --libs` -lulockmgr -o fusexmp_fh
+*/
+
+#define FUSE_USE_VERSION 26
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+
+#include <fuse.h>
+#include <ulockmgr.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <errno.h>
+#include <sys/time.h>
+#ifdef HAVE_SETXATTR
+#include <sys/xattr.h>
+#endif
+#include <sys/file.h> /* flock(2) */
+
+static int xmp_getattr(const char *path, struct stat *stbuf)
+{
+	int res;
+
+	res = lstat(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_fgetattr(const char *path, struct stat *stbuf,
+			struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+
+	res = fstat(fi->fh, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_access(const char *path, int mask)
+{
+	int res;
+
+	res = access(path, mask);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_readlink(const char *path, char *buf, size_t size)
+{
+	int res;
+
+	res = readlink(path, buf, size - 1);
+	if (res == -1)
+		return -errno;
+
+	buf[res] = '\0';
+	return 0;
+}
+
+struct xmp_dirp {
+	DIR *dp;
+	struct dirent *entry;
+	off_t offset;
+};
+
+static int xmp_opendir(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+	struct xmp_dirp *d = malloc(sizeof(struct xmp_dirp));
+	if (d == NULL)
+		return -ENOMEM;
+
+	d->dp = opendir(path);
+	if (d->dp == NULL) {
+		res = -errno;
+		free(d);
+		return res;
+	}
+	d->offset = 0;
+	d->entry = NULL;
+
+	fi->fh = (unsigned long) d;
+	return 0;
+}
+
+static inline struct xmp_dirp *get_dirp(struct fuse_file_info *fi)
+{
+	return (struct xmp_dirp *) (uintptr_t) fi->fh;
+}
+
+static int xmp_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+		       off_t offset, struct fuse_file_info *fi)
+{
+	struct xmp_dirp *d = get_dirp(fi);
+
+	(void) path;
+	if (offset != d->offset) {
+		seekdir(d->dp, offset);
+		d->entry = NULL;
+		d->offset = offset;
+	}
+	while (1) {
+		struct stat st;
+		off_t nextoff;
+
+		if (!d->entry) {
+			d->entry = readdir(d->dp);
+			if (!d->entry)
+				break;
+		}
+
+		memset(&st, 0, sizeof(st));
+		st.st_ino = d->entry->d_ino;
+		st.st_mode = d->entry->d_type << 12;
+		nextoff = telldir(d->dp);
+		if (filler(buf, d->entry->d_name, &st, nextoff))
+			break;
+
+		d->entry = NULL;
+		d->offset = nextoff;
+	}
+
+	return 0;
+}
+
+static int xmp_releasedir(const char *path, struct fuse_file_info *fi)
+{
+	struct xmp_dirp *d = get_dirp(fi);
+	(void) path;
+	closedir(d->dp);
+	free(d);
+	return 0;
+}
+
+static int xmp_mknod(const char *path, mode_t mode, dev_t rdev)
+{
+	int res;
+
+	if (S_ISFIFO(mode))
+		res = mkfifo(path, mode);
+	else
+		res = mknod(path, mode, rdev);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_mkdir(const char *path, mode_t mode)
+{
+	int res;
+
+	res = mkdir(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_unlink(const char *path)
+{
+	int res;
+
+	res = unlink(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rmdir(const char *path)
+{
+	int res;
+
+	res = rmdir(path);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_symlink(const char *from, const char *to)
+{
+	int res;
+
+	res = symlink(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_rename(const char *from, const char *to)
+{
+	int res;
+
+	res = rename(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_link(const char *from, const char *to)
+{
+	int res;
+
+	res = link(from, to);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chmod(const char *path, mode_t mode)
+{
+	int res;
+
+	res = chmod(path, mode);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_chown(const char *path, uid_t uid, gid_t gid)
+{
+	int res;
+
+	res = lchown(path, uid, gid);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_truncate(const char *path, off_t size)
+{
+	int res;
+
+	res = truncate(path, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_ftruncate(const char *path, off_t size,
+			 struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+
+	res = ftruncate(fi->fh, size);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+#ifdef HAVE_UTIMENSAT
+static int xmp_utimens(const char *path, const struct timespec ts[2])
+{
+	int res;
+
+	/* don't use utime/utimes since they follow symlinks */
+	res = utimensat(0, path, ts, AT_SYMLINK_NOFOLLOW);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+#endif
+
+static int xmp_create(const char *path, mode_t mode, struct fuse_file_info *fi)
+{
+	int fd;
+
+	fd = open(path, fi->flags, mode);
+	if (fd == -1)
+		return -errno;
+
+	fi->fh = fd;
+	return 0;
+}
+
+static int xmp_open(const char *path, struct fuse_file_info *fi)
+{
+	int fd;
+
+	fd = open(path, fi->flags);
+	if (fd == -1)
+		return -errno;
+
+	fi->fh = fd;
+	return 0;
+}
+
+static int xmp_read(const char *path, char *buf, size_t size, off_t offset,
+		    struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	res = pread(fi->fh, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	return res;
+}
+
+static int xmp_read_buf(const char *path, struct fuse_bufvec **bufp,
+			size_t size, off_t offset, struct fuse_file_info *fi)
+{
+	struct fuse_bufvec *src;
+
+	(void) path;
+
+	src = malloc(sizeof(struct fuse_bufvec));
+	if (src == NULL)
+		return -ENOMEM;
+
+	*src = FUSE_BUFVEC_INIT(size);
+
+	src->buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
+	src->buf[0].fd = fi->fh;
+	src->buf[0].pos = offset;
+
+	*bufp = src;
+
+	return 0;
+}
+
+static int xmp_write(const char *path, const char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	res = pwrite(fi->fh, buf, size, offset);
+	if (res == -1)
+		res = -errno;
+
+	return res;
+}
+
+static int xmp_write_buf(const char *path, struct fuse_bufvec *buf,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	struct fuse_bufvec dst = FUSE_BUFVEC_INIT(fuse_buf_size(buf));
+
+	(void) path;
+
+	dst.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
+	dst.buf[0].fd = fi->fh;
+	dst.buf[0].pos = offset;
+
+	return fuse_buf_copy(&dst, buf, FUSE_BUF_SPLICE_NONBLOCK);
+}
+
+static int xmp_statfs(const char *path, struct statvfs *stbuf)
+{
+	int res;
+
+	res = statvfs(path, stbuf);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_flush(const char *path, struct fuse_file_info *fi)
+{
+	int res;
+
+	(void) path;
+	/* This is called from every close on an open file, so call the
+	   close on the underlying filesystem.	But since flush may be
+	   called multiple times for an open file, this must not really
+	   close the file.  This is important if used on a network
+	   filesystem like NFS which flush the data/metadata on close() */
+	res = close(dup(fi->fh));
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static int xmp_release(const char *path, struct fuse_file_info *fi)
+{
+	(void) path;
+	close(fi->fh);
+
+	return 0;
+}
+
+static int xmp_fsync(const char *path, int isdatasync,
+		     struct fuse_file_info *fi)
+{
+	int res;
+	(void) path;
+
+#ifndef HAVE_FDATASYNC
+	(void) isdatasync;
+#else
+	if (isdatasync)
+		res = fdatasync(fi->fh);
+	else
+#endif
+		res = fsync(fi->fh);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+#ifdef HAVE_POSIX_FALLOCATE
+static int xmp_fallocate(const char *path, int mode,
+			off_t offset, off_t length, struct fuse_file_info *fi)
+{
+	(void) path;
+
+	if (mode)
+		return -EOPNOTSUPP;
+
+	return -posix_fallocate(fi->fh, offset, length);
+}
+#endif
+
+#ifdef HAVE_SETXATTR
+/* xattr operations are optional and can safely be left unimplemented */
+static int xmp_setxattr(const char *path, const char *name, const char *value,
+			size_t size, int flags)
+{
+	int res = lsetxattr(path, name, value, size, flags);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+
+static int xmp_getxattr(const char *path, const char *name, char *value,
+			size_t size)
+{
+	int res = lgetxattr(path, name, value, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_listxattr(const char *path, char *list, size_t size)
+{
+	int res = llistxattr(path, list, size);
+	if (res == -1)
+		return -errno;
+	return res;
+}
+
+static int xmp_removexattr(const char *path, const char *name)
+{
+	int res = lremovexattr(path, name);
+	if (res == -1)
+		return -errno;
+	return 0;
+}
+#endif /* HAVE_SETXATTR */
+
+static int xmp_lock(const char *path, struct fuse_file_info *fi, int cmd,
+		    struct flock *lock)
+{
+	(void) path;
+
+	return ulockmgr_op(fi->fh, cmd, lock, &fi->lock_owner,
+			   sizeof(fi->lock_owner));
+}
+
+static int xmp_flock(const char *path, struct fuse_file_info *fi, int op)
+{
+	int res;
+	(void) path;
+
+	res = flock(fi->fh, op);
+	if (res == -1)
+		return -errno;
+
+	return 0;
+}
+
+static struct fuse_operations xmp_oper = {
+	.getattr	= xmp_getattr,
+	.fgetattr	= xmp_fgetattr,
+	.access		= xmp_access,
+	.readlink	= xmp_readlink,
+	.opendir	= xmp_opendir,
+	.readdir	= xmp_readdir,
+	.releasedir	= xmp_releasedir,
+	.mknod		= xmp_mknod,
+	.mkdir		= xmp_mkdir,
+	.symlink	= xmp_symlink,
+	.unlink		= xmp_unlink,
+	.rmdir		= xmp_rmdir,
+	.rename		= xmp_rename,
+	.link		= xmp_link,
+	.chmod		= xmp_chmod,
+	.chown		= xmp_chown,
+	.truncate	= xmp_truncate,
+	.ftruncate	= xmp_ftruncate,
+#ifdef HAVE_UTIMENSAT
+	.utimens	= xmp_utimens,
+#endif
+	.create		= xmp_create,
+	.open		= xmp_open,
+	.read		= xmp_read,
+	.read_buf	= xmp_read_buf,
+	.write		= xmp_write,
+	.write_buf	= xmp_write_buf,
+	.statfs		= xmp_statfs,
+	.flush		= xmp_flush,
+	.release	= xmp_release,
+	.fsync		= xmp_fsync,
+#ifdef HAVE_POSIX_FALLOCATE
+	.fallocate	= xmp_fallocate,
+#endif
+#ifdef HAVE_SETXATTR
+	.setxattr	= xmp_setxattr,
+	.getxattr	= xmp_getxattr,
+	.listxattr	= xmp_listxattr,
+	.removexattr	= xmp_removexattr,
+#endif
+	.lock		= xmp_lock,
+	.flock		= xmp_flock,
+
+	.flag_nullpath_ok = 1,
+#if HAVE_UTIMENSAT
+	.flag_utime_omit_ok = 1,
+#endif
+};
+
+int main(int argc, char *argv[])
+{
+	umask(0);
+	return fuse_main(argc, argv, &xmp_oper, NULL);
+}
@@ -0,0 +1,96 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall hello.c `pkg-config fuse --cflags --libs` -o hello
+*/
+
+#define FUSE_USE_VERSION 26
+
+#include <fuse.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+
+static const char *hello_str = "Hello World!\n";
+static const char *hello_path = "/hello";
+
+static int hello_getattr(const char *path, struct stat *stbuf)
+{
+	int res = 0;
+
+	memset(stbuf, 0, sizeof(struct stat));
+	if (strcmp(path, "/") == 0) {
+		stbuf->st_mode = S_IFDIR | 0755;
+		stbuf->st_nlink = 2;
+	} else if (strcmp(path, hello_path) == 0) {
+		stbuf->st_mode = S_IFREG | 0444;
+		stbuf->st_nlink = 1;
+		stbuf->st_size = strlen(hello_str);
+	} else
+		res = -ENOENT;
+
+	return res;
+}
+
+static int hello_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
+			 off_t offset, struct fuse_file_info *fi)
+{
+	(void) offset;
+	(void) fi;
+
+	if (strcmp(path, "/") != 0)
+		return -ENOENT;
+
+	filler(buf, ".", NULL, 0);
+	filler(buf, "..", NULL, 0);
+	filler(buf, hello_path + 1, NULL, 0);
+
+	return 0;
+}
+
+static int hello_open(const char *path, struct fuse_file_info *fi)
+{
+	if (strcmp(path, hello_path) != 0)
+		return -ENOENT;
+
+	if ((fi->flags & 3) != O_RDONLY)
+		return -EACCES;
+
+	return 0;
+}
+
+static int hello_read(const char *path, char *buf, size_t size, off_t offset,
+		      struct fuse_file_info *fi)
+{
+	size_t len;
+	(void) fi;
+	if(strcmp(path, hello_path) != 0)
+		return -ENOENT;
+
+	len = strlen(hello_str);
+	if (offset < len) {
+		if (offset + size > len)
+			size = len - offset;
+		memcpy(buf, hello_str + offset, size);
+	} else
+		size = 0;
+
+	return size;
+}
+
+static struct fuse_operations hello_oper = {
+	.getattr	= hello_getattr,
+	.readdir	= hello_readdir,
+	.open		= hello_open,
+	.read		= hello_read,
+};
+
+int main(int argc, char *argv[])
+{
+	return fuse_main(argc, argv, &hello_oper, NULL);
+}
@@ -0,0 +1,181 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall hello_ll.c `pkg-config fuse --cflags --libs` -o hello_ll
+*/
+
+#define FUSE_USE_VERSION 26
+
+#include <fuse_lowlevel.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <assert.h>
+
+static const char *hello_str = "Hello World!\n";
+static const char *hello_name = "hello";
+
+static int hello_stat(fuse_ino_t ino, struct stat *stbuf)
+{
+	stbuf->st_ino = ino;
+	switch (ino) {
+	case 1:
+		stbuf->st_mode = S_IFDIR | 0755;
+		stbuf->st_nlink = 2;
+		break;
+
+	case 2:
+		stbuf->st_mode = S_IFREG | 0444;
+		stbuf->st_nlink = 1;
+		stbuf->st_size = strlen(hello_str);
+		break;
+
+	default:
+		return -1;
+	}
+	return 0;
+}
+
+static void hello_ll_getattr(fuse_req_t req, fuse_ino_t ino,
+			     struct fuse_file_info *fi)
+{
+	struct stat stbuf;
+
+	(void) fi;
+
+	memset(&stbuf, 0, sizeof(stbuf));
+	if (hello_stat(ino, &stbuf) == -1)
+		fuse_reply_err(req, ENOENT);
+	else
+		fuse_reply_attr(req, &stbuf, 1.0);
+}
+
+static void hello_ll_lookup(fuse_req_t req, fuse_ino_t parent, const char *name)
+{
+	struct fuse_entry_param e;
+
+	if (parent != 1 || strcmp(name, hello_name) != 0)
+		fuse_reply_err(req, ENOENT);
+	else {
+		memset(&e, 0, sizeof(e));
+		e.ino = 2;
+		e.attr_timeout = 1.0;
+		e.entry_timeout = 1.0;
+		hello_stat(e.ino, &e.attr);
+
+		fuse_reply_entry(req, &e);
+	}
+}
+
+struct dirbuf {
+	char *p;
+	size_t size;
+};
+
+static void dirbuf_add(fuse_req_t req, struct dirbuf *b, const char *name,
+		       fuse_ino_t ino)
+{
+	struct stat stbuf;
+	size_t oldsize = b->size;
+	b->size += fuse_add_direntry(req, NULL, 0, name, NULL, 0);
+	b->p = (char *) realloc(b->p, b->size);
+	memset(&stbuf, 0, sizeof(stbuf));
+	stbuf.st_ino = ino;
+	fuse_add_direntry(req, b->p + oldsize, b->size - oldsize, name, &stbuf,
+			  b->size);
+}
+
+#define min(x, y) ((x) < (y) ? (x) : (y))
+
+static int reply_buf_limited(fuse_req_t req, const char *buf, size_t bufsize,
+			     off_t off, size_t maxsize)
+{
+	if (off < bufsize)
+		return fuse_reply_buf(req, buf + off,
+				      min(bufsize - off, maxsize));
+	else
+		return fuse_reply_buf(req, NULL, 0);
+}
+
+static void hello_ll_readdir(fuse_req_t req, fuse_ino_t ino, size_t size,
+			     off_t off, struct fuse_file_info *fi)
+{
+	(void) fi;
+
+	if (ino != 1)
+		fuse_reply_err(req, ENOTDIR);
+	else {
+		struct dirbuf b;
+
+		memset(&b, 0, sizeof(b));
+		dirbuf_add(req, &b, ".", 1);
+		dirbuf_add(req, &b, "..", 1);
+		dirbuf_add(req, &b, hello_name, 2);
+		reply_buf_limited(req, b.p, b.size, off, size);
+		free(b.p);
+	}
+}
+
+static void hello_ll_open(fuse_req_t req, fuse_ino_t ino,
+			  struct fuse_file_info *fi)
+{
+	if (ino != 2)
+		fuse_reply_err(req, EISDIR);
+	else if ((fi->flags & 3) != O_RDONLY)
+		fuse_reply_err(req, EACCES);
+	else
+		fuse_reply_open(req, fi);
+}
+
+static void hello_ll_read(fuse_req_t req, fuse_ino_t ino, size_t size,
+			  off_t off, struct fuse_file_info *fi)
+{
+	(void) fi;
+
+	assert(ino == 2);
+	reply_buf_limited(req, hello_str, strlen(hello_str), off, size);
+}
+
+static struct fuse_lowlevel_ops hello_ll_oper = {
+	.lookup		= hello_ll_lookup,
+	.getattr	= hello_ll_getattr,
+	.readdir	= hello_ll_readdir,
+	.open		= hello_ll_open,
+	.read		= hello_ll_read,
+};
+
+int main(int argc, char *argv[])
+{
+	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
+	struct fuse_chan *ch;
+	char *mountpoint;
+	int err = -1;
+
+	if (fuse_parse_cmdline(&args, &mountpoint, NULL, NULL) != -1 &&
+	    (ch = fuse_mount(mountpoint, &args)) != NULL) {
+		struct fuse_session *se;
+
+		se = fuse_lowlevel_new(&args, &hello_ll_oper,
+				       sizeof(hello_ll_oper), NULL);
+		if (se != NULL) {
+			if (fuse_set_signal_handlers(se) != -1) {
+				fuse_session_add_chan(se, ch);
+				err = fuse_session_loop(se);
+				fuse_remove_signal_handlers(se);
+				fuse_session_remove_chan(ch);
+			}
+			fuse_session_destroy(se);
+		}
+		fuse_unmount(mountpoint, ch);
+	}
+	fuse_opt_free_args(&args);
+
+	return err ? 1 : 0;
+}
@@ -0,0 +1,95 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU GPL.
+  See the file COPYING.
+
+  gcc -Wall null.c `pkg-config fuse --cflags --libs` -o null
+*/
+
+#define FUSE_USE_VERSION 26
+
+#include <fuse.h>
+#include <string.h>
+#include <unistd.h>
+#include <time.h>
+#include <errno.h>
+
+static int null_getattr(const char *path, struct stat *stbuf)
+{
+	if(strcmp(path, "/") != 0)
+		return -ENOENT;
+
+	stbuf->st_mode = S_IFREG | 0644;
+	stbuf->st_nlink = 1;
+	stbuf->st_uid = getuid();
+	stbuf->st_gid = getgid();
+	stbuf->st_size = (1ULL << 32); /* 4G */
+	stbuf->st_blocks = 0;
+	stbuf->st_atime = stbuf->st_mtime = stbuf->st_ctime = time(NULL);
+
+	return 0;
+}
+
+static int null_truncate(const char *path, off_t size)
+{
+	(void) size;
+
+	if(strcmp(path, "/") != 0)
+		return -ENOENT;
+
+	return 0;
+}
+
+static int null_open(const char *path, struct fuse_file_info *fi)
+{
+	(void) fi;
+
+	if(strcmp(path, "/") != 0)
+		return -ENOENT;
+
+	return 0;
+}
+
+static int null_read(const char *path, char *buf, size_t size,
+		     off_t offset, struct fuse_file_info *fi)
+{
+	(void) buf;
+	(void) offset;
+	(void) fi;
+
+	if(strcmp(path, "/") != 0)
+		return -ENOENT;
+
+	if (offset >= (1ULL << 32))
+		return 0;
+
+	return size;
+}
+
+static int null_write(const char *path, const char *buf, size_t size,
+		      off_t offset, struct fuse_file_info *fi)
+{
+	(void) buf;
+	(void) offset;
+	(void) fi;
+
+	if(strcmp(path, "/") != 0)
+		return -ENOENT;
+
+	return size;
+}
+
+static struct fuse_operations null_oper = {
+	.getattr	= null_getattr,
+	.truncate	= null_truncate,
+	.open		= null_open,
+	.read		= null_read,
+	.write		= null_write,
+};
+
+int main(int argc, char *argv[])
+{
+	return fuse_main(argc, argv, &null_oper, NULL);
+}
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: fuse
+Description: Filesystem in Userspace
+Version: @VERSION@
+Libs: -L${libdir} -lfuse -pthread
+Libs.private: @libfuse_libs@
+Cflags: -I${includedir}/fuse -D_FILE_OFFSET_BITS=64
@@ -0,0 +1,17 @@
+## Process this file with automake to produce Makefile.in
+
+fuseincludedir=$(includedir)/fuse
+
+fuseinclude_HEADERS = \
+	fuse.h			\
+	fuse_compat.h		\
+	fuse_common.h		\
+	fuse_common_compat.h    \
+	fuse_lowlevel.h		\
+	fuse_lowlevel_compat.h	\
+	fuse_opt.h		\
+	cuse_lowlevel.h
+
+include_HEADERS = old/fuse.h ulockmgr.h
+
+noinst_HEADERS = fuse_kernel.h
@@ -0,0 +1,87 @@
+/*
+  CUSE: Character device in Userspace
+  Copyright (C) 2008-2009  SUSE Linux Products GmbH
+  Copyright (C) 2008-2009  Tejun Heo <tj@kernel.org>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+
+  Read example/cusexmp.c for usages.
+*/
+
+#ifndef _CUSE_LOWLEVEL_H_
+#define _CUSE_LOWLEVEL_H_
+
+#ifndef FUSE_USE_VERSION
+#define FUSE_USE_VERSION 29
+#endif
+
+#include "fuse_lowlevel.h"
+
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CUSE_UNRESTRICTED_IOCTL		(1 << 0) /* use unrestricted ioctl */
+
+struct fuse_session;
+
+struct cuse_info {
+	unsigned	dev_major;
+	unsigned	dev_minor;
+	unsigned	dev_info_argc;
+	const char	**dev_info_argv;
+	unsigned	flags;
+};
+
+/*
+ * Most ops behave almost identically to the matching fuse_lowlevel
+ * ops except that they don't take @ino.
+ *
+ * init_done	: called after initialization is complete
+ * read/write	: always direct IO, simultaneous operations allowed
+ * ioctl	: might be in unrestricted mode depending on ci->flags
+ */
+struct cuse_lowlevel_ops {
+	void (*init) (void *userdata, struct fuse_conn_info *conn);
+	void (*init_done) (void *userdata);
+	void (*destroy) (void *userdata);
+	void (*open) (fuse_req_t req, struct fuse_file_info *fi);
+	void (*read) (fuse_req_t req, size_t size, off_t off,
+		      struct fuse_file_info *fi);
+	void (*write) (fuse_req_t req, const char *buf, size_t size, off_t off,
+		       struct fuse_file_info *fi);
+	void (*flush) (fuse_req_t req, struct fuse_file_info *fi);
+	void (*release) (fuse_req_t req, struct fuse_file_info *fi);
+	void (*fsync) (fuse_req_t req, int datasync, struct fuse_file_info *fi);
+	void (*ioctl) (fuse_req_t req, int cmd, void *arg,
+		       struct fuse_file_info *fi, unsigned int flags,
+		       const void *in_buf, size_t in_bufsz, size_t out_bufsz);
+	void (*poll) (fuse_req_t req, struct fuse_file_info *fi,
+		      struct fuse_pollhandle *ph);
+};
+
+struct fuse_session *cuse_lowlevel_new(struct fuse_args *args,
+				       const struct cuse_info *ci,
+				       const struct cuse_lowlevel_ops *clop,
+				       void *userdata);
+
+struct fuse_session *cuse_lowlevel_setup(int argc, char *argv[],
+					 const struct cuse_info *ci,
+					 const struct cuse_lowlevel_ops *clop,
+					 int *multithreaded, void *userdata);
+
+void cuse_lowlevel_teardown(struct fuse_session *se);
+
+int cuse_lowlevel_main(int argc, char *argv[], const struct cuse_info *ci,
+		       const struct cuse_lowlevel_ops *clop, void *userdata);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _CUSE_LOWLEVEL_H_ */
--- a/Show More
+++ b/Show More