checkpoint

Misc cleanup

.cirrus.yml

@@ -0,0 +1,416 @@
+freebsd_task:
+  name: "freebsd:11.4"
+  freebsd_instance:
+    image_family: freebsd-11-4
+  env:
+    ASSUME_ALWAYS_YES: yes
+  script:
+    - tools/install-build-pkgs
+    - gmake -j4
+
+freebsd_task:
+  name: "freebsd:12.1"
+  freebsd_instance:
+    image_family: freebsd-12-1
+  env:
+    ASSUME_ALWAYS_YES: yes
+  script:
+    - tools/install-build-pkgs
+    - gmake -j4
+
+freebsd_task:
+  name: "freebsd:12.2"
+  freebsd_instance:
+    image_family: freebsd-12-2
+  env:
+    ASSUME_ALWAYS_YES: yes
+  script:
+    - tools/install-build-pkgs
+    - gmake -j4
+
+freebsd_task:
+  name: "freebsd:13.0"
+  freebsd_instance:
+    image_family: freebsd-13-0
+  env:
+    ASSUME_ALWAYS_YES: yes
+  script:
+    - tools/install-build-pkgs
+    - gmake -j4
+
+
+#macos_task:
+#  osx_instance:
+#    image: catalina-base
+#  script:
+#    - tools/install-build-pkgs
+#    - gmake -j4
+
+linux_task:
+  name: "alpine:3.11"
+  container:
+    image: alpine:3.11
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.12"
+  container:
+    image: alpine:3.12
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.13"
+  container:
+    image: alpine:3.13
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.14"
+  container:
+    image: alpine:3.14
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:latest"
+  container:
+    image: alpine:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine-arm:latest"
+  arm_container:
+    image: alpine:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "centos:7"
+  container:
+    image: centos:7
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "centos:8"
+  container:
+    image: centos:8
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:30"
+  container:
+    image: fedora:30
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:31"
+  container:
+    image: fedora:31
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:32"
+  container:
+    image: fedora:32
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:33"
+  container:
+    image: fedora:33
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:34"
+  container:
+    image: fedora:34
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:latest"
+  container:
+    image: fedora:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora-arm:latest"
+  arm_container:
+    image: fedora:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "ubuntu:14.04"
+  container:
+    image: ubuntu:14.04
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:16.04"
+  container:
+    image: ubuntu:16.04
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:18.04"
+  container:
+    image: ubuntu:18.04
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:20.04"
+  container:
+    image: ubuntu:20.04
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:latest"
+  container:
+    image: ubuntu:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu-arm:latest"
+  arm_container:
+    image: ubuntu:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:7"
+  container:
+    image: debian:8
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:8"
+  container:
+    image: debian:8
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:9"
+  container:
+    image: debian:9
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:10"
+  container:
+    image: debian:10
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:11"
+  container:
+    image: debian:11
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:latest"
+  container:
+    image: debian:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian-arm:latest"
+  arm_container:
+    image: debian:latest
+    cpu: 4
+    memory: 2G
+  timeout_in: 10m
+  script:
+    - tools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true

.github/FUNDING.yml

@@ -0,0 +1,7 @@
+# These are supported funding model platforms
+
+github: [trapexit]
+patreon: trapexit
+custom: ['https://paypal.me/trapexit','https://buymeacoff.ee/trapexit']
+ko_fi: trapexit
+open_collective: trapexit

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,49 @@
+---
+name: Bug report
+about: For the reporting of behavior not as described
+title: ''
+labels: bug, investigating
+assignees: ''
+
+---
+
+**Describe the bug**
+
+A clear and concise description of the unexpected behavior.
+
+**Please be sure to use latest release of mergerfs to ensure the issue still exists. Not your distro's latest but the latest official release.**
+
+The master branch is **not** to be considered production ready. Feel free to file bug reports but do so indicating clearly that you are testing unreleased code.
+
+
+**To Reproduce**
+
+Steps to reproduce the behavior. List **all** steps to reproduce. **All** settings.
+
+Please simplify the reproduction as much as possible.
+ - Unless it is dependenat on multiple branches, use a single branch
+ - Reproduce with standard tooling if possible (touch,truncate,rm,rmdir,ln,etc.) Having to install 3rd party software will make debugging more difficult.
+
+
+**Expected behavior**
+
+A clear and concise description of the expected behavior.
+
+
+**System information:**
+
+ - OS, kernel version: `uname -a`
+ - mergerfs version: `mergerfs -V`
+ - mergerfs settings
+ - List of drives, filesystems, & sizes:
+   - `df -h`
+   - `lsblk -f`
+ - A strace of the application having a problem:
+   - `strace -fvTtt -s 256 -o /tmp/app.strace.txt <cmd>`
+   - `strace -fvTtt -s 256 -o /tmp/app.strace.txt -p <appPID>`
+ - strace of mergerfs while app tried to do it's thing:
+   - `strace -fvTtt -s 256 -p <mergerfsPID> -o /tmp/mergerfs.strace.txt`
+
+**Additional context**
+
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: feature, investigating
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is.
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,10 @@
+---
+name: Question
+about: When you're looking for information or general support
+title: ''
+labels: investigating, question
+assignees: ''
+
+---
+
+For general questions and support please use [GitHub Discussions](https://github.com/trapexit/mergerfs/discussions) or [Discord](https://discord.gg/MpAr69V).

.github/workflows/codeql.yml

@@ -0,0 +1,42 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+  schedule:
+    - cron: "7 3 * * 6"
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ python, cpp ]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v2
+        with:
+          languages: ${{ matrix.language }}
+          queries: +security-and-quality
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v2
+        if: ${{ matrix.language == 'python' || matrix.language == 'cpp' }}
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v2
+        with:
+          category: "/language:${{ matrix.language }}"

.gitignore

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

LICENSE

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

Makefile

@@ -1,170 +1,260 @@
-# The MIT License (MIT)
+#  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 #
-# Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+#  Permission to use, copy, modify, and/or distribute this software for any
+#  purpose with or without fee is hereby granted, provided that the above
+#  copyright notice and this permission notice appear in all copies.
 #
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
+#  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+#  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+#  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+#  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+#  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+#  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+#  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
-PKGCONFIG =  	$(shell which pkg-config)
-GIT 	  = 	$(shell which git)
-TAR 	  = 	$(shell which tar)
-MKDIR     = 	$(shell which mkdir)
-TOUCH 	  = 	$(shell which touch)
-CP        = 	$(shell which cp)
-RM 	  = 	$(shell which rm)
-LN        =     $(shell which ln)
-FIND 	  = 	$(shell which find)
-INSTALL   = 	$(shell which install)
-MKTEMP    = 	$(shell which mktemp)
-STRIP     = 	$(shell which strip)
-PANDOC    =	$(shell which pandoc)
-GIT2DEBCL =     ./tools/git2debcl
-CPPFIND   =     ./tools/cppfind
+GIT 	  = git
+TAR 	  = tar
+MKDIR     = mkdir
+TOUCH 	  = touch
+CP        = cp
+RM 	  = rm
+LN        = ln
+FIND 	  = find
+INSTALL   = install
+MKTEMP    = mktemp
+STRIP     = strip
+PANDOC    = pandoc
+SED       = sed
+RPMBUILD  = rpmbuild
+GIT2DEBCL = ./tools/git2debcl
+PKGCONFIG = pkg-config
 
-ifeq ($(PKGCONFIG),"")
-$(error "pkg-config not installed"
+GIT_REPO = 0
+ifneq ($(shell $(GIT) --version 2> /dev/null),)
+ifeq  ($(shell test -e .git; echo $$?),0)
+GIT_REPO = 1
+endif
 endif
 
-ifeq ($(PANDOC),"")
-$(warning "pandoc does not appear available: manpage won't be buildable")
+USE_XATTR = 1
+UGID_USE_RWLOCK = 0
+
+ifeq ($(DEBUG),1)
+OPT_FLAGS := -O0 -g -fsanitize=undefined
+else
+OPT_FLAGS := -O2
 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 $$?)
+ifeq ($(STATIC),1)
+STATIC_FLAGS := -static
+else
+STATIC_FLAGS :=
 endif
 
-ifeq ($(FUSE_AVAILABLE),0)
-$(error "FUSE development package doesn't appear available")
+ifeq ($(LTO),1)
+LTO_FLAGS := -flto
+else
+LTO_FLAGS :=
 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")
-
-OPTS 	    = -O2
 SRC	    = $(wildcard src/*.cpp)
-OBJ         = $(SRC:src/%.cpp=obj/%.o)
-DEPS        = $(OBJ:obj/%.o=obj/%.d)
-TARGET      = mergerfs
-MANPAGE     = $(TARGET).1
-FUSE_CFLAGS = $(shell $(PKGCONFIG) --cflags fuse)
-CFLAGS      = -g -Wall \
-	      $(OPTS) \
-              $(FUSE_CFLAGS) \
-              -DFUSE_USE_VERSION=26 \
-              -MMD \
-	      -DFLAG_NOPATH=$(FLAG_NOPATH) \
-	      -DFALLOCATE=$(FALLOCATE) \
-              -DFLOCK=$(FLOCK) \
-	      -DREAD_BUF=$(READ_BUF) \
-              -DWRITE_BUF=$(WRITE_BUF)
-LDFLAGS       = $(shell $(PKGCONFIG) fuse --libs)
+OBJS        = $(SRC:src/%.cpp=build/.src/%.o)
+DEPS        = $(SRC:src/%.cpp=build/.src/%.d)
 
-BINDIR 	      =	$(PREFIX)/usr/bin
-MANDIR 	      =	$(PREFIX)/usr/share/man/man1
-INSTALLBINDIR = $(DESTDIR)$(BINDIR)
-INSTALLMANDIR = $(DESTDIR)$(MANDIR)
+TESTS       = $(wildcard tests/*.cpp)
+TESTS_OBJS  = $(filter-out build/.src/mergerfs.o,$(OBJS))
+TESTS_OBJS += $(TESTS:tests/%.cpp=build/.tests/%.o)
+TESTS_DEPS  = $(TESTS:tests/%.cpp=build/.tests/%.d)
+TESTS_DEPS += $(DEPS)
 
-ifeq ($(XATTR_AVAILABLE),0)
-$(warning "xattr not available: disabling")
-CFLAGS += -DWITHOUT_XATTR
-endif
+MANPAGE     = mergerfs.1
+CXXFLAGS    ?= ${OPT_FLAGS}
+CXXFLAGS    := \
+              ${CXXFLAGS} \
+              -std=c++11 \
+              $(STATIC_FLAGS) \
+              $(LTO_FLAGS) \
+              -Wall \
+              -Wno-unused-result \
+              -MMD
+FUSE_FLAGS = \
+              -Ilibfuse/include \
+              -D_FILE_OFFSET_BITS=64 \
+              -DFUSE_USE_VERSION=29
+MFS_FLAGS  = \
+	      -DUSE_XATTR=$(USE_XATTR) \
+	      -DUGID_USE_RWLOCK=$(UGID_USE_RWLOCK)
+TESTS_FLAGS = \
+              -Isrc \
+              -DTESTS
 
-all: $(TARGET) clonepath
+LDFLAGS := \
+    ${LDFLAGS} \
+    -pthread \
+    -lrt
 
+DESTDIR       =
+PREFIX        = /usr/local
+EXEC_PREFIX   = $(PREFIX)
+DATAROOTDIR   = $(PREFIX)/share
+DATADIR       = $(DATAROOTDIR)
+BINDIR        = $(EXEC_PREFIX)/bin
+SBINDIR       = $(EXEC_PREFIX)/sbin
+MANDIR        = $(DATAROOTDIR)/man
+MAN1DIR       = $(MANDIR)/man1
+
+INSTALLBINDIR  = $(DESTDIR)$(BINDIR)
+INSTALLSBINDIR = $(DESTDIR)$(SBINDIR)
+INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)
+
+.PHONY: all
+all: mergerfs
+
+.PHONY: help
 help:
-	@echo "usage: make"
-	@echo "make XATTR_AVAILABLE=0 - to build program without xattrs functionality (auto discovered otherwise)"
+	@echo "usage: make\n"
+	@echo "make USE_XATTR=0      - build program without xattrs functionality"
+	@echo "make STATIC=1         - build static binary"
+	@echo "make LTO=1            - build with link time optimization"
 
-$(TARGET): obj/obj-stamp $(OBJ)
-	$(CXX) $(CFLAGS) $(OBJ) -o $@ $(LDFLAGS)
+objects: version build/stamp
+	$(MAKE) $(OBJS)
 
-clonepath: $(TARGET)
-	$(LN) -s $< $@
+tests-objects:
+	$(MAKE) $(TESTS_OBJS)
+
+build/mergerfs: libfuse objects
+	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)
+
+build/tests: build/mergerfs tests-objects
+	$(CXX) $(CXXFLAGS) $(TESTS_FLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(TESTS_OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)
+
+mergerfs: build/mergerfs
+
+tests: build/tests
 
 changelog:
-	$(GIT) log --pretty --numstat --summary | git2cl > ChangeLog
+ifeq ($(GIT_REPO),1)
+	$(GIT2DEBCL) --name mergerfs > ChangeLog
+else
+	@echo "WARNING: need git repo to generate ChangeLog"
+endif
 
-obj/obj-stamp:
-	$(MKDIR) -p obj
+.PHONY: version
+version:
+	tools/update-version
+
+build/stamp:
+	$(MKDIR) -p build/.src build/.tests
 	$(TOUCH) $@
 
-obj/%.o: src/%.cpp
-	$(CXX) $(CFLAGS) -c $< -o $@
+build/.src/%.o: src/%.cpp
+	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) -c $< -o $@
 
-clean:
-	$(RM) -rf obj
-	$(RM) -f "$(TARGET)" "$(MANPAGE)" clonepath
-	$(FIND) -name "*~" -delete
+build/.tests/%.o: tests/%.cpp
+	$(CXX) $(CXXFLAGS) $(TESTS_FLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) -c $< -o $@
+
+
+.PHONY: clean
+clean: rpm-clean
+	$(RM) -rf build
+	$(FIND) . -name "*~" -delete
+	$(MAKE) -C libfuse clean
 
 distclean: clean
-	$(GIT) clean -fd
+ifeq ($(GIT_REPO),1)
+	$(GIT) clean -xfd
+endif
 
-install: install-base install-clonepath install-man
+.PHONY: install
+install: install-base install-mount-tools install-man
 
-install-base: $(TARGET)
-	$(INSTALL) -v -m 0755 -D "$(TARGET)" "$(INSTALLBINDIR)/$(TARGET)"
+install-base: build/mergerfs
+	$(MKDIR) -p "$(INSTALLBINDIR)"
+	$(INSTALL) -v -m 0755 build/mergerfs "$(INSTALLBINDIR)/mergerfs"
 
-install-clonepath: clonepath
-	$(CP) -a $< "$(INSTALLBINDIR)/$<"
+install-mount-tools: install-base
+	$(MKDIR) -p "$(INSTALLBINDIR)"
+	$(MAKE) -C libfuse install
 
 install-man: $(MANPAGE)
-	$(INSTALL) -v -m 0644 -D "$(MANPAGE)" "$(INSTALLMANDIR)/$(MANPAGE)"
+	$(MKDIR) -p "$(INSTALLMAN1DIR)"
+	$(INSTALL) -v -m 0644 "man/$(MANPAGE)" "$(INSTALLMAN1DIR)/$(MANPAGE)"
 
 install-strip: install-base
-	$(STRIP) "$(INSTALLBINDIR)/$(TARGET)"
+	$(STRIP) "$(INSTALLBINDIR)/mergerfs"
 
-uninstall: uninstall-base uninstall-clonepath uninstall-man
+.PHONY: uninstall
+uninstall: uninstall-base uninstall-mount.mergerfs uninstall-man
 
 uninstall-base:
-	$(RM) -f "$(INSTALLBINDIR)/$(TARGET)"
+	$(RM) -f "$(INSTALLBINDIR)/mergerfs"
 
-uninstall-clonepath:
-	$(RM) -f "$(INSTALLBINDIR)/clonepath"
+uninstall-mount.mergerfs:
+	$(RM) -f "$(INSTALLBINDIR)/mount.mergerfs"
 
 uninstall-man:
-	$(RM) -f "$(INSTALLMANDIR)/$(MANPAGE")
+	$(RM) -f "$(INSTALLMAN1DIR)/$(MANPAGE)"
 
 $(MANPAGE): README.md
-	$(PANDOC) -s -t man -o $(MANPAGE) README.md
+ifneq ($(shell $(PANDOC) --version 2> /dev/null),)
+	$(PANDOC) -s -t man -o "man/$(MANPAGE)" README.md
+else
+	$(warning "pandoc does not appear available: unable to build manpage")
+endif
 
 man: $(MANPAGE)
 
-tarball: clean changelog man
-	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
-	$(eval FILENAME := $(TARGET)-$(VERSION))
+.PHONY: tarball
+tarball: man changelog version
+	$(eval VERSION := $(shell cat VERSION))
+	$(eval VERSION := $(subst -,_,$(VERSION)))
+	$(eval FILENAME := mergerfs-$(VERSION))
 	$(eval TMPDIR := $(shell $(MKTEMP) --tmpdir -d .$(FILENAME).XXXXXXXX))
 	$(MKDIR) $(TMPDIR)/$(FILENAME)
 	$(CP) -ar . $(TMPDIR)/$(FILENAME)
-	$(TAR) --exclude=.git -cz -C $(TMPDIR) -f ../$(FILENAME).tar.gz $(FILENAME)
+	$(TAR) --exclude=.git -cz -C $(TMPDIR) -f $(FILENAME).tar.gz $(FILENAME)
 	$(RM) -rf $(TMPDIR)
 
+debian-changelog:
+ifeq ($(GIT_REPO),1)
+	$(GIT2DEBCL) --name mergerfs > debian/changelog
+else
+	cp ChangeLog debian/changelog
+endif
+
+signed-deb:
+	$(MAKE) distclean
+	$(MAKE) debian-changelog
+	dpkg-source -b .
+	dpkg-buildpackage -nc
+
 deb:
-	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
-	$(GIT2DEBCL) $(TARGET) $(VERSION) > debian/changelog
-	$(GIT) buildpackage --git-ignore-new
+	$(MAKE) distclean
+	$(MAKE) debian-changelog
+	dpkg-source -b .
+	dpkg-buildpackage -nc -uc -us
 
-.PHONY: all clean install help
+.PHONY: rpm-clean
+rpm-clean:
+	$(RM) -rf rpmbuild
 
-include $(wildcard obj/*.d)
+rpm: tarball
+	$(eval VERSION := $(shell cat VERSION))
+	$(eval VERSION := $(subst -,_,$(VERSION)))
+	$(MKDIR) -p rpmbuild/BUILD rpmbuild/RPMS rpmbuild/SOURCES
+	$(SED) 's/__VERSION__/$(VERSION)/g' mergerfs.spec > \
+		rpmbuild/SOURCES/mergerfs.spec
+	cp -ar mergerfs-$(VERSION).tar.gz rpmbuild/SOURCES
+	$(RPMBUILD) -ba rpmbuild/SOURCES/mergerfs.spec \
+		--define "_topdir $(CURDIR)/rpmbuild"
+
+.PHONY: install-build-pkgs
+install-build-pkgs:
+	tools/install-build-pkgs
+
+.PHONY: libfuse
+libfuse:
+	$(MAKE) DEBUG=$(DEBUG) -C libfuse
+
+-include $(DEPS)

debian/control

@@ -2,10 +2,7 @@ Source: mergerfs
 Section: utils
 Priority: optional
 Maintainer: Antonio SJ Musumeci <trapexit@spawn.link>
-Build-Depends: debhelper (>= 8.0.0),
- libfuse-dev,
- libattr1-dev,
- pkg-config
+Build-Depends: debhelper (>= 8.0.0)
 Standards-Version: 3.9.4
 Homepage: http://github.com/trapexit/mergerfs
 
@@ -13,8 +10,8 @@ Package: mergerfs
 Architecture: any
 Depends: ${shlibs:Depends},
  ${misc:Depends},
- libfuse2
+ fuse [linux-any] | fuse4bsd [kfreebsd-any]
 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
- behavior.
+ 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.

debian/copyright

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

debian/mergerfs.postinst

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+set -e
+
+case "${1}" in
+    configure)
+        chmod 4755 /usr/bin/mergerfs-fusermount
+        ;;
+esac

debian/rules

@@ -2,7 +2,10 @@
 # -*- makefile -*-
 
 # Uncomment this to turn on verbose mode.
-#export DH_VERBOSE=1
+export DH_VERBOSE=1
 
 %:
-	dh $@
+	dh $@ --parallel
+
+override_dh_auto_install:
+	$(MAKE) DESTDIR=$(CURDIR)/debian/mergerfs PREFIX=/usr install

libfuse/AUTHORS

@@ -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>

libfuse/COPYING

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

libfuse/COPYING.LIB

@@ -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!

libfuse/Makefile

@@ -0,0 +1,131 @@
+VERSION = 2.9.7-mergerfs_2.30.0
+
+OS := $(shell uname -s)
+ifeq ($(OS),Linux)
+UTILS := utils
+INSTALLUTILS := install-utils
+else
+UTILS :=
+INSTALLUTILS :=
+endif
+
+ifeq ($(DEBUG),1)
+OPT_FLAGS := -O0 -g -fsanitize=undefined
+else
+OPT_FLAGS := -O2
+endif
+
+DESTDIR       =
+PREFIX        = /usr/local
+EXEC_PREFIX   = $(PREFIX)
+DATAROOTDIR   = $(PREFIX)/share
+DATADIR       = $(DATAROOTDIR)
+BINDIR        = $(EXEC_PREFIX)/bin
+SBINDIR       = /sbin
+MANDIR        = $(DATAROOTDIR)/man
+MAN1DIR       = $(MANDIR)/man1
+
+INSTALLBINDIR  = $(DESTDIR)$(BINDIR)
+INSTALLSBINDIR = $(DESTDIR)$(SBINDIR)
+INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)
+
+AR ?= ar
+
+SRC   = \
+	lib/buffer.c \
+	lib/crc32b.c \
+	lib/debug.c \
+	lib/fuse.c \
+	lib/fuse_dirents.c \
+	lib/fuse_loop_mt.c \
+	lib/fuse_lowlevel.c \
+	lib/fuse_mt.c \
+	lib/fuse_node.c \
+	lib/fuse_opt.c \
+	lib/fuse_session.c \
+	lib/fuse_signals.c \
+	lib/helper.c \
+	lib/mount.c
+OBJS = $(SRC:lib/%.c=build/%.o)
+DEPS = $(SRC:lib/%.c=build/%.d)
+CFLAGS ?= \
+	$(OPT_FLAGS)
+CFLAGS := \
+	${CFLAGS} \
+	-std=gnu99 \
+	-Wall \
+	-pipe \
+	-MMD
+CXXFLAGS := \
+	${CXXFLAGS} \
+	-std=c++17 \
+	-Wall \
+	-pipe \
+	-MMD
+FUSERMOUNT_DIR = $(BINDIR)
+FUSE_FLAGS = \
+	-Iinclude \
+	-Ibuild \
+	-D_REENTRANT \
+	-D_FILE_OFFSET_BITS=64 \
+	-DFUSE_USE_VERSION=29 \
+	-DPACKAGE_VERSION=\"$(VERSION)\" \
+	-DFUSERMOUNT_DIR=\"$(FUSERMOUNT_DIR)\"
+LDFLAGS := \
+	${LDFLAGS} \
+	-lrt \
+	-pthread
+
+all: build/libfuse.a $(UTILS)
+
+build/config.h: build/stamp
+	ecfd/build | tee build/config.h
+
+build/stamp:
+	mkdir -p build
+	touch $@
+
+objects: build/config.h
+	$(MAKE) $(OBJS)
+
+build/libfuse.a: objects
+	${AR} rcs build/libfuse.a $(OBJS)
+
+utils: mergerfs-fusermount mount.mergerfs
+
+build/mergerfs-fusermount: build/config.h util/fusermount.c lib/mount_util.c
+	$(CC) $(CFLAGS) $(FUSE_FLAGS) -Ilib -o build/mergerfs-fusermount util/fusermount.c lib/mount_util.c
+
+mergerfs-fusermount: build/mergerfs-fusermount
+
+build/mount.mergerfs: build/libfuse.a util/mount.mergerfs.c
+	$(CC) $(CFLAGS) $(FUSE_FLAGS) -o build/mount.mergerfs util/mount.mergerfs.c build/libfuse.a $(LDFLAGS)
+
+mount.mergerfs: build/mount.mergerfs
+
+build/%.o: lib/%.c
+	$(CC) $(CFLAGS) $(FUSE_FLAGS) -c $< -o $@
+
+build/%.o: lib/%.cpp
+	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) -c $< -o $@
+
+clean:
+	rm -rf build
+
+distclean: clean
+
+strip:
+	strip --strip-all build/mount.mergerfs
+	strip --strip-all build/mergerfs-fusermount
+
+install-utils: mergerfs-fusermount mount.mergerfs strip
+	install -D build/mergerfs-fusermount "$(INSTALLBINDIR)/mergerfs-fusermount"
+	install -D build/mount.mergerfs "$(INSTALLSBINDIR)/mount.mergerfs"
+	chown root "$(INSTALLBINDIR)/mergerfs-fusermount"
+	chmod u+s "$(INSTALLBINDIR)/mergerfs-fusermount"
+
+install: $(INSTALLUTILS)
+
+.PHONY: objects strip utils install install-utils
+
+-include $(DEPS)

libfuse/NEWS

@@ -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

libfuse/README.NFS

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

libfuse/README.md

@@ -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.
+

libfuse/ecfd/LICENSE

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

libfuse/ecfd/README.md

@@ -0,0 +1,16 @@
+# ecfd: embeddable C feature discovery
+
+This is a simple script and set of tests to help with what would traditionally be the `configure` step of most C/C++. It is intended to be simple to be embedded into a project and only depends on the C compiler and /bin/sh.
+
+
+## USAGE
+
+First copy `ecfd` into your project. Next simply call the build script which will run the tests and output a `config.` style file to `stdout`. Compile errors will output to `stderr` which can be used to understand why they aren't working.
+
+```
+$ ./ecfd/build > include/config.h
+```
+
+## TESTS
+
+Each test is in a single module. The build script will try to compile each module and on success will execute the program. If anything is printed to `stdout` it will be appended to the `#define` printed to the build script's `stdout`. If the compilation fails nothing will be printed. Look at the tests directory for examples.

libfuse/ecfd/build

@@ -0,0 +1,32 @@
+#!/bin/sh
+
+PWD=$(pwd)
+BASEPATH="${PWD}/${0%/*}"
+
+CC=${CC:-cc}
+OUTPUT="/dev/null"
+
+echo "#ifndef CONFIG_H_INCLUDED"
+echo "#define CONFIG_H_INCLUDED"
+echo
+
+IFS=
+for file in "${BASEPATH}/tests/"*.c
+do
+    binary="${file%.c}"
+    basename=$(basename ${binary})
+
+    ${CC} -o "${binary}" "${file}" 1>&2
+    if [ $? -eq 0 ]; then
+        STDOUT=$(${binary})
+        if [ "${STDOUT}" != "" ]; then
+            echo "#define ${basename} ${STDOUT}"
+        else
+            echo "#define ${basename}"
+        fi
+        rm -f "${binary}"
+    fi
+done
+
+echo
+echo "#endif"

libfuse/ecfd/tests/HAVE_FORK.c

@@ -0,0 +1,10 @@
+#include <sys/types.h>
+#include <unistd.h>
+
+int
+main(void)
+{
+  (void)fork;
+  
+  return 0;
+}

libfuse/ecfd/tests/HAVE_MALLOC_TRIM.c

@@ -0,0 +1,7 @@
+#include <malloc.h>
+
+int
+main()
+{
+  malloc_trim(0);
+}

libfuse/ecfd/tests/HAVE_SPLICE.c

@@ -0,0 +1,11 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+
+int
+main(int   argc,
+     char *argv[])
+{
+  (void)splice;
+
+  return 0;
+}

libfuse/ecfd/tests/HAVE_STRUCT_STAT_ST_ATIM.c

@@ -0,0 +1,14 @@
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+int
+main(int   argc,
+     char *argv[])
+{
+  struct stat st;
+
+  (void)st.st_atim;
+
+  return 0;
+}

libfuse/ecfd/tests/HAVE_UTIMENSAT.c

@@ -0,0 +1,11 @@
+#include <fcntl.h>
+#include <sys/stat.h>
+
+int
+main(int   argc,
+     char *argv[])
+{
+  (void)utimensat;
+
+  return 0;
+}

libfuse/ecfd/tests/HAVE_VMSPLICE.c

@@ -0,0 +1,12 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <sys/uio.h>
+
+int
+main(int   argc,
+     char *argv[])
+{
+  (void)vmsplice;
+
+  return 0;
+}

libfuse/ecfd/tests/static_assert.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#define STATIC_ASSERT(condition) \
+	((void)sizeof(char[1 - 2*!(condition)]))

libfuse/include/extern_c.h

@@ -0,0 +1,9 @@
+#pragma once
+
+#ifdef __cplusplus
+#define EXTERN_C_BEGIN extern "C" {
+#define EXTERN_C_END }
+#else
+#define EXTERN_C_BEGIN
+#define EXTERN_C_END
+#endif

libfuse/include/fuse.h

@@ -0,0 +1,787 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#ifndef _FUSE_H_
+#define _FUSE_H_
+
+/** @file
+ *
+ * This file defines the library interface of FUSE
+ *
+ * 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.
+ */
+
+#ifndef FUSE_USE_VERSION
+#define FUSE_USE_VERSION 21
+#endif
+
+#include "extern_c.h"
+#include "fuse_common.h"
+
+#include <fcntl.h>
+#include <time.h>
+#include <utime.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/statvfs.h>
+#include <sys/uio.h>
+
+EXTERN_C_BEGIN
+
+/* ----------------------------------------------------------- *
+ * Basic FUSE API					       *
+ * ----------------------------------------------------------- */
+
+/** Handle for a FUSE filesystem */
+struct fuse;
+
+/** Structure containing a raw command */
+struct fuse_cmd;
+
+struct fuse_dirents_t;
+typedef struct fuse_dirents_t fuse_dirents_t;
+
+/**
+ * The file system operations:
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * Almost all operations take a path which can be of any length.
+ *
+ * Changed in fuse 2.8.0 (regardless of API version)
+ * Previously, paths were limited to a length of PATH_MAX.
+ *
+ * See http://fuse.sourceforge.net/wiki/ for more information.  There
+ * is also a snapshot of the relevant wiki pages in the doc/ folder.
+ */
+struct fuse_operations
+{
+  /** Get file attributes.
+   *
+   * 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.
+   */
+  int (*getattr) (const char *, struct stat *, fuse_timeouts_t *);
+
+  /** Read the target of a symbolic link
+   *
+   * 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.
+   */
+  int (*readlink) (const char *, char *, size_t);
+
+  /** Create a file node
+   *
+   * This is called for creation of all non-directory, non-symlink
+   * nodes.  If the filesystem defines a create() method, then for
+   * regular files that will be called instead.
+   */
+  int (*mknod) (const char *, mode_t, dev_t);
+
+  /** Create a directory
+   *
+   * 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
+   * */
+  int (*mkdir) (const char *, mode_t);
+
+  /** Hide files unlinked / renamed over
+   *
+   * Allows storing of a file handle when a file is unlinked
+   * while open. Helps manage the fact the kernel usually does
+   * not send fh with getattr requests.
+   */
+  int (*prepare_hide)(const char *name_, uint64_t *fh_);
+  int (*free_hide)(const uint64_t fh_);
+
+  /** Remove a file */
+  int (*unlink) (const char *);
+
+  /** Remove a directory */
+  int (*rmdir) (const char *);
+
+  /** Create a symbolic link */
+  int (*symlink) (const char *, const char *, struct stat *, fuse_timeouts_t *);
+
+  /** Rename a file */
+  int (*rename) (const char *, const char *);
+
+  /** Create a hard link to a file */
+  int (*link) (const char *, const char *, struct stat *, fuse_timeouts_t *);
+
+  /** Change the permission bits of a file */
+  int (*chmod) (const char *, mode_t);
+  int (*fchmod)(const fuse_file_info_t *, const mode_t);
+
+  /** Change the owner and group of a file */
+  int (*chown) (const char *, uid_t, gid_t);
+  int (*fchown)(const fuse_file_info_t *, const uid_t, const gid_t);
+
+  /** Change the size of a file */
+  int (*truncate) (const char *, off_t);
+
+  /** File open operation
+   *
+   * No creation (O_CREAT, O_EXCL) and by default also no
+   * truncation (O_TRUNC) flags will be passed to open(). If an
+   * application specifies O_TRUNC, fuse first calls truncate()
+   * and then open(). Only if 'atomic_o_trunc' has been
+   * specified and kernel version is 2.6.24 or later, O_TRUNC is
+   * passed on to open.
+   *
+   * 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 fuse_file_info structure, which will be
+   * passed to all file operations.
+   *
+   * Changed in version 2.2
+   */
+  int (*open) (const char *, fuse_file_info_t *);
+
+  /** Get file system statistics
+   *
+   * The 'f_frsize', 'f_favail', 'f_fsid' and 'f_flag' fields are ignored
+   *
+   * Replaced 'struct statfs' parameter with 'struct statvfs' in
+   * version 2.5
+   */
+  int (*statfs) (const char *, struct statvfs *);
+
+  /** Possibly flush cached data
+   *
+   * BIG NOTE: This is not equivalent to fsync().  It's not a
+   * request to sync dirty data.
+   *
+   * 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.
+   *
+   * NOTE: The flush() method may be called more than once for each
+   * open().	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.
+   *
+   * Filesystems shouldn't assume that flush will always be called
+   * after some writes, or that if will be called at all.
+   *
+   * Changed in version 2.2
+   */
+  int (*flush) (const fuse_file_info_t *);
+
+  /** Release an open file
+   *
+   * Release is called when there are no more references to an open
+   * file: all file descriptors are closed and all memory mappings
+   * are unmapped.
+   *
+   * For every open() call there will be exactly one release() 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.
+   *
+   * Changed in version 2.2
+   */
+  int (*release) (const fuse_file_info_t *);
+
+  /** Synchronize file contents
+   *
+   * If the datasync parameter is non-zero, then only the user data
+   * should be flushed, not the meta data.
+   *
+   * Changed in version 2.2
+   */
+  int (*fsync) (const fuse_file_info_t *, int);
+
+  /** Set extended attributes */
+  int (*setxattr) (const char *, const char *, const char *, size_t, int);
+
+  /** Get extended attributes */
+  int (*getxattr) (const char *, const char *, char *, size_t);
+
+  /** List extended attributes */
+  int (*listxattr) (const char *, char *, size_t);
+
+  /** Remove extended attributes */
+  int (*removexattr) (const char *, const char *);
+
+  /** Open directory
+   *
+   * 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 fuse_file_info structure, which will be
+   * passed to readdir, closedir and fsyncdir.
+   *
+   * Introduced in version 2.3
+   */
+  int (*opendir) (const char *,
+                  fuse_file_info_t *);
+
+  /** Read directory
+   *
+   * This supersedes the old getdir() interface.  New applications
+   * should use this.
+   *
+   * The filesystem may choose between two modes of operation:
+   *
+   * 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.
+   *
+   * 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'.
+   *
+   * Introduced in version 2.3
+   */
+  int (*readdir)(const fuse_file_info_t *,
+                 fuse_dirents_t *);
+
+  int (*readdir_plus)(const fuse_file_info_t *,
+                      fuse_dirents_t *);
+
+
+  /** Release directory
+   *
+   * Introduced in version 2.3
+   */
+  int (*releasedir) (const fuse_file_info_t *);
+
+  /** Synchronize directory contents
+   *
+   * If the datasync parameter is non-zero, then only the user data
+   * should be flushed, not the meta data
+   *
+   * Introduced in version 2.3
+   */
+  int (*fsyncdir) (const fuse_file_info_t *, int);
+
+  /**
+   * Initialize filesystem
+   *
+   * The return value will passed in the private_data field of
+   * fuse_context to all file operations and as a parameter to the
+   * destroy() method.
+   *
+   * Introduced in version 2.3
+   * Changed in version 2.6
+   */
+  void *(*init) (struct fuse_conn_info *conn);
+
+  /**
+   * Clean up filesystem
+   *
+   * Called on filesystem exit.
+   *
+   * Introduced in version 2.3
+   */
+  void (*destroy) (void);
+
+  /**
+   * Check file access permissions
+   *
+   * This will be called for the access() system call.  If the
+   * 'default_permissions' mount option is given, this method is not
+   * called.
+   *
+   * This method is not called under Linux kernel versions 2.4.x
+   *
+   * Introduced in version 2.5
+   */
+  int (*access) (const char *, int);
+
+  /**
+   * Create and open a file
+   *
+   * If the file does not exist, first create it with the specified
+   * mode, and then open it.
+   *
+   * If this method is not implemented or under Linux kernel
+   * versions earlier than 2.6.15, the mknod() and open() methods
+   * will be called instead.
+   *
+   * Introduced in version 2.5
+   */
+  int (*create) (const char *, mode_t, fuse_file_info_t *);
+
+  /**
+   * Change the size of an open file
+   *
+   * This method is called instead of the truncate() method if the
+   * truncation was invoked from an ftruncate() system call.
+   *
+   * If this method is not implemented or under Linux kernel
+   * versions earlier than 2.6.15, the truncate() method will be
+   * called instead.
+   *
+   * Introduced in version 2.5
+   */
+  int (*ftruncate) (const fuse_file_info_t *, off_t);
+
+  /**
+   * Get attributes from an open file
+   *
+   * This method is called instead of the getattr() method if the
+   * file information is available.
+   *
+   * Currently this is only called after the create() method if that
+   * is implemented (see above).  Later it may be called for
+   * invocations of fstat() too.
+   *
+   * Introduced in version 2.5
+   */
+  int (*fgetattr) (const fuse_file_info_t *, struct stat *, fuse_timeouts_t *);
+
+  /**
+   * Perform POSIX file locking operation
+   *
+   * The cmd argument will be either F_GETLK, F_SETLK or F_SETLKW.
+   *
+   * 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.
+   *
+   * For checking lock ownership, the 'fuse_file_info->owner'
+   * argument must be used.
+   *
+   * 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.
+   *
+   * For F_SETLK and F_SETLKW the l_pid field will be set to the pid
+   * of the process performing the locking operation.
+   *
+   * 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.
+   *
+   * Introduced in version 2.6
+   */
+  int (*lock) (const fuse_file_info_t *,
+               int cmd,
+               struct flock *);
+
+  /**
+   * Change the access and modification times of a file with
+   * nanosecond resolution
+   *
+   * This supersedes the old utime() interface.  New applications
+   * should use this.
+   *
+   * See the utimensat(2) man page for details.
+   *
+   * Introduced in version 2.6
+   */
+  int (*utimens)(const char *, const struct timespec tv[2]);
+  int (*futimens)(const fuse_file_info_t *ffi_, const struct timespec tv_[2]);
+
+  /**
+   * Map block index within file to block index within device
+   *
+   * Note: This makes sense only for block device backed filesystems
+   * mounted with the 'blkdev' option
+   *
+   * Introduced in version 2.6
+   */
+  int (*bmap) (const char *, size_t blocksize, uint64_t *idx);
+
+  /**
+   * Ioctl
+   *
+   * flags will have FUSE_IOCTL_COMPAT set for 32bit ioctls in
+   * 64bit environment.  The size and direction of data is
+   * determined by _IOC_*() 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.
+   *
+   * If flags has FUSE_IOCTL_DIR then the fuse_file_info refers to a
+   * directory file handle.
+   *
+   * Introduced in version 2.8
+   */
+  int (*ioctl) (const fuse_file_info_t *ffi,
+                unsigned long           cmd,
+                void                   *arg,
+                unsigned int            flags,
+                void                   *data,
+                uint32_t               *out_bufsz);
+
+  /**
+   * Poll for IO readiness events
+   *
+   * Note: If ph is non-NULL, the client should notify
+   * when IO readiness events occur by calling
+   * fuse_notify_poll() with the specified ph.
+   *
+   * 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.
+   *
+   * The callee is responsible for destroying ph with
+   * fuse_pollhandle_destroy() when no longer in use.
+   *
+   * Introduced in version 2.8
+   */
+  int (*poll) (const fuse_file_info_t *ffi,
+               fuse_pollhandle_t      *ph,
+               unsigned               *reventsp);
+
+  /** Write contents of buffer to an open file
+   *
+   * Similar to the write() method, but data is supplied in a
+   * generic buffer.  Use fuse_buf_copy() to transfer data to
+   * the destination.
+   *
+   * Introduced in version 2.9
+   */
+  int (*write) (const fuse_file_info_t *ffi,
+                const char             *data,
+                size_t                  size,
+                off_t                   off);
+
+  /** Store data from an open file in a buffer
+   *
+   * Similar to the read() method, but data is stored and
+   * returned in a generic buffer.
+   *
+   * No actual copying of data has to take place, the source
+   * file descriptor may simply be stored in the buffer for
+   * later data transfer.
+   *
+   * 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.
+   *
+   * Introduced in version 2.9
+   */
+  int (*read_buf) (const fuse_file_info_t  *ffi,
+                   struct fuse_bufvec     **bufp,
+                   size_t                   size,
+                   off_t                    off);
+  /**
+   * Perform BSD file locking operation
+   *
+   * The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN
+   *
+   * Nonblocking requests will be indicated by ORing LOCK_NB to
+   * the above operations
+   *
+   * For more information see the flock(2) manual page.
+   *
+   * Additionally fi->owner will be set to a value unique to
+   * this open file.  This same value will be supplied to
+   * ->release() when the file is released.
+   *
+   * 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.
+   *
+   * Introduced in version 2.9
+   */
+  int (*flock) (const fuse_file_info_t *, int op);
+
+  /**
+   * Allocates space for an open file
+   *
+   * 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.
+   *
+   * Introduced in version 2.9.1
+   */
+  int (*fallocate) (const fuse_file_info_t *, int, off_t, off_t);
+
+  /**
+   * Copy a range of data from one file to another
+   *
+   * Performs an optimized copy between two file descriptors without
+   * the additional cost of transferring data through the FUSE kernel
+   * module to user space (glibc) and then back into the FUSE filesystem
+   * again.
+   *
+   * In case this method is not implemented, glibc falls back to
+   * reading data from the source and writing to the
+   * destination. Effectively doing an inefficient copy of the
+   * data.
+   */
+  ssize_t (*copy_file_range)(const fuse_file_info_t *fi_in,
+                             off_t                   offset_in,
+                             const fuse_file_info_t *fi_out,
+                             off_t                   offset_out,
+                             size_t                  size,
+                             int                     flags);
+};
+
+/** Extra context that may be needed by some filesystems
+ *
+ * The uid, gid and pid fields are not filled in case of a writepage
+ * operation.
+ */
+struct fuse_context
+{
+  /** Pointer to the fuse object */
+  struct fuse *fuse;
+
+  /** User ID of the calling process */
+  uid_t uid;
+
+  /** Group ID of the calling process */
+  gid_t gid;
+
+  /** Thread ID of the calling process */
+  pid_t pid;
+
+  /** Umask of the calling process (introduced in version 2.8) */
+  mode_t umask;
+};
+
+/**
+ * Main function of FUSE.
+ *
+ * This is for the lazy.  This is all that has to be called from the
+ * main() function.
+ *
+ * This function does the following:
+ *   - parses command line options (-d -s and -h)
+ *   - passes relevant mount options to the fuse_mount()
+ *   - installs signal handlers for INT, HUP, TERM and PIPE
+ *   - registers an exit handler to unmount the filesystem on program exit
+ *   - creates a fuse handle
+ *   - registers the operations
+ *   - calls either the single-threaded or the multi-threaded event loop
+ *
+ * Note: this is currently implemented as a macro.
+ *
+ * @param argc the argument counter passed to the main() function
+ * @param argv the argument vector passed to the main() function
+ * @param op the file system operation
+ * @return 0 on success, nonzero on failure
+ */
+/*
+  int fuse_main(int argc, char *argv[], const struct fuse_operations *op);
+*/
+#define fuse_main(argc, argv, op)                    \
+  fuse_main_real(argc, argv, op, sizeof(*(op)))
+
+/* ----------------------------------------------------------- *
+ * More detailed API					       *
+ * ----------------------------------------------------------- */
+
+/**
+ * Create a new FUSE filesystem.
+ *
+ * @param ch the communication channel
+ * @param args argument vector
+ * @param op the filesystem operations
+ * @param op_size the size of the fuse_operations structure
+ * @return the created FUSE handle
+ */
+struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
+                      const struct fuse_operations *op, size_t op_size);
+
+/**
+ * Destroy the FUSE handle.
+ *
+ * The communication channel attached to the handle is also destroyed.
+ *
+ * NOTE: This function does not unmount the filesystem.	 If this is
+ * needed, call fuse_unmount() before calling this function.
+ *
+ * @param f the FUSE handle
+ */
+void fuse_destroy(struct fuse *f);
+
+/**
+ * Exit from event loop
+ *
+ * @param f the FUSE handle
+ */
+void fuse_exit(struct fuse *f);
+
+int fuse_config_num_threads(const struct fuse *fuse_);
+
+/**
+ * FUSE event loop with multiple threads
+ *
+ * Requests from the kernel are processed, and the appropriate
+ * operations are called.  Request are processed in parallel by
+ * distributing them between multiple threads.
+ *
+ * Calling this function requires the pthreads library to be linked to
+ * the application.
+ *
+ * @param f the FUSE handle
+ * @return 0 if no error occurred, -1 otherwise
+ */
+int fuse_loop_mt(struct fuse *f);
+
+/**
+ * Get the current context
+ *
+ * The context is only valid for the duration of a filesystem
+ * operation, and thus must not be stored and used later.
+ *
+ * @return the context
+ */
+struct fuse_context *fuse_get_context(void);
+
+/**
+ * Check if the current request has already been interrupted
+ *
+ * @return 1 if the request has been interrupted, 0 otherwise
+ */
+int fuse_interrupted(void);
+
+/**
+ * Obsolete, doesn't do anything
+ *
+ * @return -EINVAL
+ */
+int fuse_invalidate(struct fuse *f, const char *path);
+
+/* Deprecated, don't use */
+int fuse_is_lib_option(const char *opt);
+
+/**
+ * The real main function
+ *
+ * Do not call this directly, use fuse_main()
+ */
+int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op, size_t op_size);
+
+int  fuse_start_maintenance_thread(struct fuse *fuse);
+void fuse_stop_maintenance_thread(struct fuse *fuse);
+
+int  fuse_log_metrics_get(void);
+void fuse_log_metrics_set(int enabled);
+
+
+/**
+ * Iterate over cache removing stale entries
+ * use in conjunction with "-oremember"
+ *
+ * NOTE: This is already done for the standard sessions
+ *
+ * @param fuse struct fuse pointer for fuse instance
+ * @return the number of seconds until the next cleanup
+ */
+int fuse_clean_cache(struct fuse *fuse);
+
+/*
+ * Stacking API
+ */
+
+/**
+ * Fuse filesystem object
+ *
+ * This is opaque object represents a filesystem layer
+ */
+struct fuse_fs;
+
+/*
+ * These functions call the relevant filesystem operation, and return
+ * the result.
+ *
+ * If the operation is not defined, they return -ENOSYS, with the
+ * exception of fuse_fs_open, fuse_fs_release, fuse_fs_opendir,
+ * fuse_fs_releasedir and fuse_fs_statfs, which return 0.
+ */
+
+int fuse_notify_poll(fuse_pollhandle_t *ph);
+
+/**
+ * Create a new fuse filesystem object
+ *
+ * This is usually called from the factory of a fuse module to create
+ * a new instance of a filesystem.
+ *
+ * @param op the filesystem operations
+ * @param op_size the size of the fuse_operations structure
+ * @return a new filesystem object
+ */
+struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size);
+
+/* ----------------------------------------------------------- *
+ * Advanced API for event handling, don't worry about this...  *
+ * ----------------------------------------------------------- */
+
+/* NOTE: the following functions are deprecated, and will be removed
+   from the 3.0 API.  Use the lowlevel session functions instead */
+
+/** Function type used to process commands */
+typedef void (*fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *);
+
+/** This is the part of fuse_main() before the event loop */
+struct fuse *fuse_setup(int argc, char *argv[],
+                        const struct fuse_operations *op, size_t op_size,
+                        char **mountpoint);
+
+/** This is the part of fuse_main() after the event loop */
+void fuse_teardown(struct fuse *fuse, char *mountpoint);
+
+/** Read a single command.  If none are read, return NULL */
+struct fuse_cmd *fuse_read_cmd(struct fuse *f);
+
+/** Process a single command */
+void fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd);
+
+/** Multi threaded event loop, which calls the custom command
+    processor function */
+int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data);
+
+/** Return the exited flag, which indicates if fuse_exit() has been
+    called */
+int fuse_exited(struct fuse *f);
+
+/** This function is obsolete and implemented as a no-op */
+void fuse_set_getcontext_func(struct fuse_context *(*func)(void));
+
+/** Get session from fuse object */
+struct fuse_session *fuse_get_session(struct fuse *f);
+
+EXTERN_C_END
+
+#endif /* _FUSE_H_ */

libfuse/include/fuse_attr.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef struct fuse_attr_s fuse_attr_t;
+struct fuse_attr_s
+{
+  uint64_t ino;
+  uint64_t size;
+  uint64_t blocks;
+  uint64_t atime;
+  uint64_t mtime;
+  uint64_t ctime;
+  uint32_t atimensec;
+  uint32_t mtimensec;
+  uint32_t ctimensec;
+  uint32_t mode;
+  uint32_t nlink;
+  uint32_t uid;
+  uint32_t gid;
+  uint32_t rdev;
+  uint32_t blksize;
+  uint32_t _padding;
+};

libfuse/include/fuse_common.h

@@ -0,0 +1,484 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+/** @file */
+
+#if !defined(_FUSE_H_) && !defined(_FUSE_LOWLEVEL_H_)
+#error "Never include <fuse_common.h> directly; use <fuse.h> or <fuse_lowlevel.h> instead."
+#endif
+
+#ifndef _FUSE_COMMON_H_
+#define _FUSE_COMMON_H_
+
+#include "extern_c.h"
+#include "fuse_opt.h"
+#include "fuse_timeouts.h"
+
+#include <stdint.h>
+#include <sys/types.h>
+
+/** Major version of FUSE library interface */
+#define FUSE_MAJOR_VERSION 2
+
+/** Minor version of FUSE library interface */
+#define FUSE_MINOR_VERSION 9
+
+#define FUSE_MAKE_VERSION(maj, min)  ((maj) * 10 + (min))
+#define FUSE_VERSION FUSE_MAKE_VERSION(FUSE_MAJOR_VERSION, FUSE_MINOR_VERSION)
+
+/* This interface uses 64 bit off_t */
+#if _FILE_OFFSET_BITS != 64
+#error Please add -D_FILE_OFFSET_BITS=64 to your compile flags!
+#endif
+
+#define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
+#define FUSE_MAX_MAX_PAGES 256
+
+EXTERN_C_BEGIN
+
+/**
+ * Information about open files
+ *
+ * Changed in version 2.5
+ */
+typedef struct fuse_file_info_t fuse_file_info_t;
+struct fuse_file_info_t
+{
+  /** Open flags. Available in open() and release() */
+  int flags;
+
+  /** In case of a write operation indicates if this was caused by a
+      writepage */
+  uint32_t writepage : 1;
+
+  /** Can be filled in by open, to use direct I/O on this file.
+      Introduced in version 2.4 */
+  uint32_t direct_io : 1;
+
+  /** Can be filled in by open, to indicate, that cached file data
+      need not be invalidated.  Introduced in version 2.4 */
+  uint32_t keep_cache : 1;
+
+  /** Indicates a flush operation.  Set in flush operation, also
+      maybe set in highlevel lock operation and lowlevel release
+      operation.	Introduced in version 2.6 */
+  uint32_t flush : 1;
+
+  /** Can be filled in by open, to indicate that the file is not
+      seekable.  Introduced in version 2.8 */
+  uint32_t nonseekable : 1;
+
+  /* Indicates that flock locks for this file should be
+     released.  If set, lock_owner shall contain a valid value.
+     May only be set in ->release().  Introduced in version
+     2.9 */
+  uint32_t flock_release : 1;
+
+  /* Requests the kernel to cache entries returned by readdir */
+  uint32_t cache_readdir : 1;
+
+  uint32_t auto_cache : 1;
+
+  /** File handle.  May be filled in by filesystem in open().
+      Available in all other file operations */
+  uint64_t fh;
+
+  /** Lock owner id.  Available in locking operations and flush */
+  uint64_t lock_owner;
+};
+
+/**
+ * Capability bits for 'fuse_conn_info.capable' and 'fuse_conn_info.want'
+ *
+ * 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
+ * FUSE_CAP_CACHE_SYMLINKS: cache READLINK responses
+ */
+#define FUSE_CAP_ASYNC_READ        (1 << 0)
+#define FUSE_CAP_POSIX_LOCKS       (1 << 1)
+#define FUSE_CAP_ATOMIC_O_TRUNC    (1 << 3)
+#define FUSE_CAP_EXPORT_SUPPORT    (1 << 4)
+#define FUSE_CAP_BIG_WRITES        (1 << 5)
+#define FUSE_CAP_DONT_MASK         (1 << 6)
+#define FUSE_CAP_SPLICE_WRITE      (1 << 7)
+#define FUSE_CAP_SPLICE_MOVE       (1 << 8)
+#define FUSE_CAP_SPLICE_READ       (1 << 9)
+#define FUSE_CAP_FLOCK_LOCKS       (1 << 10)
+#define FUSE_CAP_IOCTL_DIR         (1 << 11)
+#define FUSE_CAP_READDIR_PLUS      (1 << 13)
+#define FUSE_CAP_READDIR_PLUS_AUTO (1 << 14)
+#define FUSE_CAP_ASYNC_DIO         (1 << 15)
+#define FUSE_CAP_WRITEBACK_CACHE   (1 << 16)
+#define FUSE_CAP_PARALLEL_DIROPS   (1 << 18)
+#define FUSE_CAP_POSIX_ACL         (1 << 19)
+#define FUSE_CAP_CACHE_SYMLINKS    (1 << 20)
+#define FUSE_CAP_MAX_PAGES         (1 << 21)
+
+/**
+ * Ioctl flags
+ *
+ * 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
+ *
+ * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
+ */
+#define FUSE_IOCTL_COMPAT	(1 << 0)
+#define FUSE_IOCTL_UNRESTRICTED	(1 << 1)
+#define FUSE_IOCTL_RETRY	(1 << 2)
+#define FUSE_IOCTL_DIR		(1 << 4)
+
+#define FUSE_IOCTL_MAX_IOV	256
+
+/**
+ * Connection information, passed to the ->init() method
+ *
+ * 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.
+ */
+struct fuse_conn_info {
+  /**
+   * Major version of the protocol (read-only)
+   */
+  unsigned proto_major;
+
+  /**
+   * Minor version of the protocol (read-only)
+   */
+  unsigned proto_minor;
+
+  /**
+   * Maximum size of the write buffer
+   */
+  unsigned max_write;
+
+  /**
+   * Maximum readahead
+   */
+  unsigned max_readahead;
+
+  /**
+   * Capability flags, that the kernel supports
+   */
+  unsigned capable;
+
+  /**
+   * Capability flags, that the filesystem wants to enable
+   */
+  unsigned want;
+
+  /**
+   * Maximum number of backgrounded requests
+   */
+  unsigned max_background;
+
+  /**
+   * Kernel congestion threshold parameter
+   */
+  unsigned congestion_threshold;
+
+  /**
+   * Max pages
+   */
+  uint16_t max_pages;
+
+  /**
+   * For future use.
+   */
+  unsigned reserved[22];
+};
+
+struct fuse_session;
+struct fuse_chan;
+struct fuse_pollhandle_t;
+typedef struct fuse_pollhandle_t fuse_pollhandle_t;
+
+/**
+ * Create a FUSE mountpoint
+ *
+ * Returns a control file descriptor suitable for passing to
+ * fuse_new()
+ *
+ * @param mountpoint the mount point path
+ * @param args argument vector
+ * @return the communication channel on success, NULL on failure
+ */
+struct fuse_chan *fuse_mount(const char       *mountpoint,
+                             struct fuse_args *args);
+
+/**
+ * Umount a FUSE mountpoint
+ *
+ * @param mountpoint the mount point path
+ * @param ch the communication channel
+ */
+void fuse_unmount(const char *mountpoint, struct fuse_chan *ch);
+
+/**
+ * Parse common options
+ *
+ * The following options are parsed:
+ *
+ *   '-f'	     foreground
+ *   '-d' '-odebug'  foreground, but keep the debug option
+ *   '-h' '--help'   help
+ *   '-ho'	     help without header
+ *   '-ofsname=..'   file system name, if not present, then set to the program
+ *		     name
+ *
+ * All parameters may be NULL
+ *
+ * @param args argument vector
+ * @param mountpoint the returned mountpoint, should be freed after use
+ * @param foreground set to 1 if one of the relevant options is present
+ * @return 0 on success, -1 on failure
+ */
+int fuse_parse_cmdline(struct fuse_args  *args,
+                       char             **mountpoint,
+                       int               *foreground);
+
+/**
+ * Go into the background
+ *
+ * @param foreground if true, stay in the foreground
+ * @return 0 on success, -1 on failure
+ */
+int fuse_daemonize(int foreground);
+
+/**
+ * Get the version of the library
+ *
+ * @return the version
+ */
+int fuse_version(void);
+
+/**
+ * Destroy poll handle
+ *
+ * @param ph the poll handle
+ */
+void fuse_pollhandle_destroy(fuse_pollhandle_t *ph);
+
+/* ----------------------------------------------------------- *
+ * Data buffer						       *
+ * ----------------------------------------------------------- */
+
+/**
+ * Buffer flags
+ */
+enum fuse_buf_flags {
+  /**
+   * Buffer contains a file descriptor
+   *
+   * If this flag is set, the .fd field is valid, otherwise the
+   * .mem fields is valid.
+   */
+  FUSE_BUF_IS_FD		= (1 << 1),
+
+  /**
+   * Seek on the file descriptor
+   *
+   * 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.
+   */
+  FUSE_BUF_FD_SEEK	= (1 << 2),
+
+  /**
+   * Retry operation on file descriptor
+   *
+   * If this flag is set then retry operation on file descriptor
+   * until .size bytes have been copied or an error or EOF is
+   * detected.
+   */
+  FUSE_BUF_FD_RETRY	= (1 << 3),
+};
+
+/**
+ * Buffer copy flags
+ */
+enum fuse_buf_copy_flags {
+  /**
+   * Don't use splice(2)
+   *
+   * Always fall back to using read and write instead of
+   * splice(2) to copy data from one file descriptor to another.
+   *
+   * If this flag is not set, then only fall back if splice is
+   * unavailable.
+   */
+  FUSE_BUF_NO_SPLICE	= (1 << 1),
+
+  /**
+   * Force splice
+   *
+   * Always use splice(2) to copy data from one file descriptor
+   * to another.  If splice is not available, return -EINVAL.
+   */
+  FUSE_BUF_FORCE_SPLICE	= (1 << 2),
+
+  /**
+   * Try to move data with splice.
+   *
+   * 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.
+   */
+  FUSE_BUF_SPLICE_MOVE	= (1 << 3),
+
+  /**
+   * Don't block on the pipe when copying data with splice
+   *
+   * 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.
+   */
+  FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
+};
+
+/**
+ * Single data buffer
+ *
+ * Generic data buffer for I/O, extended attributes, etc...  Data may
+ * be supplied as a memory pointer or as a file descriptor
+ */
+struct fuse_buf {
+  /**
+   * Size of data in bytes
+   */
+  size_t size;
+
+  /**
+   * Buffer flags
+   */
+  enum fuse_buf_flags flags;
+
+  /**
+   * Memory pointer
+   *
+   * Used unless FUSE_BUF_IS_FD flag is set.
+   */
+  void *mem;
+
+  /**
+   * File descriptor
+   *
+   * Used if FUSE_BUF_IS_FD flag is set.
+   */
+  int fd;
+
+  /**
+   * File position
+   *
+   * Used if FUSE_BUF_FD_SEEK flag is set.
+   */
+  off_t pos;
+};
+
+/**
+ * Data buffer vector
+ *
+ * An array of data buffers, each containing a memory pointer or a
+ * file descriptor.
+ *
+ * Allocate dynamically to add more than one buffer.
+ */
+struct fuse_bufvec {
+  /**
+   * Number of buffers in the array
+   */
+  size_t count;
+
+  /**
+   * Index of current buffer within the array
+   */
+  size_t idx;
+
+  /**
+   * Current offset within the current buffer
+   */
+  size_t off;
+
+  /**
+   * Array of buffers
+   */
+  struct fuse_buf buf[1];
+};
+
+/* Initialize bufvec with a single buffer of given size */
+#define FUSE_BUFVEC_INIT(size__)                        \
+  ((struct fuse_bufvec) {                               \
+    /* .count= */ 1,                                    \
+      /* .idx =  */ 0,                                  \
+      /* .off =  */ 0,                                  \
+      /* .buf =  */ { /* [0] = */ {			\
+        /* .size =  */ (size__),                        \
+          /* .flags = */ (enum fuse_buf_flags) 0,	\
+          /* .mem =   */ NULL,                          \
+          /* .fd =    */ -1,                            \
+          /* .pos =   */ 0,                             \
+          } }						\
+  } )
+
+/**
+ * Get total size of data in a fuse buffer vector
+ *
+ * @param bufv buffer vector
+ * @return size of data
+ */
+size_t fuse_buf_size(const struct fuse_bufvec *bufv);
+
+/**
+ * Copy data from one buffer vector to another
+ *
+ * @param dst destination buffer vector
+ * @param src source buffer vector
+ * @param flags flags controlling the copy
+ * @return actual number of bytes copied or -errno on error
+ */
+ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
+                      enum fuse_buf_copy_flags flags);
+
+/* ----------------------------------------------------------- *
+ * Signal handling					       *
+ * ----------------------------------------------------------- */
+
+/**
+ * Exit session on HUP, TERM and INT signals and ignore PIPE signal
+ *
+ * Stores session in a global variable.	 May only be called once per
+ * process until fuse_remove_signal_handlers() is called.
+ *
+ * @param se the session to exit
+ * @return 0 on success, -1 on failure
+ */
+int fuse_set_signal_handlers(struct fuse_session *se);
+
+/**
+ * Restore default signal handlers
+ *
+ * Resets global session.  After this fuse_set_signal_handlers() may
+ * be called again.
+ *
+ * @param se the same session as given in fuse_set_signal_handlers()
+ */
+void fuse_remove_signal_handlers(struct fuse_session *se);
+
+EXTERN_C_END
+
+#endif /* _FUSE_COMMON_H_ */

libfuse/include/fuse_dirent.h

@@ -0,0 +1,31 @@
+/*
+  ISC License
+
+  Copyright (c) 2019, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include <stdint.h>
+
+typedef struct fuse_dirent_s fuse_dirent_t;
+struct fuse_dirent_s
+{
+  uint64_t ino;
+  uint64_t off;
+  uint32_t namelen;
+  uint32_t type;
+  char     name[];
+};

libfuse/include/fuse_direntplus.h

@@ -0,0 +1,31 @@
+/*
+  ISC License
+
+  Copyright (c) 2019, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "fuse_attr.h"
+#include "fuse_dirent.h"
+#include "fuse_entry.h"
+
+typedef struct fuse_direntplus_s fuse_direntplus_t;
+struct fuse_direntplus_s
+{
+  fuse_entry_t  entry;
+  fuse_attr_t   attr;
+  fuse_dirent_t dirent;
+};

libfuse/include/fuse_dirents.h

@@ -0,0 +1,80 @@
+/*
+  ISC License
+
+  Copyright (c) 2019, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "extern_c.h"
+
+EXTERN_C_BEGIN
+
+#include "kvec.h"
+#include "fuse_dirent.h"
+#include "fuse_direntplus.h"
+#include "fuse_entry.h"
+#include "linux_dirent64.h"
+
+#include <dirent.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+enum fuse_dirents_type_e
+{
+  UNSET = 0,
+  NORMAL,
+  PLUS
+};
+typedef enum fuse_dirents_type_e fuse_dirents_type_t;
+
+typedef struct fuse_dirents_t fuse_dirents_t;
+struct fuse_dirents_t
+{
+  kvec_t(char)        data;
+  kvec_t(uint32_t)    offs;
+  fuse_dirents_type_t type;
+};
+
+int  fuse_dirents_init(fuse_dirents_t *d);
+void fuse_dirents_free(fuse_dirents_t *d);
+void fuse_dirents_reset(fuse_dirents_t *d);
+
+int  fuse_dirents_add(fuse_dirents_t      *d,
+                      const struct dirent *de,
+                      const uint64_t       namelen);
+int  fuse_dirents_add_plus(fuse_dirents_t      *d,
+                           const struct dirent *de,
+                           const uint64_t       namelen,
+                           const fuse_entry_t  *entry,
+                           const struct stat   *st);
+int  fuse_dirents_add_linux(fuse_dirents_t              *d,
+                            const struct linux_dirent64 *de,
+                            const uint64_t               namelen);
+int  fuse_dirents_add_linux_plus(fuse_dirents_t              *d,
+                                 const struct linux_dirent64 *de,
+                                 const uint64_t               namelen,
+                                 const fuse_entry_t          *entry,
+                                 const struct stat           *st);
+
+void *fuse_dirents_find(fuse_dirents_t *d,
+                        const uint64_t  ino);
+
+int fuse_dirents_convert_plus2normal(fuse_dirents_t *d);
+
+EXTERN_C_END

libfuse/include/fuse_entry.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef struct fuse_entry_s fuse_entry_t;
+struct fuse_entry_s
+{
+  uint64_t nodeid;
+  uint64_t generation;
+  uint64_t entry_valid;
+  uint64_t attr_valid;
+  uint32_t entry_valid_nsec;
+  uint32_t attr_valid_nsec;
+};

libfuse/include/fuse_opt.h

@@ -0,0 +1,270 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#ifndef _FUSE_OPT_H_
+#define _FUSE_OPT_H_
+
+#include "extern_c.h"
+
+/** @file
+ *
+ * This file defines the option parsing interface of FUSE
+ */
+
+EXTERN_C_BEGIN
+
+/**
+ * Option description
+ *
+ * This structure describes a single option, and action associated
+ * with it, in case it matches.
+ *
+ * More than one such match may occur, in which case the action for
+ * each match is executed.
+ *
+ * There are three possible actions in case of a match:
+ *
+ * i) An integer (int or unsigned) variable determined by 'offset' is
+ *    set to 'value'
+ *
+ * ii) The processing function is called, with 'value' as the key
+ *
+ * iii) An integer (any) or string (char *) variable determined by
+ *    'offset' is set to the value of an option parameter
+ *
+ * 'offset' should normally be either set to
+ *
+ *  - 'offsetof(struct foo, member)'  actions i) and iii)
+ *
+ *  - -1			      action ii)
+ *
+ * The 'offsetof()' macro is defined in the <stddef.h> header.
+ *
+ * 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.
+ *
+ * The types of templates are:
+ *
+ * 1) "-x", "-foo", "--foo", "--foo-bar", etc.	These match only
+ *   themselves.  Invalid values are "--" and anything beginning
+ *   with "-o"
+ *
+ * 2) "foo", "foo-bar", etc.  These match "-ofoo", "-ofoo-bar" or
+ *    the relevant option in a comma separated option list
+ *
+ * 3) "bar=", "--foo=", etc.  These are variations of 1) and 2)
+ *    which have a parameter
+ *
+ * 4) "bar=%s", "--foo=%lu", etc.  Same matching as above but perform
+ *    action iii).
+ *
+ * 5) "-x ", etc.  Matches either "-xparam" or "-x param" as
+ *    two separate arguments
+ *
+ * 6) "-x %s", etc.  Combination of 4) and 5)
+ *
+ * If the format is "%s", memory is allocated for the string unlike
+ * with scanf().
+ */
+struct fuse_opt
+{
+  /** Matching template and optional parameter formatting */
+  const char *templ;
+
+  /**
+   * Offset of variable within 'data' parameter of fuse_opt_parse()
+   * or -1
+   */
+  unsigned long offset;
+
+  /**
+   * Value to set the variable to, or to be passed as 'key' to the
+   * processing function.	 Ignored if template has a format
+   */
+  int value;
+};
+
+/**
+ * Key option.	In case of a match, the processing function will be
+ * called with the specified key.
+ */
+#define FUSE_OPT_KEY(templ, key) { templ, -1U, key }
+
+/**
+ * Last option.	 An array of 'struct fuse_opt' must end with a NULL
+ * template value
+ */
+#define FUSE_OPT_END { NULL, 0, 0 }
+
+/**
+ * Argument list
+ */
+struct fuse_args
+{
+  /** Argument count */
+  int argc;
+
+  /** Argument vector.  NULL terminated */
+  char **argv;
+
+  /** Is 'argv' allocated? */
+  int allocated;
+};
+
+/**
+ * Initializer for 'struct fuse_args'
+ */
+#define FUSE_ARGS_INIT(argc, argv) { argc, argv, 0 }
+
+/**
+ * Key value passed to the processing function if an option did not
+ * match any template
+ */
+#define FUSE_OPT_KEY_OPT     -1
+
+/**
+ * Key value passed to the processing function for all non-options
+ *
+ * Non-options are the arguments beginning with a character other than
+ * '-' or all arguments after the special '--' option
+ */
+#define FUSE_OPT_KEY_NONOPT  -2
+
+/**
+ * Special key value for options to keep
+ *
+ * Argument is not passed to processing function, but behave as if the
+ * processing function returned 1
+ */
+#define FUSE_OPT_KEY_KEEP -3
+
+/**
+ * Special key value for options to discard
+ *
+ * Argument is not passed to processing function, but behave as if the
+ * processing function returned zero
+ */
+#define FUSE_OPT_KEY_DISCARD -4
+
+/**
+ * Processing function
+ *
+ * This function is called if
+ *    - option did not match any 'struct fuse_opt'
+ *    - argument is a non-option
+ *    - option did match and offset was set to -1
+ *
+ * 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.
+ *
+ * Options of the form '-ofoo' are passed to this function without the
+ * '-o' prefix.
+ *
+ * The return value of this function determines whether this argument
+ * is to be inserted into the output argument vector, or discarded.
+ *
+ * @param data is the user data passed to the fuse_opt_parse() function
+ * @param arg is the whole argument or option
+ * @param key determines why the processing function was called
+ * @param outargs the current output argument list
+ * @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept
+ */
+typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
+                               struct fuse_args *outargs);
+
+/**
+ * Option parsing function
+ *
+ * If 'args' was returned from a previous call to fuse_opt_parse() or
+ * it was constructed from
+ *
+ * A NULL 'args' is equivalent to an empty argument vector
+ *
+ * A NULL 'opts' is equivalent to an 'opts' array containing a single
+ * end marker
+ *
+ * A NULL 'proc' is equivalent to a processing function always
+ * returning '1'
+ *
+ * @param args is the input and output argument list
+ * @param data is the user data
+ * @param opts is the option description array
+ * @param proc is the processing function
+ * @return -1 on error, 0 on success
+ */
+int fuse_opt_parse(struct fuse_args *args, void *data,
+                   const struct fuse_opt opts[], fuse_opt_proc_t proc);
+
+/**
+ * Add an option to a comma separated option list
+ *
+ * @param opts is a pointer to an option list, may point to a NULL value
+ * @param opt is the option to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_opt(char **opts, const char *opt);
+
+/**
+ * Add an option, escaping commas, to a comma separated option list
+ *
+ * @param opts is a pointer to an option list, may point to a NULL value
+ * @param opt is the option to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_opt_escaped(char **opts, const char *opt);
+
+/**
+ * Add an argument to a NULL terminated argument vector
+ *
+ * @param args is the structure containing the current argument list
+ * @param arg is the new argument to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_add_arg(struct fuse_args *args, const char *arg);
+
+/**
+ * Add an argument at the specified position in a NULL terminated
+ * argument vector
+ *
+ * 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 '--' option.
+ *
+ * @param args is the structure containing the current argument list
+ * @param pos is the position at which to add the argument
+ * @param arg is the new argument to add
+ * @return -1 on allocation error, 0 on success
+ */
+int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg);
+
+/**
+ * Free the contents of argument list
+ *
+ * The structure itself is not freed
+ *
+ * @param args is the structure containing the argument list
+ */
+void fuse_opt_free_args(struct fuse_args *args);
+
+
+/**
+ * Check if an option matches
+ *
+ * @param opts is the option description array
+ * @param opt is the option to match
+ * @return 1 if a match is found, 0 if not
+ */
+int fuse_opt_match(const struct fuse_opt opts[], const char *opt);
+
+EXTERN_C_END
+
+#endif /* _FUSE_OPT_H_ */

libfuse/include/fuse_pollhandle.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stdint.h>
+
+struct fuse_chan;
+struct fuse_ll;
+
+typedef struct fuse_pollhandle_t fuse_pollhandle_t;
+struct fuse_pollhandle_t
+{
+  uint64_t kh;
+  struct fuse_chan *ch;
+  struct fuse_ll *f;
+};

libfuse/include/fuse_timeouts.h

@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef struct fuse_timeouts_s fuse_timeouts_t;
+struct fuse_timeouts_s
+{
+  uint64_t entry;
+  uint64_t attr;
+};

libfuse/include/kvec.h

@@ -0,0 +1,94 @@
+/* The MIT License
+
+   Copyright (c) 2008, by Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/*
+  An example:
+
+  #include "kvec.h"
+  int main() {
+  kvec_t(int) array;
+  kv_init(array);
+  kv_push(int, array, 10); // append
+  kv_a(int, array, 20) = 5; // dynamic
+  kv_A(array, 20) = 4; // static
+  kv_destroy(array);
+  return 0;
+  }
+*/
+
+/*
+  2008-09-22 (0.1.0):
+
+  * The initial version.
+
+  */
+
+#ifndef AC_KVEC_H
+#define AC_KVEC_H
+
+#include <stdlib.h>
+
+#define kv_roundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+
+#define kvec_t(type) struct { size_t n, m; type *a; }
+#define kv_init(v) ((v).n = (v).m = 0, (v).a = 0)
+#define kv_destroy(v) free((v).a)
+#define kv_A(v, i) ((v).a[(i)])
+#define kv_pop(v) ((v).a[--(v).n])
+#define kv_size(v) ((v).n)
+#define kv_max(v) ((v).m)
+#define kv_first(v) (kv_A(v,0))
+#define kv_last(v) (kv_A(v,kv_size(v)-1))
+#define kv_end(v) (kv_A(v,kv_size(v)))
+#define kv_delete(v,i) (kv_A(v,i) = kv_pop(v))
+
+#define kv_resize(type, v, s)  ((v).m = (s), (v).a = (type*)realloc((v).a, sizeof(type) * (v).m))
+
+#define kv_copy(type, v1, v0) do {                      \
+    if ((v1).m < (v0).n) kv_resize(type, v1, (v0).n);	\
+    (v1).n = (v0).n;                                    \
+    memcpy((v1).a, (v0).a, sizeof(type) * (v0).n);      \
+  } while (0)                                           \
+
+#define kv_push(type, v, x) do {                                \
+    if ((v).n == (v).m) {                                       \
+      (v).m = (v).m? (v).m<<1 : 2;                              \
+      (v).a = (type*)realloc((v).a, sizeof(type) * (v).m);	\
+    }                                                           \
+    (v).a[(v).n++] = (x);                                       \
+  } while (0)
+
+#define kv_pushp(type, v) (((v).n == (v).m)?                            \
+                           ((v).m = ((v).m? (v).m<<1 : 2),              \
+                            (v).a = (type*)realloc((v).a, sizeof(type) * (v).m), 0) \
+                           : 0), ((v).a + ((v).n++))
+
+#define kv_a(type, v, i) (((v).m <= (size_t)(i)?                        \
+                           ((v).m = (v).n = (i) + 1, kv_roundup32((v).m), \
+                            (v).a = (type*)realloc((v).a, sizeof(type) * (v).m), 0) \
+                           : (v).n <= (size_t)(i)? (v).n = (i) + 1      \
+                           : 0), (v).a[(i)])
+
+#endif

libfuse/include/linux_dirent64.h

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <stdint.h>
+
+struct linux_dirent64
+{
+  uint64_t ino;
+  int64_t  off;
+  uint16_t reclen;
+  uint8_t  type;
+  char     name[];
+};

libfuse/include/stat_utils.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "config.h"
+
+#ifdef HAVE_STRUCT_STAT_ST_ATIM
+#define ST_ATIM_NSEC(ST) ((ST)->st_atim.tv_nsec)
+#define ST_CTIM_NSEC(ST) ((ST)->st_ctim.tv_nsec)
+#define ST_MTIM_NSEC(ST) ((ST)->st_mtim.tv_nsec)
+#elif defined HAVE_STRUCT_STAT_ST_ATIMESPEC
+#define ST_ATIM_NSEC(ST) ((ST)->st_atimespec.tv_nsec)
+#define ST_CTIM_NSEC(ST) ((ST)->st_ctimespec.tv_nsec)
+#define ST_MTIM_NSEC(ST) ((ST)->st_mtimespec.tv_nsec)
+#else
+#define ST_ATIM_NSEC(ST) 0
+#define ST_CTIM_NSEC(ST) 0
+#define ST_MTIM_NSEC(ST) 0
+#endif

libfuse/lib/buffer.c

@@ -0,0 +1,317 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2010  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
+*/
+
+#define _GNU_SOURCE
+
+#include "config.h"
+#include "fuse_i.h"
+#include "fuse_lowlevel.h"
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <assert.h>
+
+size_t fuse_buf_size(const struct fuse_bufvec *bufv)
+{
+  size_t i;
+  size_t size = 0;
+
+  for (i = 0; i < bufv->count; i++) {
+    if (bufv->buf[i].size == SIZE_MAX)
+      size = SIZE_MAX;
+    else
+      size += bufv->buf[i].size;
+  }
+
+  return size;
+}
+
+static size_t min_size(size_t s1, size_t s2)
+{
+  return s1 < s2 ? s1 : s2;
+}
+
+static ssize_t fuse_buf_write(const struct fuse_buf *dst, size_t dst_off,
+			      const struct fuse_buf *src, size_t src_off,
+			      size_t len)
+{
+  ssize_t res = 0;
+  size_t copied = 0;
+
+  while (len) {
+    if (dst->flags & FUSE_BUF_FD_SEEK) {
+      res = pwrite(dst->fd, src->mem + src_off, len,
+                   dst->pos + dst_off);
+    } else {
+      res = write(dst->fd, src->mem + src_off, len);
+    }
+    if (res == -1) {
+      if (!copied)
+        return -errno;
+      break;
+    }
+    if (res == 0)
+      break;
+
+    copied += res;
+    if (!(dst->flags & FUSE_BUF_FD_RETRY))
+      break;
+
+    src_off += res;
+    dst_off += res;
+    len -= res;
+  }
+
+  return copied;
+}
+
+static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,
+			     const struct fuse_buf *src, size_t src_off,
+			     size_t len)
+{
+  ssize_t res = 0;
+  size_t copied = 0;
+
+  while (len) {
+    if (src->flags & FUSE_BUF_FD_SEEK) {
+      res = pread(src->fd, dst->mem + dst_off, len,
+                  src->pos + src_off);
+    } else {
+      res = read(src->fd, dst->mem + dst_off, len);
+    }
+    if (res == -1) {
+      if (!copied)
+        return -errno;
+      break;
+    }
+    if (res == 0)
+      break;
+
+    copied += res;
+    if (!(src->flags & FUSE_BUF_FD_RETRY))
+      break;
+
+    dst_off += res;
+    src_off += res;
+    len -= res;
+  }
+
+  return copied;
+}
+
+static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
+				 const struct fuse_buf *src, size_t src_off,
+				 size_t len)
+{
+  char buf[4096];
+  struct fuse_buf tmp = {
+    .size = sizeof(buf),
+    .flags = 0,
+  };
+  ssize_t res;
+  size_t copied = 0;
+
+  tmp.mem = buf;
+
+  while (len) {
+    size_t this_len = min_size(tmp.size, len);
+    size_t read_len;
+
+    res = fuse_buf_read(&tmp, 0, src, src_off, this_len);
+    if (res < 0) {
+      if (!copied)
+        return res;
+      break;
+    }
+    if (res == 0)
+      break;
+
+    read_len = res;
+    res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);
+    if (res < 0) {
+      if (!copied)
+        return res;
+      break;
+    }
+    if (res == 0)
+      break;
+
+    copied += res;
+
+    if (res < this_len)
+      break;
+
+    dst_off += res;
+    src_off += res;
+    len -= res;
+  }
+
+  return copied;
+}
+
+#ifdef HAVE_SPLICE
+static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
+			       const struct fuse_buf *src, size_t src_off,
+			       size_t len, enum fuse_buf_copy_flags flags)
+{
+  int splice_flags = 0;
+  off_t *srcpos = NULL;
+  off_t *dstpos = NULL;
+  off_t srcpos_val;
+  off_t dstpos_val;
+  ssize_t res;
+  size_t copied = 0;
+
+  if (flags & FUSE_BUF_SPLICE_MOVE)
+    splice_flags |= SPLICE_F_MOVE;
+  if (flags & FUSE_BUF_SPLICE_NONBLOCK)
+    splice_flags |= SPLICE_F_NONBLOCK;
+
+  if (src->flags & FUSE_BUF_FD_SEEK) {
+    srcpos_val = src->pos + src_off;
+    srcpos = &srcpos_val;
+  }
+  if (dst->flags & FUSE_BUF_FD_SEEK) {
+    dstpos_val = dst->pos + dst_off;
+    dstpos = &dstpos_val;
+  }
+
+  while (len) {
+    res = splice(src->fd, srcpos, dst->fd, dstpos, len, splice_flags);
+    if (res == -1) {
+      if (copied)
+        break;
+
+      if (errno != EINVAL || (flags & FUSE_BUF_FORCE_SPLICE))
+        return -errno;
+
+      /* Maybe splice is not supported for this combination */
+      return fuse_buf_fd_to_fd(dst, dst_off, src, src_off,
+                               len);
+    }
+    if (res == 0)
+      break;
+
+    copied += res;
+    if (!(src->flags & FUSE_BUF_FD_RETRY) &&
+        !(dst->flags & FUSE_BUF_FD_RETRY)) {
+      break;
+    }
+
+    len -= res;
+  }
+
+  return copied;
+}
+#else
+static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
+			       const struct fuse_buf *src, size_t src_off,
+			       size_t len, enum fuse_buf_copy_flags flags)
+{
+  (void) flags;
+
+  return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
+}
+#endif
+
+
+static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,
+				 const struct fuse_buf *src, size_t src_off,
+				 size_t len, enum fuse_buf_copy_flags flags)
+{
+  int src_is_fd = src->flags & FUSE_BUF_IS_FD;
+  int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;
+
+  if (!src_is_fd && !dst_is_fd) {
+    char *dstmem = dst->mem + dst_off;
+    char *srcmem = src->mem + src_off;
+
+    if (dstmem != srcmem) {
+      if (dstmem + len <= srcmem || srcmem + len <= dstmem)
+        memcpy(dstmem, srcmem, len);
+      else
+        memmove(dstmem, srcmem, len);
+    }
+
+    return len;
+  } else if (!src_is_fd) {
+    return fuse_buf_write(dst, dst_off, src, src_off, len);
+  } else if (!dst_is_fd) {
+    return fuse_buf_read(dst, dst_off, src, src_off, len);
+  } else if (flags & FUSE_BUF_NO_SPLICE) {
+    return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
+  } else {
+    return fuse_buf_splice(dst, dst_off, src, src_off, len, flags);
+  }
+}
+
+static const struct fuse_buf *fuse_bufvec_current(struct fuse_bufvec *bufv)
+{
+  if (bufv->idx < bufv->count)
+    return &bufv->buf[bufv->idx];
+  else
+    return NULL;
+}
+
+static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)
+{
+  const struct fuse_buf *buf = fuse_bufvec_current(bufv);
+
+  bufv->off += len;
+  assert(bufv->off <= buf->size);
+  if (bufv->off == buf->size) {
+    assert(bufv->idx < bufv->count);
+    bufv->idx++;
+    if (bufv->idx == bufv->count)
+      return 0;
+    bufv->off = 0;
+  }
+  return 1;
+}
+
+ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv,
+		      enum fuse_buf_copy_flags flags)
+{
+  size_t copied = 0;
+
+  if (dstv == srcv)
+    return fuse_buf_size(dstv);
+
+  for (;;) {
+    const struct fuse_buf *src = fuse_bufvec_current(srcv);
+    const struct fuse_buf *dst = fuse_bufvec_current(dstv);
+    size_t src_len;
+    size_t dst_len;
+    size_t len;
+    ssize_t res;
+
+    if (src == NULL || dst == NULL)
+      break;
+
+    src_len = src->size - srcv->off;
+    dst_len = dst->size - dstv->off;
+    len = min_size(src_len, dst_len);
+
+    res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len, flags);
+    if (res < 0) {
+      if (!copied)
+        return res;
+      break;
+    }
+    copied += res;
+
+    if (!fuse_bufvec_advance(srcv, res) ||
+        !fuse_bufvec_advance(dstv, res))
+      break;
+
+    if (res < len)
+      break;
+  }
+
+  return copied;
+}

libfuse/lib/crc32b.c

@@ -0,0 +1,112 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "crc32b.h"
+
+static
+const
+crc32b_t CRC32BTABLE[256] =
+  {
+   0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
+   0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+   0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
+   0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+   0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+   0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+   0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
+   0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+   0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+   0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+   0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
+   0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+   0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
+   0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+   0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+   0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+   0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
+   0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+   0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
+   0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+   0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
+   0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+   0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
+   0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+   0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+   0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+   0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
+   0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+   0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
+   0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+   0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
+   0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+   0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
+   0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+   0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+   0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+   0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
+   0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+   0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
+   0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+   0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
+   0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+   0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+  };
+
+crc32b_t
+crc32b_start(void)
+{
+  return 0xFFFFFFFF;
+}
+
+crc32b_t
+crc32b_continue(const void     *buf_,
+                const crc32b_t  len_,
+                const crc32b_t  crc_)
+{
+  int i;
+  char *buf;
+  crc32b_t crc;
+
+  crc = crc_;
+  buf = (char*)buf_;
+  for(i = 0; i < len_; i++)
+    {
+      crc = (CRC32BTABLE[(crc ^ buf[i]) & 0xFFL] ^ (crc >> 8));
+    }
+
+  return crc;
+}
+
+crc32b_t
+crc32b_finish(const crc32b_t crc_)
+{
+  return (crc_ ^ 0xFFFFFFFF);
+}
+
+crc32b_t
+crc32b(const void     *buf_,
+       const crc32b_t  len_)
+{
+  crc32b_t crc;
+
+  crc = crc32b_start();
+  crc = crc32b_continue(buf_,len_,crc);
+  crc = crc32b_finish(crc);
+
+  return crc;
+}

libfuse/lib/crc32b.h

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

libfuse/lib/debug.h

@@ -0,0 +1,51 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "fuse_kernel.h"
+
+void debug_fuse_open_out(const uint64_t              unique,
+                         const struct fuse_open_out *arg,
+                         const uint64_t              argsize);
+void debug_fuse_init_in(const struct fuse_init_in *arg);
+void debug_fuse_init_out(const uint64_t              unique,
+                         const struct fuse_init_out *arg,
+                         const uint64_t              argsize);
+void debug_fuse_entry_out(const uint64_t               unique,
+                          const struct fuse_entry_out *arg,
+                          const uint64_t               argsize);
+void debug_fuse_attr_out(const uint64_t              unique,
+                         const struct fuse_attr_out *arg,
+                         const uint64_t              argsize);
+void debug_fuse_entry_open_out(const uint64_t               unique,
+                               const struct fuse_entry_out *earg,
+                               const struct fuse_open_out  *oarg);
+void debug_fuse_readlink(const uint64_t  unique,
+                         const char     *linkname);
+void debug_fuse_write_out(const uint64_t               unique,
+                          const struct fuse_write_out *arg);
+void debug_fuse_statfs_out(const uint64_t                unique,
+                           const struct fuse_statfs_out *arg);
+void debug_fuse_getxattr_out(const uint64_t                  unique,
+                             const struct fuse_getxattr_out *arg);
+void debug_fuse_lk_out(const uint64_t            unique,
+                       const struct fuse_lk_out *arg);
+void debug_fuse_bmap_out(const uint64_t              unique,
+                         const struct fuse_bmap_out *arg);
+void debug_fuse_in_header(const struct fuse_in_header *hdr);

libfuse/lib/fmp.h

@@ -0,0 +1,380 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "kvec.h"
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#define ROUND_UP(N,S) ((((N) + (S) - 1) / (S)) * (S))
+
+typedef kvec_t(void*) slab_kvec_t;
+
+typedef struct mem_stack_t mem_stack_t;
+struct mem_stack_t
+{
+  mem_stack_t *next;
+};
+
+typedef struct fmp_t fmp_t;
+struct fmp_t
+{
+  mem_stack_t *objs;
+  slab_kvec_t  slabs;
+  uint64_t     avail_objs;
+  uint64_t     obj_size;
+  uint64_t     page_size;
+  uint64_t     slab_size;
+};
+
+static
+inline
+uint64_t
+fmp_page_size()
+{
+  return sysconf(_SC_PAGESIZE);
+}
+
+static
+inline
+void
+fmp_init(fmp_t          *fmp_,
+         const uint64_t  obj_size_,
+         const uint64_t  page_multiple_)
+{
+  kv_init(fmp_->slabs);
+  fmp_->objs       = NULL;
+  fmp_->avail_objs = 0;
+  fmp_->obj_size   = ROUND_UP(obj_size_,sizeof(void*));
+  fmp_->page_size  = fmp_page_size();
+  fmp_->slab_size  = (fmp_->page_size * page_multiple_);
+}
+
+static
+inline
+uint64_t
+fmp_slab_count(fmp_t *fmp_)
+{
+  return kv_size(fmp_->slabs);
+}
+
+static
+inline
+void*
+fmp_slab_alloc_posix_memalign(fmp_t *fmp_)
+{
+  int rv;
+  void *mem;
+  const size_t alignment = fmp_->page_size;
+  const size_t size      = fmp_->slab_size;
+
+  rv = posix_memalign(&mem,alignment,size);
+  if(rv != 0)
+    return NULL;
+
+  return NULL;
+}
+
+static
+inline
+void*
+fmp_slab_alloc_mmap(fmp_t *fmp_)
+{
+  void         *mem;
+  void         *address = NULL;
+  const size_t  length  = fmp_->slab_size;
+  const int     protect = PROT_READ|PROT_WRITE;
+  const int     flags   = MAP_PRIVATE|MAP_ANONYMOUS;
+  const int     filedes = -1;
+  const off_t   offset  = 0;
+
+  mem = mmap(address,length,protect,flags,filedes,offset);
+  if(mem == MAP_FAILED)
+    return NULL;
+
+  return mem;
+}
+
+static
+inline
+void
+fmp_slab_free_posix_memalign(fmp_t*  fmp_,
+                             void   *mem_)
+{
+  (void)fmp_;
+  free(mem_);
+}
+
+static
+inline
+void
+fmp_slab_free_mmap(fmp_t*  fmp_,
+                   void   *mem_)
+{
+  void   *addr   = mem_;
+  size_t  length = fmp_->slab_size;
+
+  (void)munmap(addr,length);
+}
+
+static
+inline
+int
+fmp_slab_alloc(fmp_t *fmp_)
+{
+  char *i;
+  void *mem;
+
+  mem = fmp_slab_alloc_mmap(fmp_);
+  if(mem == NULL)
+    return -ENOMEM;
+
+  kv_push(void*,fmp_->slabs,mem);
+
+  i = ((char*)mem + fmp_->slab_size - fmp_->obj_size);
+  while(i >= (char*)mem)
+    {
+      mem_stack_t *obj = (mem_stack_t*)i;
+
+      obj->next  = fmp_->objs;
+      fmp_->objs = obj;
+      fmp_->avail_objs++;
+
+      i -= fmp_->obj_size;
+    }
+
+  return 0;
+}
+
+static
+inline
+void*
+fmp_alloc(fmp_t *fmp_)
+{
+  void *rv;
+
+  if(fmp_->objs == NULL)
+    fmp_slab_alloc(fmp_);
+  if(fmp_->objs == NULL)
+    return NULL;
+
+  rv = fmp_->objs;
+
+  fmp_->objs = fmp_->objs->next;
+  fmp_->avail_objs--;
+
+  return rv;
+}
+
+static
+inline
+void*
+fmp_calloc(fmp_t *fmp_)
+{
+  void *obj;
+
+  obj = fmp_alloc(fmp_);
+  if(obj == NULL)
+    return NULL;
+
+  memset(obj,0,fmp_->obj_size);
+
+  return obj;
+}
+
+static
+inline
+void
+fmp_free(fmp_t *fmp_,
+         void  *obj_)
+{
+  mem_stack_t *obj = (mem_stack_t*)obj_;
+
+  obj->next  = fmp_->objs;
+  fmp_->objs = obj;
+  fmp_->avail_objs++;
+}
+
+static
+inline
+void
+fmp_clear(fmp_t *fmp_)
+{
+  while(kv_size(fmp_->slabs))
+    {
+      void *slab = kv_pop(fmp_->slabs);
+
+      fmp_slab_free_mmap(fmp_,slab);
+    }
+
+  fmp_->objs       = NULL;
+  fmp_->avail_objs = 0;
+}
+
+static
+inline
+void
+fmp_destroy(fmp_t *fmp_)
+{
+  fmp_clear(fmp_);
+  kv_destroy(fmp_->slabs);
+}
+
+static
+inline
+uint64_t
+fmp_avail_objs(fmp_t *fmp_)
+{
+  return fmp_->avail_objs;
+}
+
+static
+inline
+uint64_t
+fmp_objs_per_slab(fmp_t *fmp_)
+{
+  return (fmp_->slab_size / fmp_->obj_size);
+}
+
+static
+inline
+uint64_t
+fmp_objs_in_slab(fmp_t *fmp_,
+                 void  *slab_)
+{
+  char *slab;
+  uint64_t objs_per_slab;
+  uint64_t objs_in_slab;
+
+  slab          = (char*)slab_;
+  objs_in_slab  = 0;
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  for(mem_stack_t *stack = fmp_->objs; stack != NULL; stack = stack->next)
+    {
+      char *obj = (char*)stack;
+      if((obj >= slab) && (obj < (slab + fmp_->slab_size)))
+        objs_in_slab++;
+      if(objs_in_slab >= objs_per_slab)
+        break;
+    }
+
+  return objs_in_slab;
+}
+
+static
+inline
+void
+fmp_remove_objs_in_slab(fmp_t *fmp_,
+                        void  *slab_)
+{
+  char *slab;
+  uint64_t objs_per_slab;
+  uint64_t objs_in_slab;
+  mem_stack_t **p;
+
+  p             = &fmp_->objs;
+  slab          = (char*)slab_;
+  objs_in_slab  = 0;
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  while((*p) != NULL)
+    {
+      char *obj = (char*)*p;
+
+      if((obj >= slab) && (obj < (slab + fmp_->slab_size)))
+        {
+          objs_in_slab++;
+          *p = (*p)->next;
+          fmp_->avail_objs--;
+
+          if(objs_in_slab >= objs_per_slab)
+            break;
+          continue;
+        }
+
+      p = &(*p)->next;
+    }
+}
+
+static
+inline
+int
+fmp_gc_slab(fmp_t    *fmp_,
+            uint64_t  slab_idx_)
+{
+  char *slab;
+  uint64_t objs_in_slab;
+  uint64_t objs_per_slab;
+
+  slab_idx_ = (slab_idx_ % kv_size(fmp_->slabs));
+
+  slab = kv_A(fmp_->slabs,slab_idx_);
+
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  objs_in_slab  = fmp_objs_in_slab(fmp_,slab);
+  if(objs_in_slab != objs_per_slab)
+    return 0;
+
+  fmp_remove_objs_in_slab(fmp_,slab);
+  kv_delete(fmp_->slabs,slab_idx_);
+  fmp_slab_free_mmap(fmp_,slab);
+
+  return 1;
+}
+
+
+static
+inline
+int
+fmp_gc(fmp_t *fmp_)
+{
+  uint64_t slab_idx;
+
+  slab_idx = rand();
+
+  return fmp_gc_slab(fmp_,slab_idx);
+}
+
+static
+inline
+double
+fmp_slab_usage_ratio(fmp_t *fmp_)
+{
+  double avail_objs;
+  double objs_per_slab;
+  double nums_of_slabs;
+
+  avail_objs    = fmp_->avail_objs;
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  nums_of_slabs = kv_size(fmp_->slabs);
+
+  return (avail_objs / (objs_per_slab * nums_of_slabs));
+}
+
+static
+inline
+uint64_t
+fmp_total_allocated_memory(fmp_t *fmp_)
+{
+  return (fmp_->slab_size * kv_size(fmp_->slabs));
+}

libfuse/lib/fuse_dirents.c

@@ -0,0 +1,406 @@
+#define _FILE_OFFSET_BITS 64
+
+#include "fuse_attr.h"
+#include "fuse_dirent.h"
+#include "fuse_direntplus.h"
+#include "fuse_dirents.h"
+#include "fuse_entry.h"
+#include "linux_dirent64.h"
+#include "stat_utils.h"
+
+#include <dirent.h>
+#include <errno.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* 32KB - same as glibc getdents buffer size */
+#define DEFAULT_SIZE (1024 * 32)
+
+static
+uint64_t
+round_up(const uint64_t number_,
+         const uint64_t multiple_)
+{
+  return (((number_ + multiple_ - 1) / multiple_) * multiple_);
+}
+
+static
+uint64_t
+align_uint64_t(uint64_t v_)
+{
+  return ((v_ + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1));
+}
+
+static
+uint64_t
+fuse_dirent_size(const uint64_t namelen_)
+{
+  uint64_t rv;
+
+  rv  = offsetof(fuse_dirent_t,name);
+  rv += namelen_;
+  rv  = align_uint64_t(rv);
+
+  return rv;
+}
+
+static
+uint64_t
+fuse_direntplus_size(const uint64_t namelen_)
+{
+  uint64_t rv;
+
+  rv  = offsetof(fuse_direntplus_t,dirent.name);
+  rv += namelen_;
+  rv  = align_uint64_t(rv);
+
+  return rv;
+}
+
+static
+int
+fuse_dirents_buf_resize(fuse_dirents_t *d_,
+                        uint64_t        size_)
+{
+  if((kv_size(d_->data) + size_) >= kv_max(d_->data))
+    {
+      uint64_t new_size;
+
+      new_size = round_up((kv_size(d_->data) + size_),DEFAULT_SIZE);
+
+      kv_resize(char,d_->data,new_size);
+      if(d_->data.a == NULL)
+        return -ENOMEM;
+    }
+
+  return 0;
+}
+
+static
+void*
+fuse_dirents_dirent_alloc(fuse_dirents_t *d_,
+                          uint64_t        namelen_)
+{
+  int rv;
+  uint64_t size;
+  fuse_dirent_t *d;
+
+  size = fuse_dirent_size(namelen_);
+
+  rv = fuse_dirents_buf_resize(d_,size);
+  if(rv)
+    return NULL;
+
+  d = (fuse_dirent_t*)&kv_end(d_->data);
+  kv_size(d_->data) += size;
+
+  return d;
+}
+
+static
+void*
+fuse_dirents_direntplus_alloc(fuse_dirents_t *d_,
+                              uint64_t        namelen_)
+{
+  int rv;
+  uint64_t size;
+  fuse_dirent_t *d;
+
+  size = fuse_direntplus_size(namelen_);
+
+  rv = fuse_dirents_buf_resize(d_,size);
+  if(rv)
+    return NULL;
+
+  d = (fuse_dirent_t*)&kv_end(d_->data);
+  kv_size(d_->data) += size;
+
+  return d;
+}
+
+static
+void
+fuse_dirents_fill_attr(fuse_attr_t       *attr_,
+                       const struct stat *st_)
+{
+  attr_->ino       = st_->st_ino;
+  attr_->size      = st_->st_size;
+  attr_->blocks    = st_->st_blocks;
+  attr_->atime     = st_->st_atime;
+  attr_->mtime     = st_->st_mtime;
+  attr_->ctime     = st_->st_ctime;
+  attr_->atimensec = ST_ATIM_NSEC(st_);
+  attr_->mtimensec = ST_MTIM_NSEC(st_);
+  attr_->ctimensec = ST_CTIM_NSEC(st_);
+  attr_->mode      = st_->st_mode;
+  attr_->nlink     = st_->st_nlink;
+  attr_->uid       = st_->st_uid;
+  attr_->gid       = st_->st_gid;
+  attr_->rdev      = st_->st_rdev;
+  attr_->blksize   = st_->st_blksize;
+}
+
+fuse_dirent_t*
+fuse_dirent_next(fuse_dirent_t *cur_)
+{
+  char *buf;
+
+  buf  = (char*)cur_;
+  buf += fuse_dirent_size(cur_->namelen);
+
+  return (fuse_dirent_t*)buf;
+}
+
+fuse_direntplus_t*
+fuse_direntplus_next(fuse_direntplus_t *cur_)
+{
+  char *buf;
+
+  buf  = (char*)cur_;
+  buf += fuse_direntplus_size(cur_->dirent.namelen);
+
+  return (fuse_direntplus_t*)buf;
+}
+
+fuse_dirent_t*
+fuse_dirent_find(fuse_dirents_t *d_,
+                 const uint64_t  ino_)
+{
+  fuse_dirent_t *cur;
+  fuse_dirent_t *end;
+
+  if(d_->type != NORMAL)
+    return NULL;
+
+  cur = (fuse_dirent_t*)&kv_first(d_->data);
+  end = (fuse_dirent_t*)&kv_end(d_->data);
+  while(cur < end)
+    {
+      if(cur->ino == ino_)
+        return cur;
+
+      cur = fuse_dirent_next(cur);
+    }
+
+  return NULL;
+}
+
+fuse_direntplus_t*
+fuse_direntplus_find(fuse_dirents_t *d_,
+                     const uint64_t  ino_)
+{
+  fuse_direntplus_t *cur;
+  fuse_direntplus_t *end;
+
+  if(d_->type != PLUS)
+    return NULL;
+
+  cur = (fuse_direntplus_t*)&kv_first(d_->data);
+  end = (fuse_direntplus_t*)&kv_end(d_->data);
+  while(cur < end)
+    {
+      if(cur->dirent.ino == ino_)
+        return cur;
+
+      cur = fuse_direntplus_next(cur);
+    }
+
+  return NULL;
+}
+
+void*
+fuse_dirents_find(fuse_dirents_t *d_,
+                  const uint64_t  ino_)
+{
+  switch(d_->type)
+    {
+    default:
+    case UNSET:
+      return NULL;
+    case NORMAL:
+      return fuse_dirent_find(d_,ino_);
+    case PLUS:
+      return fuse_direntplus_find(d_,ino_);
+    }
+}
+
+int
+fuse_dirents_convert_plus2normal(fuse_dirents_t *d_)
+{
+  return -ENOSYS;
+}
+
+int
+fuse_dirents_add(fuse_dirents_t      *d_,
+                 const struct dirent *dirent_,
+                 const uint64_t       namelen_)
+{
+  fuse_dirent_t *d;
+
+  switch(d_->type)
+    {
+    case UNSET:
+      d_->type = NORMAL;
+      break;
+    case NORMAL:
+      break;
+    case PLUS:
+      return -EINVAL;
+    }
+
+  d = fuse_dirents_dirent_alloc(d_,namelen_);
+  if(d == NULL)
+    return -ENOMEM;
+
+  d->off     = kv_size(d_->offs);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
+  d->ino     = dirent_->d_ino;
+  d->namelen = namelen_;
+  d->type    = dirent_->d_type;
+  memcpy(d->name,dirent_->d_name,namelen_);
+
+  return 0;
+}
+
+int
+fuse_dirents_add_plus(fuse_dirents_t      *d_,
+                      const struct dirent *dirent_,
+                      const uint64_t       namelen_,
+                      const fuse_entry_t  *entry_,
+                      const struct stat   *st_)
+{
+  fuse_direntplus_t *d;
+
+  switch(d_->type)
+    {
+    case UNSET:
+      d_->type = PLUS;
+      break;
+    case NORMAL:
+      return -EINVAL;
+    case PLUS:
+      break;
+    }
+
+  d = fuse_dirents_direntplus_alloc(d_,namelen_);
+  if(d == NULL)
+    return -ENOMEM;
+
+  d->dirent.off     = kv_size(d_->offs);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
+  d->dirent.ino     = dirent_->d_ino;
+  d->dirent.namelen = namelen_;
+  d->dirent.type    = dirent_->d_type;
+  memcpy(d->dirent.name,dirent_->d_name,namelen_);
+
+  d->entry = *entry_;
+
+  fuse_dirents_fill_attr(&d->attr,st_);
+
+  return 0;
+}
+
+int
+fuse_dirents_add_linux(fuse_dirents_t              *d_,
+                       const struct linux_dirent64 *dirent_,
+                       const uint64_t               namelen_)
+{
+  fuse_dirent_t *d;
+
+  switch(d_->type)
+    {
+    case UNSET:
+      d_->type = NORMAL;
+      break;
+    case NORMAL:
+      break;
+    case PLUS:
+      return -EINVAL;
+    }
+
+  d = fuse_dirents_dirent_alloc(d_,namelen_);
+  if(d == NULL)
+    return -ENOMEM;
+
+  d->off     = kv_size(d_->offs);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
+  d->ino     = dirent_->ino;
+  d->namelen = namelen_;
+  d->type    = dirent_->type;
+  memcpy(d->name,dirent_->name,namelen_);
+
+  return 0;
+}
+
+int
+fuse_dirents_add_linux_plus(fuse_dirents_t              *d_,
+                            const struct linux_dirent64 *dirent_,
+                            const uint64_t               namelen_,
+                            const fuse_entry_t          *entry_,
+                            const struct stat           *st_)
+{
+  fuse_direntplus_t *d;
+
+  switch(d_->type)
+    {
+    case UNSET:
+      d_->type = PLUS;
+      break;
+    case NORMAL:
+      return -EINVAL;
+    case PLUS:
+      break;
+    }
+
+  d = fuse_dirents_direntplus_alloc(d_,namelen_);
+  if(d == NULL)
+    return -ENOMEM;
+
+  d->dirent.off     = kv_size(d_->offs);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
+  d->dirent.ino     = dirent_->ino;
+  d->dirent.namelen = namelen_;
+  d->dirent.type    = dirent_->type;
+  memcpy(d->dirent.name,dirent_->name,namelen_);
+
+  d->entry = *entry_;
+
+  fuse_dirents_fill_attr(&d->attr,st_);
+
+  return 0;
+}
+
+void
+fuse_dirents_reset(fuse_dirents_t *d_)
+{
+  d_->type          = UNSET;
+  kv_size(d_->data) = 0;
+  kv_size(d_->offs) = 1;
+}
+
+int
+fuse_dirents_init(fuse_dirents_t *d_)
+{
+  d_->type = UNSET;
+
+  kv_init(d_->data);
+  kv_resize(char,d_->data,DEFAULT_SIZE);
+  if(d_->data.a == NULL)
+    return -ENOMEM;
+
+  kv_init(d_->offs);
+  kv_resize(uint32_t,d_->offs,64);
+  kv_push(uint32_t,d_->offs,0);
+
+  return 0;
+}
+
+void
+fuse_dirents_free(fuse_dirents_t *d_)
+{
+  kv_destroy(d_->data);
+  kv_destroy(d_->offs);
+}

libfuse/lib/fuse_i.h

@@ -0,0 +1,118 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
+*/
+
+#pragma once
+
+#include "fuse.h"
+#include "fuse_lowlevel.h"
+
+#include "extern_c.h"
+
+struct fuse_chan;
+struct fuse_ll;
+
+struct fuse_session
+{
+  int (*receive_buf)(struct fuse_session *se,
+                     struct fuse_buf *buf,
+                     struct fuse_chan *ch);
+
+  void (*process_buf)(void *data,
+                      const void *buf,
+                      struct fuse_chan *ch);
+
+  void (*destroy)(void *data);
+
+  void *data;
+  volatile int exited;
+  struct fuse_chan *ch;
+};
+
+struct fuse_req
+{
+  struct fuse_ll *f;
+  uint64_t unique;
+  struct fuse_ctx ctx;
+  struct fuse_chan *ch;
+  unsigned int ioctl_64bit : 1;
+};
+
+struct fuse_notify_req
+{
+  uint64_t unique;
+  void (*reply)(struct fuse_notify_req *,
+                fuse_req_t,
+                uint64_t,
+                const void *);
+  struct fuse_notify_req *next;
+  struct fuse_notify_req *prev;
+};
+
+struct fuse_ll
+{
+  int debug;
+  int no_remote_posix_lock;
+  int no_remote_flock;
+  int big_writes;
+  int splice_write;
+  int splice_move;
+  int splice_read;
+  int no_splice_write;
+  int no_splice_move;
+  int no_splice_read;
+  struct fuse_lowlevel_ops op;
+  int got_init;
+  void *userdata;
+  uid_t owner;
+  struct fuse_conn_info conn;
+  pthread_mutex_t lock;
+  int got_destroy;
+  pthread_key_t pipe_key;
+  int broken_splice_nonblock;
+  uint64_t notify_ctr;
+  struct fuse_notify_req notify_list;
+};
+
+struct fuse_cmd
+{
+  char *buf;
+  size_t buflen;
+  struct fuse_chan *ch;
+};
+
+EXTERN_C_BEGIN
+
+struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
+			     const struct fuse_operations *op,
+			     size_t op_size);
+
+struct fuse_chan *fuse_kern_chan_new(int fd);
+
+struct fuse_session *fuse_lowlevel_new_common(struct fuse_args *args,
+                                              const struct fuse_lowlevel_ops *op,
+                                              size_t op_size, void *userdata);
+
+int fuse_chan_clearfd(struct fuse_chan *ch);
+
+void fuse_kern_unmount(const char *mountpoint, int fd);
+int fuse_kern_mount(const char *mountpoint, struct fuse_args *args);
+
+int fuse_send_reply_iov_nofree(fuse_req_t req, int error, struct iovec *iov,
+			       int count);
+void fuse_free_req(fuse_req_t req);
+
+
+struct fuse *fuse_setup_common(int argc, char *argv[],
+			       const struct fuse_operations *op,
+			       size_t op_size,
+			       char **mountpoint,
+			       int *fd);
+
+int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg);
+
+EXTERN_C_END

libfuse/lib/fuse_loop_mt.cpp

@@ -0,0 +1,239 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#include "pool.hpp"
+
+#include "fuse_i.h"
+#include "fuse_kernel.h"
+#include "fuse_lowlevel.h"
+#include "fuse_misc.h"
+
+#include <errno.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <unistd.h>
+
+/* Environment var controlling the thread stack size */
+#define ENVNAME_THREAD_STACK "FUSE_THREAD_STACK"
+
+struct fuse_worker
+{
+  struct fuse_worker *prev;
+  struct fuse_worker *next;
+  pthread_t thread_id;
+  size_t bufsize;
+  char *buf;
+  struct fuse_mt *mt;
+};
+
+struct fuse_mt
+{
+  struct fuse_session *se;
+  struct fuse_worker main;
+  sem_t finish;
+  int exit;
+  int error;
+};
+
+static
+void
+list_add_worker(struct fuse_worker *w,
+                struct fuse_worker *next)
+{
+  struct fuse_worker *prev = next->prev;
+  w->next = next;
+  w->prev = prev;
+  prev->next = w;
+  next->prev = w;
+}
+
+static void list_del_worker(struct fuse_worker *w)
+{
+  struct fuse_worker *prev = w->prev;
+  struct fuse_worker *next = w->next;
+  prev->next = next;
+  next->prev = prev;
+}
+
+static int fuse_loop_start_thread(struct fuse_mt *mt);
+
+thread_pool tp;
+
+static
+void*
+fuse_do_work(void *data)
+{
+  struct fuse_worker *w  = (struct fuse_worker *) data;
+  struct fuse_mt     *mt = w->mt;
+
+  while(!fuse_session_exited(mt->se))
+    {
+      int res;
+      struct fuse_buf fbuf = {0};
+
+      fbuf.mem = (char*)malloc(w->bufsize);
+      fbuf.size = w->bufsize;
+
+      pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+      res = mt->se->receive_buf(mt->se,&fbuf,mt->se->ch);
+      pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+      if(res == -EINTR)
+        continue;
+      if(res <= 0)
+        {
+          if(res < 0)
+            {
+              mt->se->exited = 1;
+              mt->error = -1;
+            }
+          break;
+        }
+
+      if(mt->exit)
+        return NULL;
+
+      tp.enqueue_work([=] {
+        mt->se->process_buf(mt->se->data,fbuf.mem,mt->se->ch);
+
+        free(fbuf.mem);
+      });
+    }
+
+  sem_post(&mt->finish);
+
+  return NULL;
+}
+
+int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg)
+{
+  sigset_t oldset;
+  sigset_t newset;
+  int res;
+  pthread_attr_t attr;
+  char *stack_size;
+
+  /* Override default stack size */
+  pthread_attr_init(&attr);
+  stack_size = getenv(ENVNAME_THREAD_STACK);
+  if(stack_size && pthread_attr_setstacksize(&attr, atoi(stack_size)))
+    fprintf(stderr, "fuse: invalid stack size: %s\n", stack_size);
+
+  /* Disallow signal reception in worker threads */
+  sigfillset(&newset);
+  pthread_sigmask(SIG_BLOCK,&newset,&oldset);
+  res = pthread_create(thread_id, &attr, func, arg);
+  pthread_sigmask(SIG_SETMASK,&oldset,NULL);
+  pthread_attr_destroy(&attr);
+  if(res != 0) {
+    fprintf(stderr, "fuse: error creating thread: %s\n",
+            strerror(res));
+    return -1;
+  }
+
+  return 0;
+}
+
+static int fuse_loop_start_thread(struct fuse_mt *mt)
+{
+  int res;
+  struct fuse_worker *w = (struct fuse_worker*)malloc(sizeof(struct fuse_worker));
+  if(!w) {
+    fprintf(stderr, "fuse: failed to allocate worker structure\n");
+    return -1;
+  }
+  memset(w, 0, sizeof(struct fuse_worker));
+  w->bufsize = fuse_chan_bufsize(mt->se->ch);
+  w->buf = (char*)calloc(w->bufsize,1);
+  w->mt = mt;
+  if(!w->buf) {
+    fprintf(stderr, "fuse: failed to allocate read buffer\n");
+    free(w);
+    return -1;
+  }
+
+  res = fuse_start_thread(&w->thread_id, fuse_do_work, w);
+  if(res == -1) {
+    free(w->buf);
+    free(w);
+    return -1;
+  }
+  list_add_worker(w, &mt->main);
+
+  return 0;
+}
+
+static void fuse_join_worker(struct fuse_worker *w)
+{
+  pthread_join(w->thread_id, NULL);
+  list_del_worker(w);
+  free(w->buf);
+  free(w);
+}
+
+static int number_of_threads(void)
+{
+#ifdef _SC_NPROCESSORS_ONLN
+  return sysconf(_SC_NPROCESSORS_ONLN);
+#endif
+
+  return 4;
+}
+
+int
+fuse_session_loop_mt(struct fuse_session *se_,
+                     const int            threads_)
+{
+  int i;
+  int err;
+  int threads;
+  struct fuse_mt mt;
+  struct fuse_worker *w;
+
+  memset(&mt,0,sizeof(struct fuse_mt));
+  mt.se = se_;
+  mt.error = 0;
+  mt.main.thread_id = pthread_self();
+  mt.main.prev = mt.main.next = &mt.main;
+  sem_init(&mt.finish,0,0);
+
+  threads = ((threads_ > 0) ? threads_ : number_of_threads());
+  if(threads_ < 0)
+    threads /= -threads_;
+  if(threads == 0)
+    threads = 1;
+
+  err = 0;
+  for(i = 0; (i < threads) && !err; i++)
+    err = fuse_loop_start_thread(&mt);
+
+  if(!err)
+    {
+      /* sem_wait() is interruptible */
+      while(!fuse_session_exited(se_))
+        sem_wait(&mt.finish);
+
+      for(w = mt.main.next; w != &mt.main; w = w->next)
+        pthread_cancel(w->thread_id);
+      mt.exit = 1;
+
+      while(mt.main.next != &mt.main)
+        fuse_join_worker(mt.main.next);
+
+      err = mt.error;
+    }
+
+  sem_destroy(&mt.finish);
+  fuse_session_reset(se_);
+
+  return err;
+}

libfuse/lib/fuse_misc.h

@@ -0,0 +1,63 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
+*/
+
+#pragma once
+
+#include "config.h"
+
+#include <pthread.h>
+
+/*
+  Versioned symbols cannot be used in some cases because it
+  - confuse the dynamic linker in uClibc
+  - not supported on MacOSX (in MachO binary format)
+*/
+#if (!defined(__UCLIBC__) && !defined(__APPLE__))
+#define FUSE_SYMVER(x) __asm__(x)
+#else
+#define FUSE_SYMVER(x)
+#endif
+
+#ifndef USE_UCLIBC
+#define fuse_mutex_init(mut) pthread_mutex_init(mut, NULL)
+#else
+/* Is this hack still needed? */
+static inline void fuse_mutex_init(pthread_mutex_t *mut)
+{
+  pthread_mutexattr_t attr;
+  pthread_mutexattr_init(&attr);
+  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
+  pthread_mutex_init(mut, &attr);
+  pthread_mutexattr_destroy(&attr);
+}
+#endif
+
+#ifdef HAVE_STRUCT_STAT_ST_ATIM
+/* Linux */
+#define ST_ATIM_NSEC(stbuf)         ((stbuf)->st_atim.tv_nsec)
+#define ST_CTIM_NSEC(stbuf)         ((stbuf)->st_ctim.tv_nsec)
+#define ST_MTIM_NSEC(stbuf)         ((stbuf)->st_mtim.tv_nsec)
+#define ST_ATIM_NSEC_SET(stbuf,val) ((stbuf)->st_atim.tv_nsec = (val))
+#define ST_CTIM_NSEC_SET(stbuf,val) ((stbuf)->st_ctim.tv_nsec = (val))
+#define ST_MTIM_NSEC_SET(stbuf,val) ((stbuf)->st_mtim.tv_nsec = (val))
+#elif defined(HAVE_STRUCT_STAT_ST_ATIMESPEC)
+/* FreeBSD */
+#define ST_ATIM_NSEC(stbuf)         ((stbuf)->st_atimespec.tv_nsec)
+#define ST_CTIM_NSEC(stbuf)         ((stbuf)->st_ctimespec.tv_nsec)
+#define ST_MTIM_NSEC(stbuf)         ((stbuf)->st_mtimespec.tv_nsec)
+#define ST_ATIM_NSEC_SET(stbuf,val) ((stbuf)->st_atimespec.tv_nsec = (val))
+#define ST_CTIM_NSEC_SET(stbuf,val) ((stbuf)->st_ctimespec.tv_nsec = (val))
+#define ST_MTIM_NSEC_SET(stbuf,val) ((stbuf)->st_mtimespec.tv_nsec = (val))
+#else
+#define ST_ATIM_NSEC(stbuf) 0
+#define ST_CTIM_NSEC(stbuf) 0
+#define ST_MTIM_NSEC(stbuf) 0
+#define ST_ATIM_NSEC_SET(stbuf,val) do { } while (0)
+#define ST_CTIM_NSEC_SET(stbuf,val) do { } while (0)
+#define ST_MTIM_NSEC_SET(stbuf,val) do { } while (0)
+#endif

libfuse/lib/fuse_mt.c

@@ -0,0 +1,35 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#include "fuse_i.h"
+#include "fuse_misc.h"
+#include "fuse_lowlevel.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <assert.h>
+
+int
+fuse_loop_mt(struct fuse *f)
+{
+  if (f == NULL)
+    return -1;
+
+  int res = fuse_start_maintenance_thread(f);
+  if (res)
+    return -1;
+
+  res = fuse_session_loop_mt(fuse_get_session(f),
+                             fuse_config_num_threads(f));
+
+  fuse_stop_maintenance_thread(f);
+
+  return res;
+}

libfuse/lib/fuse_node.c

@@ -0,0 +1,224 @@
+#include "fuse_node.h"
+
+#include "khash.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <stdio.h> // for debugging
+
+#define UNKNOWN_INO    UINT64_MAX
+#define ROOT_NODE_ID   0
+#define ROOT_NODE_NAME "/"
+
+typedef struct node_idname_t node_idname_t;
+struct node_idname_t
+{
+  uint64_t    id;
+  const char *name;
+};
+
+static khint_t idname_hash_func(const node_idname_t idname);
+static int     idname_hash_equal(const node_idname_t idname0, const node_idname_t idname1);
+
+KHASH_INIT(node,node_idname_t,fuse_node_t*,1,idname_hash_func,idname_hash_equal);
+
+typedef struct fuse_node_hashtable_t fuse_node_hashtable_t;
+struct fuse_node_hashtable_t
+{
+  kh_node_t *ht;
+  uint64_t   id;
+  uint64_t   generation;
+};
+
+static
+inline
+khint_t
+idname_hash_func(const node_idname_t idname_)
+{
+  if(idname_.name == NULL)
+    return idname_.id;
+  return (idname_.id ^ kh_str_hash_func(idname_.name));
+}
+
+static
+inline
+int
+idname_hash_equal(const node_idname_t idname0_,
+                  const node_idname_t idname1_)
+{
+  return ((idname0_.id == idname1_.id) &&
+          ((idname0_.name == idname1_.name) ||
+           (strcmp(idname0_.name,idname1_.name) == 0)));
+}
+
+static
+inline
+fuse_node_t*
+fuse_node_alloc(const uint64_t  id_,
+                const char     *name_)
+{
+  fuse_node_t *node;
+
+  node = (fuse_node_t*)calloc(1,sizeof(fuse_node_t));
+
+  node->id           = id_;
+  node->name         = strdup(name_);
+  node->ref_count    = 1;
+  node->lookup_count = 1;
+
+  return node;
+}
+
+static
+inline
+void
+fuse_node_free(fuse_node_t *node_)
+{
+  free(node_->name);
+  free(node_);
+}
+
+static
+inline
+uint64_t
+rand64()
+{
+  uint64_t rv;
+
+  rv   = rand();
+  rv <<= 32;
+  rv  |= rand();
+
+  return rv;
+}
+
+static
+inline
+void
+node_hashtable_gen_unique_id(fuse_node_hashtable_t *ht_)
+{
+  do
+    {
+      ht_->id++;
+      if(ht_->id == 0)
+        ht_->generation++;
+    }
+  while((ht_->id == 0) || (ht_->id == UNKNOWN_INO));
+}
+
+static
+inline
+void
+node_hashtable_put_root(fuse_node_hashtable_t *ht_)
+{
+  int rv;
+  khint_t k;
+  fuse_node_t *root_node;
+  const node_idname_t idname0 = {ROOT_NODE_ID,""};
+  const node_idname_t idname1 = {ROOT_NODE_ID,ROOT_NODE_NAME};
+
+  root_node = fuse_node_alloc(ROOT_NODE_ID,ROOT_NODE_NAME);
+
+  k = kh_put_node(ht_->ht,idname0,&rv);
+  kh_value(ht_->ht,k) = root_node;
+
+  k = kh_put_node(ht_->ht,idname1,&rv);
+  kh_value(ht_->ht,k) = root_node;
+}
+
+static
+inline
+void
+node_hashtable_set_id_gen(fuse_node_hashtable_t *ht_,
+                          fuse_node_t           *node_)
+{
+  node_hashtable_gen_unique_id(ht_);
+  node_->id         = ht_->id;
+  node_->generation = ht_->generation;
+}
+
+fuse_node_hashtable_t*
+fuse_node_hashtable_init()
+{
+  fuse_node_hashtable_t *ht;
+
+  ht = (fuse_node_hashtable_t*)calloc(sizeof(fuse_node_hashtable_t),1);
+  if(ht == NULL)
+    return NULL;
+
+  ht->ht = kh_init_node();
+  if(ht->ht == NULL)
+    {
+      free(ht);
+      return NULL;
+    }
+
+  srand(time(NULL));
+  ht->id         = 0;
+  ht->generation = rand64();
+
+  node_hashtable_put_root(ht);
+
+  return ht;
+}
+
+fuse_node_t*
+fuse_node_hashtable_put(fuse_node_hashtable_t *ht_,
+                        const uint64_t         parent_id_,
+                        const uint64_t         child_id_,
+                        const char            *child_name_)
+{
+  int rv;
+  khint_t k;
+  fuse_node_t *child_node;
+  const node_idname_t p_idname  = {parent_id_,""};
+  const node_idname_t c0_idname = {child_id_,child_name_};
+  const node_idname_t c1_idname = {parent_id_,child_name_};
+
+  child_node = fuse_node_alloc(child_id_,child_name_);
+
+  k = kh_get_node(ht_->ht,p_idname);
+  child_node->parent = kh_value(ht_->ht,k);
+  child_node->parent->ref_count++;
+
+  k = kh_put_node(ht_->ht,c0_idname,&rv);
+  kh_value(ht_->ht,k) = child_node;
+
+  k = kh_put_node(ht_->ht,c1_idname,&rv);
+  kh_value(ht_->ht,k) = child_node;
+
+  return child_node;
+}
+
+fuse_node_t*
+fuse_node_hashtable_get(fuse_node_hashtable_t *ht_,
+                        const uint64_t         id_)
+{
+  return fuse_node_hashtable_get_child(ht_,id_,"");
+}
+
+fuse_node_t*
+fuse_node_hashtable_get_child(fuse_node_hashtable_t *ht_,
+                              const uint64_t         parent_id_,
+                              const char            *child_name_)
+{
+  khint_t k;
+  fuse_node_t *node;
+  const node_idname_t idname = {parent_id_,child_name_};
+
+  k = kh_get_node(ht_->ht,idname);
+  node = ((k != kh_end(ht_->ht)) ?
+          kh_value(ht_->ht,k) :
+          NULL);
+
+  return node;
+}
+
+void
+fuse_node_hashtable_del(fuse_node_hashtable_t *ht_,
+                        fuse_node_t           *node_)
+{
+
+}

libfuse/lib/fuse_node.h

@@ -0,0 +1,36 @@
+#include <stdint.h>
+
+typedef struct fuse_node_t fuse_node_t;
+struct fuse_node_t
+{
+  uint64_t     id;
+  uint64_t     generation;  
+  char        *name;
+  fuse_node_t *parent;
+  uint32_t     ref_count;
+  uint64_t     lookup_count;
+  uint64_t     open_count;
+};
+
+struct fuse_node_hashtable_t;
+typedef struct fuse_node_hashtable_t fuse_node_hashtable_t;
+
+
+fuse_node_hashtable_t *fuse_node_hashtable_init();
+
+fuse_node_t *fuse_node_hashtable_put(fuse_node_hashtable_t *ht,
+                                     const uint64_t         parent_id,
+                                     const uint64_t         child_id,
+                                     const char            *child_name);
+
+fuse_node_t* fuse_node_hashtable_get(fuse_node_hashtable_t *ht,
+                                     const uint64_t         id);
+fuse_node_t* fuse_node_hashtable_get_child(fuse_node_hashtable_t *ht,
+                                           const uint64_t         id,
+                                           const char            *name);
+void fuse_node_hashtable_del(fuse_node_hashtable_t *ht,
+                             fuse_node_t           *node);
+
+void fuse_node_hashtable_get_path(fuse_node_hashtable_t *ht,
+                                  char                  *buf,
+                                  uint32_t               buflen);

libfuse/lib/fuse_opt.c

@@ -0,0 +1,421 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
+*/
+
+#include "fuse_opt.h"
+#include "fuse_misc.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+struct fuse_opt_context
+{
+  void *data;
+  const struct fuse_opt *opt;
+  fuse_opt_proc_t proc;
+  int argctr;
+  int argc;
+  char **argv;
+  struct fuse_args outargs;
+  char *opts;
+  int nonopt;
+};
+
+void
+fuse_opt_free_args(struct fuse_args *args)
+{
+  if (args) {
+    if (args->argv && args->allocated) {
+      int i;
+      for (i = 0; i < args->argc; i++)
+        free(args->argv[i]);
+      free(args->argv);
+    }
+    args->argc = 0;
+    args->argv = NULL;
+    args->allocated = 0;
+  }
+}
+
+static
+int
+alloc_failed(void)
+{
+  fprintf(stderr, "fuse: memory allocation failed\n");
+  return -1;
+}
+
+int
+fuse_opt_add_arg(struct fuse_args *args, const char *arg)
+{
+  char **newargv;
+  char *newarg;
+
+  assert(!args->argv || args->allocated);
+
+  newarg = strdup(arg);
+  if (!newarg)
+    return alloc_failed();
+
+  newargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));
+  if (!newargv) {
+    free(newarg);
+    return alloc_failed();
+  }
+
+  args->argv = newargv;
+  args->allocated = 1;
+  args->argv[args->argc++] = newarg;
+  args->argv[args->argc] = NULL;
+  return 0;
+}
+
+static int fuse_opt_insert_arg_common(struct fuse_args *args, int pos,
+				      const char *arg)
+{
+  assert(pos <= args->argc);
+  if (fuse_opt_add_arg(args, arg) == -1)
+    return -1;
+
+  if (pos != args->argc - 1) {
+    char *newarg = args->argv[args->argc - 1];
+    memmove(&args->argv[pos + 1], &args->argv[pos],
+            sizeof(char *) * (args->argc - pos - 1));
+    args->argv[pos] = newarg;
+  }
+  return 0;
+}
+
+int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg)
+{
+  return fuse_opt_insert_arg_common(args, pos, arg);
+}
+
+static int next_arg(struct fuse_opt_context *ctx, const char *opt)
+{
+  if (ctx->argctr + 1 >= ctx->argc) {
+    fprintf(stderr, "fuse: missing argument after `%s'\n", opt);
+    return -1;
+  }
+  ctx->argctr++;
+  return 0;
+}
+
+static int add_arg(struct fuse_opt_context *ctx, const char *arg)
+{
+  return fuse_opt_add_arg(&ctx->outargs, arg);
+}
+
+static int add_opt_common(char **opts, const char *opt, int esc)
+{
+  unsigned oldlen = *opts ? strlen(*opts) : 0;
+  char *d = realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);
+
+  if (!d)
+    return alloc_failed();
+
+  *opts = d;
+  if (oldlen) {
+    d += oldlen;
+    *d++ = ',';
+  }
+
+  for (; *opt; opt++) {
+    if (esc && (*opt == ',' || *opt == '\\'))
+      *d++ = '\\';
+    *d++ = *opt;
+  }
+  *d = '\0';
+
+  return 0;
+}
+
+int fuse_opt_add_opt(char **opts, const char *opt)
+{
+  return add_opt_common(opts, opt, 0);
+}
+
+int fuse_opt_add_opt_escaped(char **opts, const char *opt)
+{
+  return add_opt_common(opts, opt, 1);
+}
+
+static int add_opt(struct fuse_opt_context *ctx, const char *opt)
+{
+  return add_opt_common(&ctx->opts, opt, 1);
+}
+
+static int call_proc(struct fuse_opt_context *ctx, const char *arg, int key,
+		     int iso)
+{
+  if (key == FUSE_OPT_KEY_DISCARD)
+    return 0;
+
+  if (key != FUSE_OPT_KEY_KEEP && ctx->proc) {
+    int res = ctx->proc(ctx->data, arg, key, &ctx->outargs);
+    if (res == -1 || !res)
+      return res;
+  }
+  if (iso)
+    return add_opt(ctx, arg);
+  else
+    return add_arg(ctx, arg);
+}
+
+static int match_template(const char *t, const char *arg, unsigned *sepp)
+{
+  int arglen = strlen(arg);
+  const char *sep = strchr(t, '=');
+  sep = sep ? sep : strchr(t, ' ');
+  if (sep && (!sep[1] || sep[1] == '%')) {
+    int tlen = sep - t;
+    if (sep[0] == '=')
+      tlen ++;
+    if (arglen >= tlen && strncmp(arg, t, tlen) == 0) {
+      *sepp = sep - t;
+      return 1;
+    }
+  }
+  if (strcmp(t, arg) == 0) {
+    *sepp = 0;
+    return 1;
+  }
+  return 0;
+}
+
+static const struct fuse_opt *find_opt(const struct fuse_opt *opt,
+				       const char *arg, unsigned *sepp)
+{
+  for (; opt && opt->templ; opt++)
+    if (match_template(opt->templ, arg, sepp))
+      return opt;
+  return NULL;
+}
+
+int fuse_opt_match(const struct fuse_opt *opts, const char *opt)
+{
+  unsigned dummy;
+  return find_opt(opts, opt, &dummy) ? 1 : 0;
+}
+
+static int process_opt_param(void *var, const char *format, const char *param,
+			     const char *arg)
+{
+  assert(format[0] == '%');
+  if (format[1] == 's') {
+    char *copy = strdup(param);
+    if (!copy)
+      return alloc_failed();
+
+    *(char **) var = copy;
+  } else {
+    if (sscanf(param, format, var) != 1) {
+      fprintf(stderr, "fuse: invalid parameter in option `%s'\n", arg);
+      return -1;
+    }
+  }
+  return 0;
+}
+
+static int process_opt(struct fuse_opt_context *ctx,
+		       const struct fuse_opt *opt, unsigned sep,
+		       const char *arg, int iso)
+{
+  if (opt->offset == -1U) {
+    if (call_proc(ctx, arg, opt->value, iso) == -1)
+      return -1;
+  } else {
+    void *var = ctx->data + opt->offset;
+    if (sep && opt->templ[sep + 1]) {
+      const char *param = arg + sep;
+      if (opt->templ[sep] == '=')
+        param ++;
+      if (process_opt_param(var, opt->templ + sep + 1,
+                            param, arg) == -1)
+        return -1;
+    } else
+      *(int *)var = opt->value;
+  }
+  return 0;
+}
+
+static int process_opt_sep_arg(struct fuse_opt_context *ctx,
+			       const struct fuse_opt *opt, unsigned sep,
+			       const char *arg, int iso)
+{
+  int res;
+  char *newarg;
+  char *param;
+
+  if (next_arg(ctx, arg) == -1)
+    return -1;
+
+  param = ctx->argv[ctx->argctr];
+  newarg = malloc(sep + strlen(param) + 1);
+  if (!newarg)
+    return alloc_failed();
+
+  memcpy(newarg, arg, sep);
+  strcpy(newarg + sep, param);
+  res = process_opt(ctx, opt, sep, newarg, iso);
+  free(newarg);
+
+  return res;
+}
+
+static int process_gopt(struct fuse_opt_context *ctx, const char *arg, int iso)
+{
+  unsigned sep;
+  const struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep);
+  if (opt) {
+    for (; opt; opt = find_opt(opt + 1, arg, &sep)) {
+      int res;
+      if (sep && opt->templ[sep] == ' ' && !arg[sep])
+        res = process_opt_sep_arg(ctx, opt, sep, arg,
+                                  iso);
+      else
+        res = process_opt(ctx, opt, sep, arg, iso);
+      if (res == -1)
+        return -1;
+    }
+    return 0;
+  } else
+    return call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);
+}
+
+static int process_real_option_group(struct fuse_opt_context *ctx, char *opts)
+{
+  char *s = opts;
+  char *d = s;
+  int end = 0;
+
+  while (!end) {
+    if (*s == '\0')
+      end = 1;
+    if (*s == ',' || end) {
+      int res;
+
+      *d = '\0';
+      res = process_gopt(ctx, opts, 1);
+      if (res == -1)
+        return -1;
+      d = opts;
+    } else {
+      if (s[0] == '\\' && s[1] != '\0') {
+        s++;
+        if (s[0] >= '0' && s[0] <= '3' &&
+            s[1] >= '0' && s[1] <= '7' &&
+            s[2] >= '0' && s[2] <= '7') {
+          *d++ = (s[0] - '0') * 0100 +
+            (s[1] - '0') * 0010 +
+            (s[2] - '0');
+          s += 2;
+        } else {
+          *d++ = *s;
+        }
+      } else {
+        *d++ = *s;
+      }
+    }
+    s++;
+  }
+
+  return 0;
+}
+
+static int process_option_group(struct fuse_opt_context *ctx, const char *opts)
+{
+  int res;
+  char *copy = strdup(opts);
+
+  if (!copy) {
+    fprintf(stderr, "fuse: memory allocation failed\n");
+    return -1;
+  }
+  res = process_real_option_group(ctx, copy);
+  free(copy);
+  return res;
+}
+
+static int process_one(struct fuse_opt_context *ctx, const char *arg)
+{
+  if (ctx->nonopt || arg[0] != '-')
+    return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
+  else if (arg[1] == 'o') {
+    if (arg[2])
+      return process_option_group(ctx, arg + 2);
+    else {
+      if (next_arg(ctx, arg) == -1)
+        return -1;
+
+      return process_option_group(ctx,
+                                  ctx->argv[ctx->argctr]);
+    }
+  } else if (arg[1] == '-' && !arg[2]) {
+    if (add_arg(ctx, arg) == -1)
+      return -1;
+    ctx->nonopt = ctx->outargs.argc;
+    return 0;
+  } else
+    return process_gopt(ctx, arg, 0);
+}
+
+static int opt_parse(struct fuse_opt_context *ctx)
+{
+  if (ctx->argc) {
+    if (add_arg(ctx, ctx->argv[0]) == -1)
+      return -1;
+  }
+
+  for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
+    if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
+      return -1;
+
+  if (ctx->opts) {
+    if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
+        fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
+      return -1;
+  }
+
+  /* If option separator ("--") is the last argument, remove it */
+  if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
+      strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
+    free(ctx->outargs.argv[ctx->outargs.argc - 1]);
+    ctx->outargs.argv[--ctx->outargs.argc] = NULL;
+  }
+
+  return 0;
+}
+
+int fuse_opt_parse(struct fuse_args *args, void *data,
+		   const struct fuse_opt opts[], fuse_opt_proc_t proc)
+{
+  int res;
+  struct fuse_opt_context ctx = {
+    .data = data,
+    .opt = opts,
+    .proc = proc,
+  };
+
+  if (!args || !args->argv || !args->argc)
+    return 0;
+
+  ctx.argc = args->argc;
+  ctx.argv = args->argv;
+
+  res = opt_parse(&ctx);
+  if (res != -1) {
+    struct fuse_args tmp = *args;
+    *args = ctx.outargs;
+    ctx.outargs = tmp;
+  }
+  free(ctx.opts);
+  fuse_opt_free_args(&ctx.outargs);
+  return res;
+}

libfuse/lib/fuse_session.c

@@ -0,0 +1,229 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
+*/
+
+#include "fuse_i.h"
+#include "fuse_misc.h"
+#include "fuse_kernel.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/uio.h>
+
+
+struct fuse_chan
+{
+  struct fuse_session *se;
+  int fd;
+  size_t bufsize;
+};
+
+struct fuse_session *fuse_session_new(void *data,
+                                      void *receive_buf,
+                                      void *process_buf,
+                                      void *destroy)
+{
+  struct fuse_session *se = (struct fuse_session *) malloc(sizeof(*se));
+  if (se == NULL) {
+    fprintf(stderr, "fuse: failed to allocate session\n");
+    return NULL;
+  }
+
+  memset(se, 0, sizeof(*se));
+  se->data = data;
+  se->receive_buf = receive_buf;
+  se->process_buf = process_buf;
+  se->destroy     = destroy;
+
+  return se;
+}
+
+void fuse_session_add_chan(struct fuse_session *se, struct fuse_chan *ch)
+{
+  assert(se->ch == NULL);
+  assert(ch->se == NULL);
+  se->ch = ch;
+  ch->se = se;
+}
+
+void fuse_session_remove_chan(struct fuse_chan *ch)
+{
+  struct fuse_session *se = ch->se;
+  if (se) {
+    assert(se->ch == ch);
+    se->ch = NULL;
+    ch->se = NULL;
+  }
+}
+
+void
+fuse_session_destroy(struct fuse_session *se)
+{
+  se->destroy(se->data);
+  if(se->ch != NULL)
+    fuse_chan_destroy(se->ch);
+  free(se);
+}
+
+void fuse_session_reset(struct fuse_session *se)
+{
+  se->exited = 0;
+}
+
+int
+fuse_session_exited(struct fuse_session *se)
+{
+  return se->exited;
+}
+
+void
+fuse_session_exit(struct fuse_session *se_)
+{
+  se_->exited = 1;
+}
+
+void *fuse_session_data(struct fuse_session *se)
+{
+  return se->data;
+}
+
+struct fuse_chan *
+fuse_chan_new(int fd,
+              size_t bufsize)
+{
+  struct fuse_chan *ch;
+
+  ch = (struct fuse_chan*)malloc(sizeof(*ch));
+  if(ch == NULL)
+    {
+      fprintf(stderr, "fuse: failed to allocate channel\n");
+      return NULL;
+    }
+
+  memset(ch, 0, sizeof(*ch));
+
+  ch->fd = fd;
+  ch->bufsize = bufsize;
+
+  return ch;
+}
+
+int fuse_chan_fd(struct fuse_chan *ch)
+{
+  return ch->fd;
+}
+
+int fuse_chan_clearfd(struct fuse_chan *ch)
+{
+  int fd = ch->fd;
+  ch->fd = -1;
+  return fd;
+}
+
+size_t fuse_chan_bufsize(struct fuse_chan *ch)
+{
+  return ch->bufsize;
+}
+
+struct fuse_session *fuse_chan_session(struct fuse_chan *ch)
+{
+  return ch->se;
+}
+
+int
+fuse_chan_recv(struct fuse_chan *ch,
+               char             *buf,
+               size_t            size)
+{
+  int err;
+  ssize_t res;
+  struct fuse_session *se = fuse_chan_session(ch);
+  assert(se != NULL);
+
+ restart:
+  res = read(fuse_chan_fd(ch), buf, size);
+  err = errno;
+
+  if(fuse_session_exited(se))
+    return 0;
+
+  if(res == -1)
+    {
+      /* ENOENT means the operation was interrupted, it's safe
+         to restart */
+      if (err == ENOENT)
+        goto restart;
+
+      if(err == ENODEV)
+        {
+          se->exited = 1;
+          return 0;
+        }
+
+      /* Errors occurring during normal operation: EINTR (read
+         interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
+         umounted) */
+      if(err != EINTR && err != EAGAIN)
+        perror("fuse: reading device");
+      return -err;
+    }
+
+  if((size_t) res < sizeof(struct fuse_in_header))
+    {
+      fprintf(stderr, "short read on fuse device\n");
+      return -EIO;
+    }
+
+  return res;
+}
+
+int
+fuse_chan_send(struct fuse_chan *ch,
+               const struct iovec iov[],
+               size_t count)
+{
+  if(!iov)
+    return 0;
+
+  int err;
+  ssize_t res;
+
+  res = writev(fuse_chan_fd(ch), iov, count);
+  err = errno;
+
+  if(res == -1)
+    {
+      struct fuse_session *se = fuse_chan_session(ch);
+
+      assert(se != NULL);
+
+      /* ENOENT means the operation was interrupted */
+      if(!fuse_session_exited(se) && err != ENOENT)
+        perror("fuse: writing device");
+      return -err;
+    }
+
+  return 0;
+}
+
+void
+fuse_chan_destroy(struct fuse_chan *ch)
+{
+  int fd;
+
+  fuse_session_remove_chan(ch);
+
+  fd = fuse_chan_fd(ch);
+  if(fd != -1)
+    close(fd);
+
+  free(ch);
+}

libfuse/lib/fuse_signals.c

@@ -0,0 +1,71 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
+*/
+
+#include "fuse_lowlevel.h"
+
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+
+static struct fuse_session *fuse_instance;
+
+static void exit_handler(int sig)
+{
+  (void) sig;
+  if (fuse_instance)
+    fuse_session_exit(fuse_instance);
+}
+
+static int set_one_signal_handler(int sig, void (*handler)(int), int remove)
+{
+  struct sigaction sa;
+  struct sigaction old_sa;
+
+  memset(&sa, 0, sizeof(struct sigaction));
+  sa.sa_handler = remove ? SIG_DFL : handler;
+  sigemptyset(&(sa.sa_mask));
+  sa.sa_flags = 0;
+
+  if (sigaction(sig, NULL, &old_sa) == -1) {
+    perror("fuse: cannot get old signal handler");
+    return -1;
+  }
+
+  if (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&
+      sigaction(sig, &sa, NULL) == -1) {
+    perror("fuse: cannot set signal handler");
+    return -1;
+  }
+  return 0;
+}
+
+int fuse_set_signal_handlers(struct fuse_session *se)
+{
+  if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
+      set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
+      set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
+      set_one_signal_handler(SIGPIPE, SIG_IGN, 0) == -1)
+    return -1;
+
+  fuse_instance = se;
+  return 0;
+}
+
+void fuse_remove_signal_handlers(struct fuse_session *se)
+{
+  if (fuse_instance != se)
+    fprintf(stderr,
+            "fuse: fuse_remove_signal_handlers: unknown session\n");
+  else
+    fuse_instance = NULL;
+
+  set_one_signal_handler(SIGHUP, exit_handler, 1);
+  set_one_signal_handler(SIGINT, exit_handler, 1);
+  set_one_signal_handler(SIGTERM, exit_handler, 1);
+  set_one_signal_handler(SIGPIPE, SIG_IGN, 1);
+}

libfuse/lib/helper.c

@@ -0,0 +1,407 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#include "config.h"
+#include "fuse_i.h"
+#include "fuse_misc.h"
+#include "fuse_opt.h"
+#include "fuse_lowlevel.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <unistd.h>
+#include <string.h>
+#include <limits.h>
+#include <errno.h>
+#include <sys/param.h>
+
+enum  {
+  KEY_HELP,
+  KEY_HELP_NOHEADER,
+  KEY_VERSION,
+};
+
+struct helper_opts
+{
+  int foreground;
+  int nodefault_subtype;
+  char *mountpoint;
+};
+
+#define FUSE_HELPER_OPT(t, p) { t, offsetof(struct helper_opts, p), 1 }
+
+static
+const
+struct fuse_opt fuse_helper_opts[] =
+  {
+    FUSE_HELPER_OPT("-f",	foreground),
+    FUSE_HELPER_OPT("fsname=",	nodefault_subtype),
+    FUSE_HELPER_OPT("subtype=",	nodefault_subtype),
+    FUSE_OPT_KEY("-h",		KEY_HELP),
+    FUSE_OPT_KEY("--help",	KEY_HELP),
+    FUSE_OPT_KEY("-ho",		KEY_HELP_NOHEADER),
+    FUSE_OPT_KEY("-V",		KEY_VERSION),
+    FUSE_OPT_KEY("--version",	KEY_VERSION),
+    FUSE_OPT_KEY("-d",		FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_KEY("debug",	FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_KEY("fsname=",	FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_KEY("subtype=",	FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_END
+  };
+
+static void usage(const char *progname)
+{
+  fprintf(stderr,
+          "usage: %s mountpoint [options]\n\n", progname);
+  fprintf(stderr,
+          "general options:\n"
+          "    -o opt,[opt...]        mount options\n"
+          "    -h   --help            print help\n"
+          "    -V   --version         print version\n"
+          "\n");
+}
+
+static void helper_help(void)
+{
+  fprintf(stderr,
+          "FUSE options:\n"
+          "    -d   -o debug          enable debug output (implies -f)\n"
+          "    -f                     foreground operation\n"
+          "\n"
+          );
+}
+
+static void helper_version(void)
+{
+  fprintf(stderr, "FUSE library version: %s\n", PACKAGE_VERSION);
+}
+
+static int fuse_helper_opt_proc(void *data, const char *arg, int key,
+				struct fuse_args *outargs)
+{
+  struct helper_opts *hopts = data;
+
+  switch (key) {
+  case KEY_HELP:
+    usage(outargs->argv[0]);
+    /* fall through */
+
+  case KEY_HELP_NOHEADER:
+    helper_help();
+    return fuse_opt_add_arg(outargs, "-h");
+
+  case KEY_VERSION:
+    helper_version();
+    return 1;
+
+  case FUSE_OPT_KEY_NONOPT:
+    if (!hopts->mountpoint) {
+      char mountpoint[PATH_MAX];
+      if (realpath(arg, mountpoint) == NULL) {
+        fprintf(stderr,
+                "fuse: bad mount point `%s': %s\n",
+                arg, strerror(errno));
+        return -1;
+      }
+      return fuse_opt_add_opt(&hopts->mountpoint, mountpoint);
+    } else {
+      fprintf(stderr, "fuse: invalid argument `%s'\n", arg);
+      return -1;
+    }
+
+  default:
+    return 1;
+  }
+}
+
+static int add_default_subtype(const char *progname, struct fuse_args *args)
+{
+  int res;
+  char *subtype_opt;
+  const char *basename = strrchr(progname, '/');
+  if (basename == NULL)
+    basename = progname;
+  else if (basename[1] != '\0')
+    basename++;
+
+  subtype_opt = (char *) malloc(strlen(basename) + 64);
+  if (subtype_opt == NULL) {
+    fprintf(stderr, "fuse: memory allocation failed\n");
+    return -1;
+  }
+  sprintf(subtype_opt, "-osubtype=%s", basename);
+  res = fuse_opt_add_arg(args, subtype_opt);
+  free(subtype_opt);
+  return res;
+}
+
+int
+fuse_parse_cmdline(struct fuse_args  *args_,
+                   char             **mountpoint_,
+                   int               *foreground_)
+{
+  int res;
+  struct helper_opts hopts;
+
+  memset(&hopts, 0, sizeof(hopts));
+
+  res = fuse_opt_parse(args_,
+                       &hopts,
+                       fuse_helper_opts,
+                       fuse_helper_opt_proc);
+  if(res == -1)
+    return -1;
+
+  if(!hopts.nodefault_subtype)
+    {
+      res = add_default_subtype(args_->argv[0], args_);
+      if(res == -1)
+        goto err;
+    }
+
+  if(mountpoint_)
+    *mountpoint_ = hopts.mountpoint;
+  else
+    free(hopts.mountpoint);
+
+  if(foreground_)
+    *foreground_ = hopts.foreground;
+
+  return 0;
+
+ err:
+  free(hopts.mountpoint);
+  return -1;
+}
+
+int fuse_daemonize(int foreground)
+{
+  if (!foreground) {
+    int nullfd;
+    int waiter[2];
+    char completed;
+
+    if (pipe(waiter)) {
+      perror("fuse_daemonize: pipe");
+      return -1;
+    }
+
+    /*
+     * demonize current process by forking it and killing the
+     * parent.  This makes current process as a child of 'init'.
+     */
+    switch(fork()) {
+    case -1:
+      perror("fuse_daemonize: fork");
+      return -1;
+    case 0:
+      break;
+    default:
+      read(waiter[0], &completed, sizeof(completed));
+      _exit(0);
+    }
+
+    if (setsid() == -1) {
+      perror("fuse_daemonize: setsid");
+      return -1;
+    }
+
+    (void) chdir("/");
+
+    nullfd = open("/dev/null", O_RDWR, 0);
+    if (nullfd != -1) {
+      (void) dup2(nullfd, 0);
+      (void) dup2(nullfd, 1);
+      (void) dup2(nullfd, 2);
+      if (nullfd > 2)
+        close(nullfd);
+    }
+
+    /* Propagate completion of daemon initializatation */
+    completed = 1;
+    write(waiter[1], &completed, sizeof(completed));
+    close(waiter[0]);
+    close(waiter[1]);
+  }
+  return 0;
+}
+
+static
+struct fuse_chan *
+fuse_mount_common(const char       *mountpoint_,
+                  struct fuse_args *args_)
+{
+  int fd;
+  long bufsize;
+  long pagesize;
+  struct fuse_chan *ch;
+
+  /*
+   * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
+   * would ensue.
+   */
+  do
+    {
+      fd = open("/dev/null", O_RDWR);
+      if(fd > 2)
+        close(fd);
+    } while(fd >= 0 && fd <= 2);
+
+  fd = fuse_kern_mount(mountpoint_,args_);
+  if(fd == -1)
+    return NULL;
+
+  pagesize = sysconf(_SC_PAGESIZE);
+  bufsize  = ((FUSE_MAX_MAX_PAGES + 1) * pagesize);
+
+  ch = fuse_chan_new(fd,bufsize);
+  if(!ch)
+    fuse_kern_unmount(mountpoint_, fd);
+
+  return ch;
+}
+
+struct fuse_chan *
+fuse_mount(const char       *mountpoint_,
+           struct fuse_args *args_)
+{
+  return fuse_mount_common(mountpoint_,args_);
+}
+
+static void fuse_unmount_common(const char *mountpoint, struct fuse_chan *ch)
+{
+  if (mountpoint) {
+    int fd = ch ? fuse_chan_clearfd(ch) : -1;
+    fuse_kern_unmount(mountpoint, fd);
+    if (ch)
+      fuse_chan_destroy(ch);
+  }
+}
+
+void fuse_unmount(const char *mountpoint, struct fuse_chan *ch)
+{
+  fuse_unmount_common(mountpoint, ch);
+}
+
+struct fuse *
+fuse_setup_common(int argc,
+                  char *argv[],
+                  const struct fuse_operations *op,
+                  size_t op_size,
+                  char **mountpoint,
+                  int *fd)
+{
+  struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
+  struct fuse_chan *ch;
+  struct fuse *fuse;
+  int foreground;
+  int res;
+
+  res = fuse_parse_cmdline(&args, mountpoint, &foreground);
+  if (res == -1)
+    return NULL;
+
+  ch = fuse_mount_common(*mountpoint, &args);
+  if (!ch) {
+    fuse_opt_free_args(&args);
+    goto err_free;
+  }
+
+  fuse = fuse_new_common(ch, &args, op, op_size);
+  fuse_opt_free_args(&args);
+  if (fuse == NULL)
+    goto err_unmount;
+
+  res = fuse_daemonize(foreground);
+  if (res == -1)
+    goto err_unmount;
+
+  res = fuse_set_signal_handlers(fuse_get_session(fuse));
+  if (res == -1)
+    goto err_unmount;
+
+  if (fd)
+    *fd = fuse_chan_fd(ch);
+
+  return fuse;
+
+ err_unmount:
+  fuse_unmount_common(*mountpoint, ch);
+  if (fuse)
+    fuse_destroy(fuse);
+ err_free:
+  free(*mountpoint);
+  return NULL;
+}
+
+struct fuse *fuse_setup(int argc, char *argv[],
+			const struct fuse_operations *op, size_t op_size,
+			char **mountpoint)
+{
+  return fuse_setup_common(argc, argv, op, op_size, mountpoint,
+                           NULL);
+}
+
+static void fuse_teardown_common(struct fuse *fuse, char *mountpoint)
+{
+  struct fuse_session *se = fuse_get_session(fuse);
+  struct fuse_chan *ch = se->ch;
+  fuse_remove_signal_handlers(se);
+  fuse_unmount_common(mountpoint, ch);
+  fuse_destroy(fuse);
+  free(mountpoint);
+}
+
+void fuse_teardown(struct fuse *fuse, char *mountpoint)
+{
+  fuse_teardown_common(fuse, mountpoint);
+}
+
+static int fuse_main_common(int argc, char *argv[],
+			    const struct fuse_operations *op, size_t op_size)
+{
+  struct fuse *fuse;
+  char *mountpoint;
+  int res;
+
+  fuse = fuse_setup_common(argc, argv, op, op_size,
+                           &mountpoint,
+                           NULL);
+  if (fuse == NULL)
+    return 1;
+
+  res = fuse_loop_mt(fuse);
+
+  fuse_teardown_common(fuse, mountpoint);
+  if (res == -1)
+    return 1;
+
+  return 0;
+}
+
+int fuse_main_real(int argc,
+                   char *argv[],
+                   const struct fuse_operations *op,
+		   size_t op_size)
+{
+  return fuse_main_common(argc, argv, op, op_size);
+}
+
+#undef fuse_main
+int fuse_main(void);
+int fuse_main(void)
+{
+  fprintf(stderr, "fuse_main(): This function does not exist\n");
+  return -1;
+}
+
+int fuse_version(void)
+{
+  return FUSE_VERSION;
+}

libfuse/lib/khash.h

@@ -0,0 +1,627 @@
+/* The MIT License
+
+   Copyright (c) 2008, 2009, 2011 by Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/*
+  An example:
+
+  #include "khash.h"
+  KHASH_MAP_INIT_INT(32, char)
+  int main() {
+  int ret, is_missing;
+  khiter_t k;
+  khash_t(32) *h = kh_init(32);
+  k = kh_put(32, h, 5, &ret);
+  kh_value(h, k) = 10;
+  k = kh_get(32, h, 10);
+  is_missing = (k == kh_end(h));
+  k = kh_get(32, h, 5);
+  kh_del(32, h, k);
+  for (k = kh_begin(h); k != kh_end(h); ++k)
+  if (kh_exist(h, k)) kh_value(h, k) = 1;
+  kh_destroy(32, h);
+  return 0;
+  }
+*/
+
+/*
+  2013-05-02 (0.2.8):
+
+  * Use quadratic probing. When the capacity is power of 2, stepping function
+  i*(i+1)/2 guarantees to traverse each bucket. It is better than double
+  hashing on cache performance and is more robust than linear probing.
+
+  In theory, double hashing should be more robust than quadratic probing.
+  However, my implementation is probably not for large hash tables, because
+  the second hash function is closely tied to the first hash function,
+  which reduce the effectiveness of double hashing.
+
+  Reference: http://research.cs.vt.edu/AVresearch/hashing/quadratic.php
+
+  2011-12-29 (0.2.7):
+
+  * Minor code clean up; no actual effect.
+
+  2011-09-16 (0.2.6):
+
+  * The capacity is a power of 2. This seems to dramatically improve the
+  speed for simple keys. Thank Zilong Tan for the suggestion. Reference:
+
+  - http://code.google.com/p/ulib/
+  - http://nothings.org/computer/judy/
+
+  * Allow to optionally use linear probing which usually has better
+  performance for random input. Double hashing is still the default as it
+  is more robust to certain non-random input.
+
+  * Added Wang's integer hash function (not used by default). This hash
+  function is more robust to certain non-random input.
+
+  2011-02-14 (0.2.5):
+
+  * Allow to declare global functions.
+
+  2009-09-26 (0.2.4):
+
+  * Improve portability
+
+  2008-09-19 (0.2.3):
+
+  * Corrected the example
+  * Improved interfaces
+
+  2008-09-11 (0.2.2):
+
+  * Improved speed a little in kh_put()
+
+  2008-09-10 (0.2.1):
+
+  * Added kh_clear()
+  * Fixed a compiling error
+
+  2008-09-02 (0.2.0):
+
+  * Changed to token concatenation which increases flexibility.
+
+  2008-08-31 (0.1.2):
+
+  * Fixed a bug in kh_get(), which has not been tested previously.
+
+  2008-08-31 (0.1.1):
+
+  * Added destructor
+  */
+
+
+#ifndef __AC_KHASH_H
+#define __AC_KHASH_H
+
+/*!
+  @header
+
+  Generic hash table library.
+*/
+
+#define AC_VERSION_KHASH_H "0.2.8"
+
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+
+/* compiler specific configuration */
+
+#if UINT_MAX == 0xffffffffu
+typedef unsigned int khint32_t;
+#elif ULONG_MAX == 0xffffffffu
+typedef unsigned long khint32_t;
+#endif
+
+#if ULONG_MAX == ULLONG_MAX
+typedef unsigned long khint64_t;
+#else
+typedef unsigned long long khint64_t;
+#endif
+
+#ifndef kh_inline
+#ifdef _MSC_VER
+#define kh_inline __inline
+#else
+#define kh_inline inline
+#endif
+#endif /* kh_inline */
+
+#ifndef klib_unused
+#if (defined __clang__ && __clang_major__ >= 3) || (defined __GNUC__ && __GNUC__ >= 3)
+#define klib_unused __attribute__ ((__unused__))
+#else
+#define klib_unused
+#endif
+#endif /* klib_unused */
+
+typedef khint32_t khint_t;
+typedef khint_t khiter_t;
+
+#define __ac_isempty(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&2)
+#define __ac_isdel(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&1)
+#define __ac_iseither(flag, i) ((flag[i>>4]>>((i&0xfU)<<1))&3)
+#define __ac_set_isdel_false(flag, i) (flag[i>>4]&=~(1ul<<((i&0xfU)<<1)))
+#define __ac_set_isempty_false(flag, i) (flag[i>>4]&=~(2ul<<((i&0xfU)<<1)))
+#define __ac_set_isboth_false(flag, i) (flag[i>>4]&=~(3ul<<((i&0xfU)<<1)))
+#define __ac_set_isdel_true(flag, i) (flag[i>>4]|=1ul<<((i&0xfU)<<1))
+
+#define __ac_fsize(m) ((m) < 16? 1 : (m)>>4)
+
+#ifndef kroundup32
+#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#endif
+
+#ifndef kcalloc
+#define kcalloc(N,Z) calloc(N,Z)
+#endif
+#ifndef kmalloc
+#define kmalloc(Z) malloc(Z)
+#endif
+#ifndef krealloc
+#define krealloc(P,Z) realloc(P,Z)
+#endif
+#ifndef kfree
+#define kfree(P) free(P)
+#endif
+
+static const double __ac_HASH_UPPER = 0.77;
+
+#define __KHASH_TYPE(name, khkey_t, khval_t)            \
+  typedef struct kh_##name##_s {                        \
+    khint_t n_buckets, size, n_occupied, upper_bound;   \
+    khint32_t *flags;                                   \
+    khkey_t *keys;                                      \
+    khval_t *vals;                                      \
+  } kh_##name##_t;
+
+#define __KHASH_PROTOTYPES(name, khkey_t, khval_t)                      \
+  extern kh_##name##_t *kh_init_##name(void);                           \
+  extern void kh_destroy_##name(kh_##name##_t *h);                      \
+  extern void kh_clear_##name(kh_##name##_t *h);                        \
+  extern khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key); 	\
+  extern int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets); \
+  extern khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret); \
+  extern void kh_del_##name(kh_##name##_t *h, khint_t x);
+
+#define __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+  SCOPE kh_##name##_t *kh_init_##name(void) {                           \
+    return (kh_##name##_t*)kcalloc(1, sizeof(kh_##name##_t));		\
+  }                                                                     \
+  SCOPE void kh_destroy_##name(kh_##name##_t *h)                        \
+  {                                                                     \
+    if (h) {                                                            \
+      kfree((void *)h->keys); kfree(h->flags);                          \
+      kfree((void *)h->vals);                                           \
+      kfree(h);                                                         \
+    }                                                                   \
+  }                                                                     \
+  SCOPE void kh_clear_##name(kh_##name##_t *h)                          \
+  {                                                                     \
+    if (h && h->flags) {                                                \
+      memset(h->flags, 0xaa, __ac_fsize(h->n_buckets) * sizeof(khint32_t)); \
+      h->size = h->n_occupied = 0;                                      \
+    }                                                                   \
+  }                                                                     \
+  SCOPE khint_t kh_get_##name(const kh_##name##_t *h, khkey_t key) 	\
+  {                                                                     \
+    if (h->n_buckets) {                                                 \
+      khint_t k, i, last, mask, step = 0;                               \
+      mask = h->n_buckets - 1;                                          \
+      k = __hash_func(key); i = k & mask;                               \
+      last = i;                                                         \
+      while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
+        i = (i + (++step)) & mask;                                      \
+        if (i == last) return h->n_buckets;                             \
+      }                                                                 \
+      return __ac_iseither(h->flags, i)? h->n_buckets : i;		\
+    } else return 0;                                                    \
+  }                                                                     \
+  SCOPE int kh_resize_##name(kh_##name##_t *h, khint_t new_n_buckets)   \
+  { /* This function uses 0.25*n_buckets bytes of working space instead of [sizeof(key_t+val_t)+.25]*n_buckets. */ \
+    khint32_t *new_flags = 0;                                           \
+    khint_t j = 1;                                                      \
+    {                                                                   \
+      kroundup32(new_n_buckets);                                        \
+      if (new_n_buckets < 4) new_n_buckets = 4;                         \
+      if (h->size >= (khint_t)(new_n_buckets * __ac_HASH_UPPER + 0.5)) j = 0;	/* requested size is too small */ \
+      else { /* hash table size to be changed (shrink or expand); rehash */ \
+        new_flags = (khint32_t*)kmalloc(__ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
+        if (!new_flags) return -1;                                      \
+        memset(new_flags, 0xaa, __ac_fsize(new_n_buckets) * sizeof(khint32_t)); \
+        if (h->n_buckets < new_n_buckets) {	/* expand */		\
+          khkey_t *new_keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
+          if (!new_keys) { kfree(new_flags); return -1; }		\
+          h->keys = new_keys;                                           \
+          if (kh_is_map) {                                              \
+            khval_t *new_vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
+            if (!new_vals) { kfree(new_flags); return -1; }             \
+            h->vals = new_vals;                                         \
+          }                                                             \
+        } /* otherwise shrink */                                        \
+      }                                                                 \
+    }                                                                   \
+    if (j) { /* rehashing is needed */                                  \
+      for (j = 0; j != h->n_buckets; ++j) {                             \
+        if (__ac_iseither(h->flags, j) == 0) {                          \
+          khkey_t key = h->keys[j];                                     \
+          khval_t val;                                                  \
+          khint_t new_mask;                                             \
+          new_mask = new_n_buckets - 1;                                 \
+          if (kh_is_map) val = h->vals[j];                              \
+          __ac_set_isdel_true(h->flags, j);                             \
+          while (1) { /* kick-out process; sort of like in Cuckoo hashing */ \
+            khint_t k, i, step = 0;                                     \
+            k = __hash_func(key);                                       \
+            i = k & new_mask;                                           \
+            while (!__ac_isempty(new_flags, i)) i = (i + (++step)) & new_mask; \
+            __ac_set_isempty_false(new_flags, i);			\
+            if (i < h->n_buckets && __ac_iseither(h->flags, i) == 0) { /* kick out the existing element */ \
+              { khkey_t tmp = h->keys[i]; h->keys[i] = key; key = tmp; } \
+              if (kh_is_map) { khval_t tmp = h->vals[i]; h->vals[i] = val; val = tmp; } \
+              __ac_set_isdel_true(h->flags, i); /* mark it as deleted in the old hash table */ \
+            } else { /* write the element and jump out of the loop */   \
+              h->keys[i] = key;                                         \
+              if (kh_is_map) h->vals[i] = val;                          \
+              break;                                                    \
+            }                                                           \
+          }                                                             \
+        }                                                               \
+      }                                                                 \
+      if (h->n_buckets > new_n_buckets) { /* shrink the hash table */   \
+        h->keys = (khkey_t*)krealloc((void *)h->keys, new_n_buckets * sizeof(khkey_t)); \
+        if (kh_is_map) h->vals = (khval_t*)krealloc((void *)h->vals, new_n_buckets * sizeof(khval_t)); \
+      }                                                                 \
+      kfree(h->flags); /* free the working space */                     \
+      h->flags = new_flags;                                             \
+      h->n_buckets = new_n_buckets;                                     \
+      h->n_occupied = h->size;                                          \
+      h->upper_bound = (khint_t)(h->n_buckets * __ac_HASH_UPPER + 0.5); \
+    }                                                                   \
+    return 0;                                                           \
+  }                                                                     \
+  SCOPE khint_t kh_put_##name(kh_##name##_t *h, khkey_t key, int *ret)  \
+  {                                                                     \
+    khint_t x;                                                          \
+    if (h->n_occupied >= h->upper_bound) { /* update the hash table */  \
+      if (h->n_buckets > (h->size<<1)) {                                \
+        if (kh_resize_##name(h, h->n_buckets - 1) < 0) { /* clear "deleted" elements */ \
+          *ret = -1; return h->n_buckets;                               \
+        }                                                               \
+      } else if (kh_resize_##name(h, h->n_buckets + 1) < 0) { /* expand the hash table */ \
+        *ret = -1; return h->n_buckets;                                 \
+      }                                                                 \
+    } /* TODO: to implement automatically shrinking; resize() already support shrinking */ \
+    {                                                                   \
+      khint_t k, i, site, last, mask = h->n_buckets - 1, step = 0;      \
+      x = site = h->n_buckets; k = __hash_func(key); i = k & mask;      \
+      if (__ac_isempty(h->flags, i)) x = i; /* for speed up */          \
+      else {                                                            \
+        last = i;                                                       \
+        while (!__ac_isempty(h->flags, i) && (__ac_isdel(h->flags, i) || !__hash_equal(h->keys[i], key))) { \
+          if (__ac_isdel(h->flags, i)) site = i;                        \
+          i = (i + (++step)) & mask;                                    \
+          if (i == last) { x = site; break; }                           \
+        }                                                               \
+        if (x == h->n_buckets) {                                        \
+          if (__ac_isempty(h->flags, i) && site != h->n_buckets) x = site; \
+          else x = i;                                                   \
+        }                                                               \
+      }                                                                 \
+    }                                                                   \
+    if (__ac_isempty(h->flags, x)) { /* not present at all */		\
+      h->keys[x] = key;                                                 \
+      __ac_set_isboth_false(h->flags, x);                               \
+      ++h->size; ++h->n_occupied;                                       \
+      *ret = 1;                                                         \
+    } else if (__ac_isdel(h->flags, x)) { /* deleted */                 \
+      h->keys[x] = key;                                                 \
+      __ac_set_isboth_false(h->flags, x);                               \
+      ++h->size;                                                        \
+      *ret = 2;                                                         \
+    } else *ret = 0; /* Don't touch h->keys[x] if present and not deleted */ \
+    return x;                                                           \
+  }                                                                     \
+  SCOPE void kh_del_##name(kh_##name##_t *h, khint_t x)                 \
+  {                                                                     \
+    if (x != h->n_buckets && !__ac_iseither(h->flags, x)) {             \
+      __ac_set_isdel_true(h->flags, x);                                 \
+      --h->size;                                                        \
+    }                                                                   \
+  }
+
+#define KHASH_DECLARE(name, khkey_t, khval_t)   \
+  __KHASH_TYPE(name, khkey_t, khval_t)          \
+  __KHASH_PROTOTYPES(name, khkey_t, khval_t)
+
+#define KHASH_INIT2(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+  __KHASH_TYPE(name, khkey_t, khval_t)                                  \
+  __KHASH_IMPL(name, SCOPE, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
+
+#define KHASH_INIT(name, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal) \
+  KHASH_INIT2(name, static kh_inline klib_unused, khkey_t, khval_t, kh_is_map, __hash_func, __hash_equal)
+
+/* --- BEGIN OF HASH FUNCTIONS --- */
+
+/*! @function
+  @abstract     Integer hash function
+  @param  key   The integer [khint32_t]
+  @return       The hash value [khint_t]
+*/
+#define kh_int_hash_func(key) (khint32_t)(key)
+/*! @function
+  @abstract     Integer comparison function
+*/
+#define kh_int_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     64-bit integer hash function
+  @param  key   The integer [khint64_t]
+  @return       The hash value [khint_t]
+*/
+#define kh_int64_hash_func(key) (khint32_t)((key)>>33^(key)^(key)<<11)
+/*! @function
+  @abstract     64-bit integer comparison function
+*/
+#define kh_int64_hash_equal(a, b) ((a) == (b))
+/*! @function
+  @abstract     const char* hash function
+  @param  s     Pointer to a null terminated string
+  @return       The hash value
+*/
+static kh_inline khint_t __ac_X31_hash_string(const char *s)
+{
+  khint_t h = (khint_t)*s;
+  if (h) for (++s ; *s; ++s) h = (h << 5) - h + (khint_t)*s;
+  return h;
+}
+/*! @function
+  @abstract     Another interface to const char* hash function
+  @param  key   Pointer to a null terminated string [const char*]
+  @return       The hash value [khint_t]
+*/
+#define kh_str_hash_func(key) __ac_X31_hash_string(key)
+/*! @function
+  @abstract     Const char* comparison function
+*/
+#define kh_str_hash_equal(a, b) (strcmp(a, b) == 0)
+
+static kh_inline khint_t __ac_Wang_hash(khint_t key)
+{
+  key += ~(key << 15);
+  key ^=  (key >> 10);
+  key +=  (key << 3);
+  key ^=  (key >> 6);
+  key += ~(key << 11);
+  key ^=  (key >> 16);
+  return key;
+}
+#define kh_int_hash_func2(key) __ac_Wang_hash((khint_t)key)
+
+/* --- END OF HASH FUNCTIONS --- */
+
+/* Other convenient macros... */
+
+/*!
+  @abstract Type of the hash table.
+  @param  name  Name of the hash table [symbol]
+*/
+#define khash_t(name) kh_##name##_t
+
+/*! @function
+  @abstract     Initiate a hash table.
+  @param  name  Name of the hash table [symbol]
+  @return       Pointer to the hash table [khash_t(name)*]
+*/
+#define kh_init(name) kh_init_##name()
+
+/*! @function
+  @abstract     Destroy a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+*/
+#define kh_destroy(name, h) kh_destroy_##name(h)
+
+/*! @function
+  @abstract     Reset a hash table without deallocating memory.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+*/
+#define kh_clear(name, h) kh_clear_##name(h)
+
+/*! @function
+  @abstract     Resize a hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  s     New size [khint_t]
+*/
+#define kh_resize(name, h, s) kh_resize_##name(h, s)
+
+/*! @function
+  @abstract     Insert a key to the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @param  r     Extra return code: -1 if the operation failed;
+  0 if the key is present in the hash table;
+  1 if the bucket is empty (never used); 2 if the element in
+  the bucket has been deleted [int*]
+  @return       Iterator to the inserted element [khint_t]
+*/
+#define kh_put(name, h, k, r) kh_put_##name(h, k, r)
+
+/*! @function
+  @abstract     Retrieve a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Key [type of keys]
+  @return       Iterator to the found element, or kh_end(h) if the element is absent [khint_t]
+*/
+#define kh_get(name, h, k) kh_get_##name(h, k)
+
+/*! @function
+  @abstract     Remove a key from the hash table.
+  @param  name  Name of the hash table [symbol]
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  k     Iterator to the element to be deleted [khint_t]
+*/
+#define kh_del(name, h, k) kh_del_##name(h, k)
+
+/*! @function
+  @abstract     Test whether a bucket contains data.
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       1 if containing data; 0 otherwise [int]
+*/
+#define kh_exist(h, x) (!__ac_iseither((h)->flags, (x)))
+
+/*! @function
+  @abstract     Get key given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Key [type of keys]
+*/
+#define kh_key(h, x) ((h)->keys[x])
+
+/*! @function
+  @abstract     Get value given an iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  x     Iterator to the bucket [khint_t]
+  @return       Value [type of values]
+  @discussion   For hash sets, calling this results in segfault.
+*/
+#define kh_val(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Alias of kh_val()
+*/
+#define kh_value(h, x) ((h)->vals[x])
+
+/*! @function
+  @abstract     Get the start iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The start iterator [khint_t]
+*/
+#define kh_begin(h) (khint_t)(0)
+
+/*! @function
+  @abstract     Get the end iterator
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       The end iterator [khint_t]
+*/
+#define kh_end(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Get the number of elements in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of elements in the hash table [khint_t]
+*/
+#define kh_size(h) ((h)->size)
+
+/*! @function
+  @abstract     Get the number of buckets in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @return       Number of buckets in the hash table [khint_t]
+*/
+#define kh_n_buckets(h) ((h)->n_buckets)
+
+/*! @function
+  @abstract     Iterate over the entries in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  kvar  Variable to which key will be assigned
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+*/
+#define kh_foreach(h, kvar, vvar, code) { khint_t __i;  \
+    for (__i = kh_begin(h); __i != kh_end(h); ++__i) {  \
+      if (!kh_exist(h,__i)) continue;                   \
+      (kvar) = kh_key(h,__i);                           \
+      (vvar) = kh_val(h,__i);                           \
+      code;                                             \
+    } }
+
+/*! @function
+  @abstract     Iterate over the values in the hash table
+  @param  h     Pointer to the hash table [khash_t(name)*]
+  @param  vvar  Variable to which value will be assigned
+  @param  code  Block of code to execute
+*/
+#define kh_foreach_value(h, vvar, code) { khint_t __i;  \
+    for (__i = kh_begin(h); __i != kh_end(h); ++__i) {  \
+      if (!kh_exist(h,__i)) continue;                   \
+      (vvar) = kh_val(h,__i);                           \
+      code;                                             \
+    } }
+
+/* More convenient interfaces */
+
+/*! @function
+  @abstract     Instantiate a hash set containing integer keys
+  @param  name  Name of the hash table [symbol]
+*/
+#define KHASH_SET_INIT_INT(name)                                        \
+  KHASH_INIT(name, khint32_t, char, 0, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+*/
+#define KHASH_MAP_INIT_INT(name, khval_t)                               \
+  KHASH_INIT(name, khint32_t, khval_t, 1, kh_int_hash_func, kh_int_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash set containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+*/
+#define KHASH_SET_INIT_INT64(name)                                      \
+  KHASH_INIT(name, khint64_t, char, 0, kh_int64_hash_func, kh_int64_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing 64-bit integer keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+*/
+#define KHASH_MAP_INIT_INT64(name, khval_t)                             \
+  KHASH_INIT(name, khint64_t, khval_t, 1, kh_int64_hash_func, kh_int64_hash_equal)
+
+typedef const char *kh_cstr_t;
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+*/
+#define KHASH_SET_INIT_STR(name)                                        \
+  KHASH_INIT(name, kh_cstr_t, char, 0, kh_str_hash_func, kh_str_hash_equal)
+
+/*! @function
+  @abstract     Instantiate a hash map containing const char* keys
+  @param  name  Name of the hash table [symbol]
+  @param  khval_t  Type of values [type]
+*/
+#define KHASH_MAP_INIT_STR(name, khval_t)                               \
+  KHASH_INIT(name, kh_cstr_t, khval_t, 1, kh_str_hash_func, kh_str_hash_equal)
+
+#endif /* __AC_KHASH_H */

libfuse/lib/lfmp.h

@@ -0,0 +1,243 @@
+/*
+  ISC License
+
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "fmp.h"
+
+#include <pthread.h>
+
+
+typedef struct lfmp_t lfmp_t;
+struct lfmp_t
+{
+  fmp_t fmp;
+  pthread_mutex_t lock;
+};
+
+
+static
+inline
+void
+lfmp_init(lfmp_t         *lfmp_,
+          const uint64_t  obj_size_,
+          const uint64_t  page_multiple_)
+{
+  fmp_init(&lfmp_->fmp,obj_size_,page_multiple_);
+  pthread_mutex_init(&lfmp_->lock,NULL);
+}
+
+static
+inline
+void
+lfmp_lock(lfmp_t *lfmp_)
+{
+  pthread_mutex_lock(&lfmp_->lock);
+}
+
+static
+inline
+void
+lfmp_unlock(lfmp_t *lfmp_)
+{
+  pthread_mutex_unlock(&lfmp_->lock);
+}
+
+static
+inline
+uint64_t
+lfmp_slab_count(lfmp_t *lfmp_)
+{
+  uint64_t rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_slab_count(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+int
+lfmp_slab_alloc(lfmp_t *lfmp_)
+{
+  int rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_slab_alloc(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+void*
+lfmp_alloc(lfmp_t *lfmp_)
+{
+  void *rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_alloc(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+void*
+lfmp_calloc(lfmp_t *lfmp_)
+{
+  void *rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_calloc(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+void
+lfmp_free(lfmp_t *lfmp_,
+          void   *obj_)
+{
+  pthread_mutex_lock(&lfmp_->lock);
+  fmp_free(&lfmp_->fmp,obj_);
+  pthread_mutex_unlock(&lfmp_->lock);
+}
+
+static
+inline
+void
+lfmp_clear(lfmp_t *lfmp_)
+{
+  pthread_mutex_lock(&lfmp_->lock);
+  fmp_clear(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+}
+
+static
+inline
+void
+lfmp_destroy(lfmp_t *lfmp_)
+{
+  pthread_mutex_lock(&lfmp_->lock);
+  fmp_destroy(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+  pthread_mutex_destroy(&lfmp_->lock);
+}
+
+static
+inline
+uint64_t
+lfmp_avail_objs(lfmp_t *lfmp_)
+{
+  uint64_t rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_avail_objs(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+uint64_t
+lfmp_objs_in_slab(lfmp_t *lfmp_,
+                  void   *slab_)
+{
+  uint64_t rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_objs_in_slab(&lfmp_->fmp,slab_);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+void
+lfmp_remove_objs_in_slab(lfmp_t *lfmp_,
+                         void   *slab_)
+{
+  pthread_mutex_lock(&lfmp_->lock);
+  fmp_remove_objs_in_slab(&lfmp_->fmp,slab_);
+  pthread_mutex_unlock(&lfmp_->lock);
+}
+
+static
+inline
+int
+lfmp_gc(lfmp_t *lfmp_)
+{
+  int rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_gc(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+uint64_t
+lfmp_objs_per_slab(lfmp_t *lfmp_)
+{
+  uint64_t rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_objs_per_slab(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+double
+lfmp_slab_usage_ratio(lfmp_t *lfmp_)
+{
+  double rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_slab_usage_ratio(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}
+
+static
+inline
+uint64_t
+lfmp_total_allocated_memory(lfmp_t *lfmp_)
+{
+  uint64_t rv;
+
+  pthread_mutex_lock(&lfmp_->lock);
+  rv = fmp_total_allocated_memory(&lfmp_->fmp);
+  pthread_mutex_unlock(&lfmp_->lock);
+
+  return rv;
+}

libfuse/lib/mount.c

@@ -0,0 +1,24 @@
+/*
+  ISC License
+
+  Copyright (c) 2019, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#if defined __FreeBSD__ || __NetBSD__ || __OpenBSD__ || __DragonFly__
+# include "mount_bsd.c"
+#else
+# include "mount_generic.c"
+# include "mount_util.c"
+#endif

libfuse/lib/mount_bsd.c

@@ -0,0 +1,325 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2005-2008 Csaba Henk <csaba.henk@creo.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#include "fuse_i.h"
+#include "fuse_misc.h"
+#include "fuse_opt.h"
+
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/sysctl.h>
+#include <sys/user.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <paths.h>
+#include <limits.h>
+
+#define FUSERMOUNT_PROG		"mount_fusefs"
+#define FUSE_DEV_TRUNK		"/dev/fuse"
+
+enum {
+  KEY_RO,
+  KEY_HELP,
+  KEY_VERSION,
+  KEY_KERN
+};
+
+struct mount_opts {
+  int allow_other;
+  int ishelp;
+  char *kernel_opts;
+};
+
+#define FUSE_DUAL_OPT_KEY(templ, key) 				\
+  FUSE_OPT_KEY(templ, key), FUSE_OPT_KEY("no" templ, key)
+
+static const struct fuse_opt fuse_mount_opts[] = {
+  { "allow_other", offsetof(struct mount_opts, allow_other), 1 },
+  FUSE_OPT_KEY("-r",			KEY_RO),
+  FUSE_OPT_KEY("-h",			KEY_HELP),
+  FUSE_OPT_KEY("--help",			KEY_HELP),
+  FUSE_OPT_KEY("-V",			KEY_VERSION),
+  FUSE_OPT_KEY("--version",		KEY_VERSION),
+  /* standard FreeBSD mount options */
+  FUSE_DUAL_OPT_KEY("dev",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("async",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("atime",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("dev",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("exec",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("suid",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("symfollow",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("rdonly",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("sync",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("union",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("userquota",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("groupquota",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("clusterr",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("clusterw",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("suiddir",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("snapshot",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("multilabel",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("acls",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("force",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("update",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("ro",			KEY_KERN),
+  FUSE_DUAL_OPT_KEY("rw",			KEY_KERN),
+  FUSE_DUAL_OPT_KEY("auto",		KEY_KERN),
+  /* options supported under both Linux and FBSD */
+  FUSE_DUAL_OPT_KEY("allow_other",	KEY_KERN),
+  FUSE_DUAL_OPT_KEY("default_permissions",KEY_KERN),
+  FUSE_OPT_KEY("max_read=",		KEY_KERN),
+  FUSE_OPT_KEY("subtype=",		KEY_KERN),
+  /* FBSD FUSE specific mount options */
+  FUSE_DUAL_OPT_KEY("private",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("neglect_shares",	KEY_KERN),
+  FUSE_DUAL_OPT_KEY("push_symlinks_in",	KEY_KERN),
+  FUSE_OPT_KEY("nosync_unmount",		KEY_KERN),
+  /* stock FBSD mountopt parsing routine lets anything be negated... */
+  /*
+   * Linux specific mount options, but let just the mount util
+   * handle them
+   */
+  FUSE_OPT_KEY("fsname=",			KEY_KERN),
+  FUSE_OPT_KEY("nonempty",		KEY_KERN),
+  FUSE_OPT_KEY("large_read",		KEY_KERN),
+  FUSE_OPT_END
+};
+
+static void mount_help(void)
+{
+  system(FUSERMOUNT_PROG " --help");
+  fputc('\n', stderr);
+}
+
+static void mount_version(void)
+{
+  system(FUSERMOUNT_PROG " --version");
+}
+
+static int fuse_mount_opt_proc(void *data, const char *arg, int key,
+			       struct fuse_args *outargs)
+{
+  struct mount_opts *mo = data;
+
+  switch (key) {
+  case KEY_RO:
+    arg = "ro";
+    /* fall through */
+
+  case KEY_KERN:
+    return fuse_opt_add_opt(&mo->kernel_opts, arg);
+
+  case KEY_HELP:
+    mount_help();
+    mo->ishelp = 1;
+    break;
+
+  case KEY_VERSION:
+    mount_version();
+    mo->ishelp = 1;
+    break;
+  }
+  return 1;
+}
+
+static void do_unmount(char *dev, int fd)
+{
+  char device_path[SPECNAMELEN + 12];
+  const char *argv[4];
+  const char umount_cmd[] = "/sbin/umount";
+  pid_t pid;
+
+  snprintf(device_path, SPECNAMELEN + 12, _PATH_DEV "%s", dev);
+
+  argv[0] = umount_cmd;
+  argv[1] = "-f";
+  argv[2] = device_path;
+  argv[3] = NULL;
+
+  pid = fork();
+
+  if (pid == -1)
+    return;
+
+  if (pid == 0) {
+    close(fd);
+    execvp(umount_cmd, (char **)argv);
+    exit(1);
+  }
+
+  waitpid(pid, NULL, 0);
+}
+
+void fuse_kern_unmount(const char *mountpoint, int fd)
+{
+  char *ep, dev[128];
+  struct stat sbuf;
+
+  (void)mountpoint;
+
+  if (fstat(fd, &sbuf) == -1)
+    goto out;
+
+  devname_r(sbuf.st_rdev, S_IFCHR, dev, 128);
+
+  if (strncmp(dev, "fuse", 4))
+    goto out;
+
+  strtol(dev + 4, &ep, 10);
+  if (*ep != '\0')
+    goto out;
+
+  do_unmount(dev, fd);
+
+ out:
+  close(fd);
+}
+
+/* Check if kernel is doing init in background */
+static int init_backgrounded(void)
+{
+  unsigned ibg, len;
+
+  len = sizeof(ibg);
+
+  if (sysctlbyname("vfs.fuse.init_backgrounded", &ibg, &len, NULL, 0))
+    return 0;
+
+  return ibg;
+}
+
+
+static int fuse_mount_core(const char *mountpoint, const char *opts)
+{
+  const char *mountprog = FUSERMOUNT_PROG;
+  int fd;
+  char *fdnam, *dev;
+  pid_t pid, cpid;
+  int status;
+
+  fdnam = getenv("FUSE_DEV_FD");
+
+  if (fdnam) {
+    char *ep;
+
+    fd = strtol(fdnam, &ep, 10);
+
+    if (*ep != '\0') {
+      fprintf(stderr, "invalid value given in FUSE_DEV_FD\n");
+      return -1;
+    }
+
+    if (fd < 0)
+      return -1;
+
+    goto mount;
+  }
+
+  dev = getenv("FUSE_DEV_NAME");
+
+  if (! dev)
+    dev = (char *)FUSE_DEV_TRUNK;
+
+  if ((fd = open(dev, O_RDWR)) < 0) {
+    perror("fuse: failed to open fuse device");
+    return -1;
+  }
+
+ mount:
+  if (getenv("FUSE_NO_MOUNT") || ! mountpoint)
+    goto out;
+
+  pid = fork();
+  cpid = pid;
+
+  if (pid == -1) {
+    perror("fuse: fork() failed");
+    close(fd);
+    return -1;
+  }
+
+  if (pid == 0) {
+    if (! init_backgrounded()) {
+      /*
+       * If init is not backgrounded, we have to
+       * call the mount util backgrounded, to avoid
+       * deadlock.
+       */
+
+      pid = fork();
+
+      if (pid == -1) {
+        perror("fuse: fork() failed");
+        close(fd);
+        exit(1);
+      }
+    }
+
+    if (pid == 0) {
+      const char *argv[32];
+      int a = 0;
+
+      if (! fdnam && asprintf(&fdnam, "%d", fd) == -1) {
+        perror("fuse: failed to assemble mount arguments");
+        exit(1);
+      }
+
+      argv[a++] = mountprog;
+      if (opts) {
+        argv[a++] = "-o";
+        argv[a++] = opts;
+      }
+      argv[a++] = fdnam;
+      argv[a++] = mountpoint;
+      argv[a++] = NULL;
+      execvp(mountprog, (char **) argv);
+      perror("fuse: failed to exec mount program");
+      exit(1);
+    }
+
+    exit(0);
+  }
+
+  if (waitpid(cpid, &status, 0) == -1 || WEXITSTATUS(status) != 0) {
+    perror("fuse: failed to mount file system");
+    close(fd);
+    return -1;
+  }
+
+ out:
+  return fd;
+}
+
+int fuse_kern_mount(const char *mountpoint, struct fuse_args *args)
+{
+  struct mount_opts mo;
+  int res = -1;
+
+  memset(&mo, 0, sizeof(mo));
+  /* mount util should not try to spawn the daemon */
+  setenv("MOUNT_FUSEFS_SAFE", "1", 1);
+  /* to notify the mount util it's called from lib */
+  setenv("MOUNT_FUSEFS_CALL_BY_LIB", "1", 1);
+
+  if (args &&
+      fuse_opt_parse(args, &mo, fuse_mount_opts, fuse_mount_opt_proc) == -1)
+    return -1;
+
+  if (mo.ishelp)
+    return 0;
+
+  res = fuse_mount_core(mountpoint, mo.kernel_opts);
+ out:
+  free(mo.kernel_opts);
+  return res;
+}

libfuse/lib/mount_generic.c

@@ -0,0 +1,613 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#include "config.h"
+#include "fuse_i.h"
+#include "fuse_misc.h"
+#include "fuse_opt.h"
+#include "mount_util.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <stddef.h>
+#include <string.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/poll.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sys/wait.h>
+#include <sys/mount.h>
+
+#ifdef __NetBSD__
+#include <perfuse.h>
+
+#define MS_RDONLY 	MNT_RDONLY
+#define MS_NOSUID 	MNT_NOSUID
+#define MS_NODEV 	MNT_NODEV
+#define MS_NOEXEC 	MNT_NOEXEC
+#define MS_SYNCHRONOUS 	MNT_SYNCHRONOUS
+#define MS_NOATIME 	MNT_NOATIME
+
+#define umount2(mnt, flags) unmount(mnt, (flags == 2) ? MNT_FORCE : 0)
+#endif
+
+#define FUSERMOUNT_PROG		"fusermount"
+#define FUSE_COMMFD_ENV		"_FUSE_COMMFD"
+
+#ifndef HAVE_FORK
+#define fork() vfork()
+#endif
+
+#ifndef MS_DIRSYNC
+#define MS_DIRSYNC 128
+#endif
+
+enum {
+  KEY_KERN_FLAG,
+  KEY_KERN_OPT,
+  KEY_FUSERMOUNT_OPT,
+  KEY_SUBTYPE_OPT,
+  KEY_MTAB_OPT,
+  KEY_RO,
+  KEY_HELP,
+  KEY_VERSION,
+};
+
+struct mount_opts {
+  int allow_other;
+  int ishelp;
+  int flags;
+  int nonempty;
+  int auto_unmount;
+  int blkdev;
+  char *fsname;
+  char *subtype;
+  char *subtype_opt;
+  char *mtab_opts;
+  char *fusermount_opts;
+  char *kernel_opts;
+};
+
+#define FUSE_MOUNT_OPT(t, p) { t, offsetof(struct mount_opts, p), 1 }
+
+static const struct fuse_opt fuse_mount_opts[] = {
+  FUSE_MOUNT_OPT("allow_other",		allow_other),
+  FUSE_MOUNT_OPT("nonempty",		nonempty),
+  FUSE_MOUNT_OPT("blkdev",		blkdev),
+  FUSE_MOUNT_OPT("auto_unmount",		auto_unmount),
+  FUSE_MOUNT_OPT("fsname=%s",		fsname),
+  FUSE_MOUNT_OPT("subtype=%s",		subtype),
+  FUSE_OPT_KEY("allow_other",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("nonempty",		KEY_FUSERMOUNT_OPT),
+  FUSE_OPT_KEY("auto_unmount",		KEY_FUSERMOUNT_OPT),
+  FUSE_OPT_KEY("blkdev",			KEY_FUSERMOUNT_OPT),
+  FUSE_OPT_KEY("fsname=",			KEY_FUSERMOUNT_OPT),
+  FUSE_OPT_KEY("subtype=",		KEY_SUBTYPE_OPT),
+  FUSE_OPT_KEY("large_read",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("blksize=",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("default_permissions",	KEY_KERN_OPT),
+  FUSE_OPT_KEY("context=",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("fscontext=",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("defcontext=",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("rootcontext=",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("max_read=",		KEY_KERN_OPT),
+  FUSE_OPT_KEY("max_read=",		FUSE_OPT_KEY_KEEP),
+  FUSE_OPT_KEY("user=",			KEY_MTAB_OPT),
+  FUSE_OPT_KEY("-r",			KEY_RO),
+  FUSE_OPT_KEY("ro",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("rw",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("suid",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("nosuid",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("dev",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("nodev",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("exec",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("noexec",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("async",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("sync",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("dirsync",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("atime",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("noatime",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("-h",			KEY_HELP),
+  FUSE_OPT_KEY("--help",			KEY_HELP),
+  FUSE_OPT_KEY("-V",			KEY_VERSION),
+  FUSE_OPT_KEY("--version",		KEY_VERSION),
+  FUSE_OPT_END
+};
+
+static void mount_help(void)
+{
+  fprintf(stderr,
+          "    -o allow_other         allow access to other users\n"
+          "    -o auto_unmount        auto unmount on process termination\n"
+          "    -o nonempty            allow mounts over non-empty file/dir\n"
+          "    -o default_permissions enable permission checking by kernel\n"
+          "    -o fsname=NAME         set filesystem name\n"
+          "    -o subtype=NAME        set filesystem type\n"
+          "    -o large_read          issue large read requests (2.4 only)\n"
+          "    -o max_read=N          set maximum size of read requests\n"
+          "\n");
+}
+
+static void exec_fusermount(const char *argv[])
+{
+  execv(FUSERMOUNT_DIR "/mergerfs-" FUSERMOUNT_PROG, (char **) argv);
+  execvp("mergerfs-" FUSERMOUNT_PROG, (char **) argv);
+  execv(FUSERMOUNT_DIR "/" FUSERMOUNT_PROG, (char **) argv);
+  execvp(FUSERMOUNT_PROG, (char **) argv);
+}
+
+static void mount_version(void)
+{
+  int pid = fork();
+  if (!pid) {
+    const char *argv[] = { FUSERMOUNT_PROG, "--version", NULL };
+    exec_fusermount(argv);
+    _exit(1);
+  } else if (pid != -1)
+    waitpid(pid, NULL, 0);
+}
+
+struct mount_flags {
+  const char *opt;
+  unsigned long flag;
+  int on;
+};
+
+static const struct mount_flags mount_flags[] = {
+  {"rw",	    MS_RDONLY,	    0},
+  {"ro",	    MS_RDONLY,	    1},
+  {"suid",    MS_NOSUID,	    0},
+  {"nosuid",  MS_NOSUID,	    1},
+  {"dev",	    MS_NODEV,	    0},
+  {"nodev",   MS_NODEV,	    1},
+  {"exec",    MS_NOEXEC,	    0},
+  {"noexec",  MS_NOEXEC,	    1},
+  {"async",   MS_SYNCHRONOUS, 0},
+  {"sync",    MS_SYNCHRONOUS, 1},
+  {"atime",   MS_NOATIME,	    0},
+  {"noatime", MS_NOATIME,	    1},
+#ifndef __NetBSD__
+  {"dirsync", MS_DIRSYNC,	    1},
+#endif
+  {NULL,	    0,		    0}
+};
+
+static void set_mount_flag(const char *s, int *flags)
+{
+  int i;
+
+  for (i = 0; mount_flags[i].opt != NULL; i++) {
+    const char *opt = mount_flags[i].opt;
+    if (strcmp(opt, s) == 0) {
+      if (mount_flags[i].on)
+        *flags |= mount_flags[i].flag;
+      else
+        *flags &= ~mount_flags[i].flag;
+      return;
+    }
+  }
+  fprintf(stderr, "fuse: internal error, can't find mount flag\n");
+  abort();
+}
+
+static int fuse_mount_opt_proc(void *data, const char *arg, int key,
+			       struct fuse_args *outargs)
+{
+  struct mount_opts *mo = data;
+
+  switch (key) {
+  case KEY_RO:
+    arg = "ro";
+    /* fall through */
+  case KEY_KERN_FLAG:
+    set_mount_flag(arg, &mo->flags);
+    return 0;
+
+  case KEY_KERN_OPT:
+    return fuse_opt_add_opt(&mo->kernel_opts, arg);
+
+  case KEY_FUSERMOUNT_OPT:
+    return fuse_opt_add_opt_escaped(&mo->fusermount_opts, arg);
+
+  case KEY_SUBTYPE_OPT:
+    return fuse_opt_add_opt(&mo->subtype_opt, arg);
+
+  case KEY_MTAB_OPT:
+    return fuse_opt_add_opt(&mo->mtab_opts, arg);
+
+  case KEY_HELP:
+    mount_help();
+    mo->ishelp = 1;
+    break;
+
+  case KEY_VERSION:
+    mount_version();
+    mo->ishelp = 1;
+    break;
+  }
+  return 1;
+}
+
+/* return value:
+ * >= 0	 => fd
+ * -1	 => error
+ */
+static int receive_fd(int fd)
+{
+  struct msghdr msg;
+  struct iovec iov;
+  char buf[1];
+  int rv;
+  size_t ccmsg[CMSG_SPACE(sizeof(int)) / sizeof(size_t)];
+  struct cmsghdr *cmsg;
+
+  iov.iov_base = buf;
+  iov.iov_len = 1;
+
+  memset(&msg, 0, sizeof(msg));
+  msg.msg_name = 0;
+  msg.msg_namelen = 0;
+  msg.msg_iov = &iov;
+  msg.msg_iovlen = 1;
+  /* old BSD implementations should use msg_accrights instead of
+   * msg_control; the interface is different. */
+  msg.msg_control = ccmsg;
+  msg.msg_controllen = sizeof(ccmsg);
+
+  while(((rv = recvmsg(fd, &msg, 0)) == -1) && errno == EINTR);
+  if (rv == -1) {
+    perror("recvmsg");
+    return -1;
+  }
+  if(!rv) {
+    /* EOF */
+    return -1;
+  }
+
+  cmsg = CMSG_FIRSTHDR(&msg);
+  if (cmsg->cmsg_type != SCM_RIGHTS) {
+    fprintf(stderr, "got control message of unknown type %d\n",
+            cmsg->cmsg_type);
+    return -1;
+  }
+  return *(int*)CMSG_DATA(cmsg);
+}
+
+void fuse_kern_unmount(const char *mountpoint, int fd)
+{
+  int res;
+  int pid;
+
+  if (!mountpoint)
+    return;
+
+  if (fd != -1) {
+    struct pollfd pfd;
+
+    pfd.fd = fd;
+    pfd.events = 0;
+    res = poll(&pfd, 1, 0);
+
+    /* Need to close file descriptor, otherwise synchronous umount
+       would recurse into filesystem, and deadlock.
+
+       Caller expects fuse_kern_unmount to close the fd, so close it
+       anyway. */
+    close(fd);
+
+    /* If file poll returns POLLERR on the device file descriptor,
+       then the filesystem is already unmounted */
+    if (res == 1 && (pfd.revents & POLLERR))
+      return;
+  }
+
+  if (geteuid() == 0) {
+    fuse_mnt_umount("fuse", mountpoint, mountpoint,  1);
+    return;
+  }
+
+  res = umount2(mountpoint, 2);
+  if (res == 0)
+    return;
+
+  pid = fork();
+  if(pid == -1)
+    return;
+
+  if(pid == 0) {
+    const char *argv[] = { FUSERMOUNT_PROG, "-u", "-q", "-z",
+                           "--", mountpoint, NULL };
+
+    exec_fusermount(argv);
+    _exit(1);
+  }
+  waitpid(pid, NULL, 0);
+}
+
+static int fuse_mount_fusermount(const char *mountpoint, struct mount_opts *mo,
+                                 const char *opts, int quiet)
+{
+  int fds[2], pid;
+  int res;
+  int rv;
+
+  if (!mountpoint) {
+    fprintf(stderr, "fuse: missing mountpoint parameter\n");
+    return -1;
+  }
+
+  res = socketpair(PF_UNIX, SOCK_STREAM, 0, fds);
+  if(res == -1) {
+    perror("fuse: socketpair() failed");
+    return -1;
+  }
+
+  pid = fork();
+  if(pid == -1) {
+    perror("fuse: fork() failed");
+    close(fds[0]);
+    close(fds[1]);
+    return -1;
+  }
+
+  if(pid == 0) {
+    char env[10];
+    const char *argv[32];
+    int a = 0;
+
+    if (quiet) {
+      int fd = open("/dev/null", O_RDONLY);
+      if (fd != -1) {
+        dup2(fd, 1);
+        dup2(fd, 2);
+      }
+    }
+
+    argv[a++] = FUSERMOUNT_PROG;
+    if (opts) {
+      argv[a++] = "-o";
+      argv[a++] = opts;
+    }
+    argv[a++] = "--";
+    argv[a++] = mountpoint;
+    argv[a++] = NULL;
+
+    close(fds[1]);
+    fcntl(fds[0], F_SETFD, 0);
+    snprintf(env, sizeof(env), "%i", fds[0]);
+    setenv(FUSE_COMMFD_ENV, env, 1);
+    exec_fusermount(argv);
+    perror("fuse: failed to exec fusermount");
+    _exit(1);
+  }
+
+  close(fds[0]);
+  rv = receive_fd(fds[1]);
+
+  if (!mo->auto_unmount) {
+    /* with auto_unmount option fusermount will not exit until
+       this socket is closed */
+    close(fds[1]);
+    waitpid(pid, NULL, 0); /* bury zombie */
+  }
+
+  return rv;
+}
+
+static int fuse_mount_sys(const char *mnt, struct mount_opts *mo,
+			  const char *mnt_opts)
+{
+  char tmp[128];
+  const char *devname = "/dev/fuse";
+  char *source = NULL;
+  char *type = NULL;
+  struct stat stbuf;
+  int fd;
+  int res;
+
+  if (!mnt) {
+    fprintf(stderr, "fuse: missing mountpoint parameter\n");
+    return -1;
+  }
+
+  res = stat(mnt, &stbuf);
+  if (res == -1) {
+    fprintf(stderr ,"fuse: failed to access mountpoint %s: %s\n",
+            mnt, strerror(errno));
+    return -1;
+  }
+
+  if (!mo->nonempty) {
+    res = fuse_mnt_check_empty("fuse", mnt, stbuf.st_mode,
+                               stbuf.st_size);
+    if (res == -1)
+      return -1;
+  }
+
+  if (mo->auto_unmount) {
+    /* Tell the caller to fallback to fusermount because
+       auto-unmount does not work otherwise. */
+    return -2;
+  }
+
+  fd = open(devname, O_RDWR);
+  if (fd == -1) {
+    if (errno == ENODEV || errno == ENOENT)
+      fprintf(stderr, "fuse: device not found, try 'modprobe fuse' first\n");
+    else
+      fprintf(stderr, "fuse: failed to open %s: %s\n",
+              devname, strerror(errno));
+    return -1;
+  }
+
+  snprintf(tmp, sizeof(tmp),  "fd=%i,rootmode=%o,user_id=%u,group_id=%u",
+           fd, stbuf.st_mode & S_IFMT, getuid(), getgid());
+
+  res = fuse_opt_add_opt(&mo->kernel_opts, tmp);
+  if (res == -1)
+    goto out_close;
+
+  source = malloc((mo->fsname ? strlen(mo->fsname) : 0) +
+                  (mo->subtype ? strlen(mo->subtype) : 0) +
+                  strlen(devname) + 32);
+
+  type = malloc((mo->subtype ? strlen(mo->subtype) : 0) + 32);
+  if (!type || !source) {
+    fprintf(stderr, "fuse: failed to allocate memory\n");
+    goto out_close;
+  }
+
+  strcpy(type, mo->blkdev ? "fuseblk" : "fuse");
+  if (mo->subtype) {
+    strcat(type, ".");
+    strcat(type, mo->subtype);
+  }
+  strcpy(source,
+         mo->fsname ? mo->fsname : (mo->subtype ? mo->subtype : devname));
+
+  res = mount(source, mnt, type, mo->flags, mo->kernel_opts);
+  if (res == -1 && errno == ENODEV && mo->subtype) {
+    /* Probably missing subtype support */
+    strcpy(type, mo->blkdev ? "fuseblk" : "fuse");
+    if (mo->fsname) {
+      if (!mo->blkdev)
+        sprintf(source, "%s#%s", mo->subtype,
+                mo->fsname);
+    } else {
+      strcpy(source, type);
+    }
+    res = mount(source, mnt, type, mo->flags, mo->kernel_opts);
+  }
+  if (res == -1) {
+    /*
+     * Maybe kernel doesn't support unprivileged mounts, in this
+     * case try falling back to fusermount
+     */
+    if (errno == EPERM) {
+      res = -2;
+    } else {
+      int errno_save = errno;
+      if (mo->blkdev && errno == ENODEV &&
+          !fuse_mnt_check_fuseblk())
+        fprintf(stderr,
+                "fuse: 'fuseblk' support missing\n");
+      else
+        fprintf(stderr, "fuse: mount failed: %s\n",
+                strerror(errno_save));
+    }
+
+    goto out_close;
+  }
+
+#ifndef __NetBSD__
+#ifndef IGNORE_MTAB
+  if (geteuid() == 0) {
+    char *newmnt = fuse_mnt_resolve_path("fuse", mnt);
+    res = -1;
+    if (!newmnt)
+      goto out_umount;
+
+    res = fuse_mnt_add_mount("fuse", source, newmnt, type,
+                             mnt_opts);
+    free(newmnt);
+    if (res == -1)
+      goto out_umount;
+  }
+#endif /* IGNORE_MTAB */
+#endif /* __NetBSD__ */
+  free(type);
+  free(source);
+
+  return fd;
+
+ out_umount:
+  umount2(mnt, 2); /* lazy umount */
+ out_close:
+  free(type);
+  free(source);
+  close(fd);
+  return res;
+}
+
+static int get_mnt_flag_opts(char **mnt_optsp, int flags)
+{
+  int i;
+
+  if (!(flags & MS_RDONLY) && fuse_opt_add_opt(mnt_optsp, "rw") == -1)
+    return -1;
+
+  for (i = 0; mount_flags[i].opt != NULL; i++) {
+    if (mount_flags[i].on && (flags & mount_flags[i].flag) &&
+        fuse_opt_add_opt(mnt_optsp, mount_flags[i].opt) == -1)
+      return -1;
+  }
+  return 0;
+}
+
+int fuse_kern_mount(const char *mountpoint, struct fuse_args *args)
+{
+  struct mount_opts mo;
+  int res = -1;
+  char *mnt_opts = NULL;
+
+  memset(&mo, 0, sizeof(mo));
+  mo.flags = MS_NOSUID | MS_NODEV;
+
+  if (args &&
+      fuse_opt_parse(args, &mo, fuse_mount_opts, fuse_mount_opt_proc) == -1)
+    return -1;
+
+  res = 0;
+  if (mo.ishelp)
+    goto out;
+
+  res = -1;
+  if (get_mnt_flag_opts(&mnt_opts, mo.flags) == -1)
+    goto out;
+  if (mo.kernel_opts && fuse_opt_add_opt(&mnt_opts, mo.kernel_opts) == -1)
+    goto out;
+  if (mo.mtab_opts &&  fuse_opt_add_opt(&mnt_opts, mo.mtab_opts) == -1)
+    goto out;
+
+  res = fuse_mount_sys(mountpoint, &mo, mnt_opts);
+  if (res == -2) {
+    if (mo.fusermount_opts &&
+        fuse_opt_add_opt(&mnt_opts, mo.fusermount_opts) == -1)
+      goto out;
+
+    if (mo.subtype) {
+      char *tmp_opts = NULL;
+
+      res = -1;
+      if (fuse_opt_add_opt(&tmp_opts, mnt_opts) == -1 ||
+          fuse_opt_add_opt(&tmp_opts, mo.subtype_opt) == -1) {
+        free(tmp_opts);
+        goto out;
+      }
+
+      res = fuse_mount_fusermount(mountpoint, &mo, tmp_opts, 1);
+      free(tmp_opts);
+      if (res == -1)
+        res = fuse_mount_fusermount(mountpoint, &mo,
+                                    mnt_opts, 0);
+    } else {
+      res = fuse_mount_fusermount(mountpoint, &mo, mnt_opts, 0);
+    }
+  }
+ out:
+  free(mnt_opts);
+  free(mo.fsname);
+  free(mo.subtype);
+  free(mo.fusermount_opts);
+  free(mo.subtype_opt);
+  free(mo.kernel_opts);
+  free(mo.mtab_opts);
+  return res;
+}

libfuse/lib/mount_util.c

@@ -0,0 +1,363 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#include "mount_util.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <paths.h>
+#ifndef __NetBSD__
+#include <mntent.h>
+#endif
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+
+#ifdef __NetBSD__
+#define umount2(mnt, flags) unmount(mnt, (flags == 2) ? MNT_FORCE : 0)
+#define mtab_needs_update(mnt) 0
+#else
+static int mtab_needs_update(const char *mnt)
+{
+  int res;
+  struct stat stbuf;
+
+  /* If mtab is within new mount, don't touch it */
+  if (strncmp(mnt, _PATH_MOUNTED, strlen(mnt)) == 0 &&
+      _PATH_MOUNTED[strlen(mnt)] == '/')
+    return 0;
+
+  /*
+   * Skip mtab update if /etc/mtab:
+   *
+   *  - doesn't exist,
+   *  - is a symlink,
+   *  - is on a read-only filesystem.
+   */
+  res = lstat(_PATH_MOUNTED, &stbuf);
+  if (res == -1) {
+    if (errno == ENOENT)
+      return 0;
+  } else {
+    uid_t ruid;
+    int err;
+
+    if (S_ISLNK(stbuf.st_mode))
+      return 0;
+
+    ruid = getuid();
+    if (ruid != 0)
+      setreuid(0, -1);
+
+    res = access(_PATH_MOUNTED, W_OK);
+    err = (res == -1) ? errno : 0;
+    if (ruid != 0)
+      setreuid(ruid, -1);
+
+    if (err == EROFS)
+      return 0;
+  }
+
+  return 1;
+}
+#endif /* __NetBSD__ */
+
+static int add_mount(const char *progname, const char *fsname,
+                     const char *mnt, const char *type, const char *opts)
+{
+  int res;
+  int status;
+  sigset_t blockmask;
+  sigset_t oldmask;
+
+  sigemptyset(&blockmask);
+  sigaddset(&blockmask, SIGCHLD);
+  res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+  if (res == -1) {
+    fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+    return -1;
+  }
+
+  res = fork();
+  if (res == -1) {
+    fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+    goto out_restore;
+  }
+  if (res == 0) {
+    char *env = NULL;
+
+    sigprocmask(SIG_SETMASK, &oldmask, NULL);
+    setuid(geteuid());
+    execle("/bin/mount", "/bin/mount", "--no-canonicalize", "-i",
+           "-f", "-t", type, "-o", opts, fsname, mnt, NULL, &env);
+    fprintf(stderr, "%s: failed to execute /bin/mount: %s\n",
+            progname, strerror(errno));
+    exit(1);
+  }
+  res = waitpid(res, &status, 0);
+  if (res == -1)
+    fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+
+  if (status != 0)
+    res = -1;
+
+ out_restore:
+  sigprocmask(SIG_SETMASK, &oldmask, NULL);
+
+  return res;
+}
+
+int fuse_mnt_add_mount(const char *progname, const char *fsname,
+		       const char *mnt, const char *type, const char *opts)
+{
+  if (!mtab_needs_update(mnt))
+    return 0;
+
+  return add_mount(progname, fsname, mnt, type, opts);
+}
+
+static int exec_umount(const char *progname, const char *rel_mnt, int lazy)
+{
+  int res;
+  int status;
+  sigset_t blockmask;
+  sigset_t oldmask;
+
+  sigemptyset(&blockmask);
+  sigaddset(&blockmask, SIGCHLD);
+  res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+  if (res == -1) {
+    fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+    return -1;
+  }
+
+  res = fork();
+  if (res == -1) {
+    fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+    goto out_restore;
+  }
+  if (res == 0) {
+    char *env = NULL;
+
+    sigprocmask(SIG_SETMASK, &oldmask, NULL);
+    setuid(geteuid());
+    if (lazy) {
+      execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
+             "-l", NULL, &env);
+    } else {
+      execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
+             NULL, &env);
+    }
+    fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
+            progname, strerror(errno));
+    exit(1);
+  }
+  res = waitpid(res, &status, 0);
+  if (res == -1)
+    fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+
+  if (status != 0) {
+    res = -1;
+  }
+
+ out_restore:
+  sigprocmask(SIG_SETMASK, &oldmask, NULL);
+  return res;
+
+}
+
+int fuse_mnt_umount(const char *progname, const char *abs_mnt,
+		    const char *rel_mnt, int lazy)
+{
+  int res;
+
+  if (!mtab_needs_update(abs_mnt)) {
+    res = umount2(rel_mnt, lazy ? 2 : 0);
+    if (res == -1)
+      fprintf(stderr, "%s: failed to unmount %s: %s\n",
+              progname, abs_mnt, strerror(errno));
+    return res;
+  }
+
+  return exec_umount(progname, rel_mnt, lazy);
+}
+
+static int remove_mount(const char *progname, const char *mnt)
+{
+  int res;
+  int status;
+  sigset_t blockmask;
+  sigset_t oldmask;
+
+  sigemptyset(&blockmask);
+  sigaddset(&blockmask, SIGCHLD);
+  res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+  if (res == -1) {
+    fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+    return -1;
+  }
+
+  res = fork();
+  if (res == -1) {
+    fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+    goto out_restore;
+  }
+  if (res == 0) {
+    char *env = NULL;
+
+    sigprocmask(SIG_SETMASK, &oldmask, NULL);
+    setuid(geteuid());
+    execle("/bin/umount", "/bin/umount", "--no-canonicalize", "-i",
+           "--fake", mnt, NULL, &env);
+    fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
+            progname, strerror(errno));
+    exit(1);
+  }
+  res = waitpid(res, &status, 0);
+  if (res == -1)
+    fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+
+  if (status != 0)
+    res = -1;
+
+ out_restore:
+  sigprocmask(SIG_SETMASK, &oldmask, NULL);
+  return res;
+}
+
+int fuse_mnt_remove_mount(const char *progname, const char *mnt)
+{
+  if (!mtab_needs_update(mnt))
+    return 0;
+
+  return remove_mount(progname, mnt);
+}
+
+char *fuse_mnt_resolve_path(const char *progname, const char *orig)
+{
+  char buf[PATH_MAX];
+  char *copy;
+  char *dst;
+  char *end;
+  char *lastcomp;
+  const char *toresolv;
+
+  if (!orig[0]) {
+    fprintf(stderr, "%s: invalid mountpoint '%s'\n", progname,
+            orig);
+    return NULL;
+  }
+
+  copy = strdup(orig);
+  if (copy == NULL) {
+    fprintf(stderr, "%s: failed to allocate memory\n", progname);
+    return NULL;
+  }
+
+  toresolv = copy;
+  lastcomp = NULL;
+  for (end = copy + strlen(copy) - 1; end > copy && *end == '/'; end --);
+  if (end[0] != '/') {
+    char *tmp;
+    end[1] = '\0';
+    tmp = strrchr(copy, '/');
+    if (tmp == NULL) {
+      lastcomp = copy;
+      toresolv = ".";
+    } else {
+      lastcomp = tmp + 1;
+      if (tmp == copy)
+        toresolv = "/";
+    }
+    if (strcmp(lastcomp, ".") == 0 || strcmp(lastcomp, "..") == 0) {
+      lastcomp = NULL;
+      toresolv = copy;
+    }
+    else if (tmp)
+      tmp[0] = '\0';
+  }
+  if (realpath(toresolv, buf) == NULL) {
+    fprintf(stderr, "%s: bad mount point %s: %s\n", progname, orig,
+            strerror(errno));
+    free(copy);
+    return NULL;
+  }
+  if (lastcomp == NULL)
+    dst = strdup(buf);
+  else {
+    dst = (char *) malloc(strlen(buf) + 1 + strlen(lastcomp) + 1);
+    if (dst) {
+      unsigned buflen = strlen(buf);
+      if (buflen && buf[buflen-1] == '/')
+        sprintf(dst, "%s%s", buf, lastcomp);
+      else
+        sprintf(dst, "%s/%s", buf, lastcomp);
+    }
+  }
+  free(copy);
+  if (dst == NULL)
+    fprintf(stderr, "%s: failed to allocate memory\n", progname);
+  return dst;
+}
+
+int fuse_mnt_check_empty(const char *progname, const char *mnt,
+			 mode_t rootmode, off_t rootsize)
+{
+  int isempty = 1;
+
+  if (S_ISDIR(rootmode)) {
+    struct dirent *ent;
+    DIR *dp = opendir(mnt);
+    if (dp == NULL) {
+      fprintf(stderr,
+              "%s: failed to open mountpoint for reading: %s\n",
+              progname, strerror(errno));
+      return -1;
+    }
+    while ((ent = readdir(dp)) != NULL) {
+      if (strcmp(ent->d_name, ".") != 0 &&
+          strcmp(ent->d_name, "..") != 0) {
+        isempty = 0;
+        break;
+      }
+    }
+    closedir(dp);
+  } else if (rootsize)
+    isempty = 0;
+
+  if (!isempty) {
+    fprintf(stderr, "%s: mountpoint is not empty\n", progname);
+    fprintf(stderr, "%s: if you are sure this is safe, use the 'nonempty' mount option\n", progname);
+    return -1;
+  }
+  return 0;
+}
+
+int fuse_mnt_check_fuseblk(void)
+{
+  char buf[256];
+  FILE *f = fopen("/proc/filesystems", "r");
+  if (!f)
+    return 1;
+
+  while (fgets(buf, sizeof(buf), f))
+    if (strstr(buf, "fuseblk\n")) {
+      fclose(f);
+      return 1;
+    }
+
+  fclose(f);
+  return 0;
+}

libfuse/lib/mount_util.h

@@ -0,0 +1,21 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#pragma once
+
+#include <sys/types.h>
+
+int fuse_mnt_add_mount(const char *progname, const char *fsname,
+		       const char *mnt, const char *type, const char *opts);
+int fuse_mnt_remove_mount(const char *progname, const char *mnt);
+int fuse_mnt_umount(const char *progname, const char *abs_mnt,
+		    const char *rel_mnt, int lazy);
+char *fuse_mnt_resolve_path(const char *progname, const char *orig);
+int fuse_mnt_check_empty(const char *progname, const char *mnt,
+			 mode_t rootmode, off_t rootsize);
+int fuse_mnt_check_fuseblk(void);

libfuse/lib/pool.hpp

@@ -0,0 +1,161 @@
+#pragma once
+
+#include <tuple>
+#include <atomic>
+#include <vector>
+#include <thread>
+#include <memory>
+#include <future>
+#include <utility>
+#include <stdexcept>
+#include <functional>
+#include <type_traits>
+#include "queue.hpp"
+
+
+
+class simple_thread_pool
+{
+public:
+	explicit simple_thread_pool(std::size_t thread_count = std::thread::hardware_concurrency())
+	{
+		if(!thread_count)
+			throw std::invalid_argument("bad thread count! must be non-zero!");
+
+		auto worker = [this]()
+		{
+			while(true)
+			{
+				proc_t f;
+				if(!m_queue.pop(f))
+					break;
+				f();
+			}
+		};
+
+		m_threads.reserve(thread_count);
+		while(thread_count--)
+			m_threads.emplace_back(worker);
+	}
+
+	~simple_thread_pool()
+	{
+		m_queue.unblock();
+		for(auto& thread : m_threads)
+			thread.join();
+	}
+
+	template<typename F, typename... Args>
+	void enqueue_work(F&& f, Args&&... args)
+	{
+		m_queue.push([p = std::forward<F>(f), t = std::make_tuple(std::forward<Args>(args)...)]() { std::apply(p, t); });
+	}
+
+	template<typename F, typename... Args>
+	[[nodiscard]] auto enqueue_task(F&& f, Args&&... args) -> std::future<std::invoke_result_t<F, Args...>>
+	{
+		using task_return_type = std::invoke_result_t<F, Args...>;
+		using task_type = std::packaged_task<task_return_type()>;
+
+		auto task = std::make_shared<task_type>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
+		auto result = task->get_future();
+
+		m_queue.push([=]() { (*task)(); });
+
+		return result;
+	}
+
+private:
+	using proc_t = std::function<void(void)>;
+	using queue_t = unbounded_queue<proc_t>;
+	queue_t m_queue;
+
+	using threads_t = std::vector<std::thread>;
+	threads_t m_threads;
+};
+
+
+
+class thread_pool
+{
+public:
+	explicit thread_pool(std::size_t thread_count = std::thread::hardware_concurrency())
+	: m_queues(thread_count), m_count(thread_count)
+	{
+		if(!thread_count)
+			throw std::invalid_argument("bad thread count! must be non-zero!");
+
+		auto worker = [this](auto i)
+		{
+			while(true)
+			{
+				proc_t f;
+				for(std::size_t n = 0; n < m_count * K; ++n)
+					if(m_queues[(i + n) % m_count].try_pop(f))
+						break;
+				if(!f && !m_queues[i].pop(f))
+					break;
+				f();
+			}
+		};
+
+		m_threads.reserve(thread_count);
+		for(std::size_t i = 0; i < thread_count; ++i)
+			m_threads.emplace_back(worker, i);
+	}
+
+	~thread_pool()
+	{
+		for(auto& queue : m_queues)
+			queue.unblock();
+		for(auto& thread : m_threads)
+			thread.join();
+	}
+
+	template<typename F, typename... Args>
+	void enqueue_work(F&& f, Args&&... args)
+	{
+		auto work = [p = std::forward<F>(f), t = std::make_tuple(std::forward<Args>(args)...)]() { std::apply(p, t); };
+		auto i = m_index++;
+
+		for(std::size_t n = 0; n < m_count * K; ++n)
+			if(m_queues[(i + n) % m_count].try_push(work))
+				return;
+
+		m_queues[i % m_count].push(std::move(work));
+	}
+
+	template<typename F, typename... Args>
+	[[nodiscard]] auto enqueue_task(F&& f, Args&&... args) -> std::future<std::invoke_result_t<F, Args...>>
+	{
+		using task_return_type = std::invoke_result_t<F, Args...>;
+		using task_type = std::packaged_task<task_return_type()>;
+
+		auto task = std::make_shared<task_type>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
+		auto work = [=]() { (*task)(); };
+		auto result = task->get_future();
+		auto i = m_index++;
+
+		for(auto n = 0; n < m_count * K; ++n)
+			if(m_queues[(i + n) % m_count].try_push(work))
+				return result;
+
+		m_queues[i % m_count].push(std::move(work));
+
+		return result;
+	}
+
+private:
+	using proc_t = std::function<void(void)>;
+	using queue_t = unbounded_queue<proc_t>;
+	using queues_t = std::vector<queue_t>;
+	queues_t m_queues;
+
+	using threads_t = std::vector<std::thread>;
+	threads_t m_threads;
+
+	const std::size_t m_count;
+	std::atomic_uint m_index = 0;
+
+	inline static const unsigned int K = 2;
+};

libfuse/lib/queue.hpp

@@ -0,0 +1,256 @@
+#pragma once
+
+#include <mutex>
+#include <queue>
+#include <utility>
+#include <stdexcept>
+#include <condition_variable>
+
+
+
+template<typename T>
+class unbounded_queue
+{
+public:
+	explicit unbounded_queue(bool block = true)
+	: m_block{ block } {}
+
+	void push(const T& item)
+	{
+		{
+			std::scoped_lock guard(m_queue_lock);
+			m_queue.push(item);
+		}
+		m_condition.notify_one();
+	}
+
+	void push(T&& item)
+	{
+		{
+			std::scoped_lock guard(m_queue_lock);
+			m_queue.push(std::move(item));
+		}
+		m_condition.notify_one();
+	}
+
+	template<typename... Args>
+	void emplace(Args&&... args)
+	{
+		{
+			std::scoped_lock guard(m_queue_lock);
+			m_queue.emplace(std::forward<Args>(args)...);
+		}
+		m_condition.notify_one();
+	}
+
+	bool try_push(const T& item)
+	{
+		{
+			std::unique_lock lock(m_queue_lock, std::try_to_lock);
+			if(!lock)
+				return false;
+			m_queue.push(item);
+		}
+		m_condition.notify_one();
+		return true;
+	}
+
+	bool try_push(T&& item)
+	{
+		{
+			std::unique_lock lock(m_queue_lock, std::try_to_lock);
+			if(!lock)
+				return false;
+			m_queue.push(std::move(item));
+		}
+		m_condition.notify_one();
+		return true;
+	}
+
+	bool pop(T& item)
+	{
+		std::unique_lock guard(m_queue_lock);
+		m_condition.wait(guard, [&]() { return !m_queue.empty() || !m_block; });
+		if(m_queue.empty())
+			return false;
+		item = std::move(m_queue.front());
+		m_queue.pop();
+		return true;
+	}
+
+	bool try_pop(T& item)
+	{
+		std::unique_lock lock(m_queue_lock, std::try_to_lock);
+		if(!lock || m_queue.empty())
+			return false;
+		item = std::move(m_queue.front());
+		m_queue.pop();
+		return true;
+	}
+
+	std::size_t size() const
+	{
+		std::scoped_lock guard(m_queue_lock);
+		return m_queue.size();
+	}
+
+	bool empty() const
+	{
+		std::scoped_lock guard(m_queue_lock);
+		return m_queue.empty();
+	}
+
+	void block()
+	{
+		std::scoped_lock guard(m_queue_lock);
+		m_block = true;
+	}
+
+	void unblock()
+	{
+		{
+			std::scoped_lock guard(m_queue_lock);
+			m_block = false;
+		}
+		m_condition.notify_all();
+	}
+
+	bool blocking() const
+	{
+		std::scoped_lock guard(m_queue_lock);
+		return m_block;
+	}
+
+private:
+	using queue_t = std::queue<T>;
+	queue_t m_queue;
+
+	bool m_block;
+
+	mutable std::mutex m_queue_lock;
+	std::condition_variable m_condition;
+};
+
+
+
+template<typename T>
+class bounded_queue
+{
+public:
+	explicit bounded_queue(std::size_t max_size, bool block = true)
+	: m_block{ block }, m_max_size{ max_size }
+	{
+		if(!m_max_size)
+			throw std::invalid_argument("bad queue max-size! must be non-zero!");
+	}
+
+	bool push(const T& item)
+	{
+		{
+			std::unique_lock guard(m_queue_lock);
+			m_condition_push.wait(guard, [&]() { return m_queue.size() < m_max_size || !m_block; });
+			if(m_queue.size() == m_max_size)
+				return false;
+			m_queue.push(item);
+		}
+		m_condition_pop.notify_one();
+		return true;
+	}
+
+	bool push(T&& item)
+	{
+		{
+			std::unique_lock guard(m_queue_lock);
+			m_condition_push.wait(guard, [&]() { return m_queue.size() < m_max_size || !m_block; });
+			if(m_queue.size() == m_max_size)
+				return false;
+			m_queue.push(std::move(item));
+		}
+		m_condition_pop.notify_one();
+		return true;
+	}
+
+	template<typename... Args>
+	bool emplace(Args&&... args)
+	{
+		{
+			std::unique_lock guard(m_queue_lock);
+			m_condition_push.wait(guard, [&]() { return m_queue.size() < m_max_size || !m_block; });
+			if(m_queue.size() == m_max_size)
+				return false;
+			m_queue.emplace(std::forward<Args>(args)...);
+		}
+		m_condition_pop.notify_one();
+		return true;
+	}
+
+	bool pop(T& item)
+	{
+		{
+			std::unique_lock guard(m_queue_lock);
+			m_condition_pop.wait(guard, [&]() { return !m_queue.empty() || !m_block; });
+			if(m_queue.empty())
+				return false;
+			item = std::move(m_queue.front());
+			m_queue.pop();
+		}
+		m_condition_push.notify_one();
+		return true;
+	}
+
+	std::size_t size() const
+	{
+		std::scoped_lock guard(m_queue_lock);
+		return m_queue.size();
+	}
+
+	std::size_t capacity() const
+	{
+		return m_max_size;
+	}
+
+	bool empty() const
+	{
+		std::scoped_lock guard(m_queue_lock);
+		return m_queue.empty();
+	}
+
+	bool full() const
+	{
+		std::scoped_lock lock(m_queue_lock);
+		return m_queue.size() == capacity();
+	}
+
+	void block()
+	{
+		std::scoped_lock guard(m_queue_lock);
+		m_block = true;
+	}
+
+	void unblock()
+	{
+		{
+			std::scoped_lock guard(m_queue_lock);
+			m_block = false;
+		}
+		m_condition_push.notify_all();
+		m_condition_pop.notify_all();
+	}
+
+	bool blocking() const
+	{
+		std::scoped_lock guard(m_queue_lock);
+		return m_block;
+	}
+
+private:
+	using queue_t = std::queue<T>;
+	queue_t m_queue;
+
+	bool m_block;
+	const std::size_t m_max_size;
+
+	mutable std::mutex m_queue_lock;
+	std::condition_variable m_condition_push;
+	std::condition_variable m_condition_pop;
+};

libfuse/util/mount.mergerfs.c

@@ -0,0 +1,231 @@
+/*
+  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.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+static char *progname;
+
+static char *xstrdup(const char *s)
+{
+	char *t = strdup(s);
+	if (!t) {
+		fprintf(stderr, "%s: failed to allocate memory\n", progname);
+		exit(1);
+	}
+	return t;
+}
+
+static void *xrealloc(void *oldptr, size_t size)
+{
+	void *ptr = realloc(oldptr, size);
+	if (!ptr) {
+		fprintf(stderr, "%s: failed to allocate memory\n", progname);
+		exit(1);
+	}
+	return ptr;
+}
+
+static void add_arg(char **cmdp, const char *opt)
+{
+	size_t optlen = strlen(opt);
+	size_t cmdlen = *cmdp ? strlen(*cmdp) : 0;
+	char *cmd = xrealloc(*cmdp, cmdlen + optlen * 4 + 4);
+	char *s;
+	s = cmd + cmdlen;
+	if (*cmdp)
+		*s++ = ' ';
+
+	*s++ = '\'';
+	for (; *opt; opt++) {
+		if (*opt == '\'') {
+			*s++ = '\'';
+			*s++ = '\\';
+			*s++ = '\'';
+			*s++ = '\'';
+		} else
+			*s++ = *opt;
+	}
+	*s++ = '\'';
+	*s = '\0';
+	*cmdp = cmd;
+}
+
+static char *add_option(const char *opt, char *options)
+{
+	int oldlen = options ? strlen(options) : 0;
+
+	options = xrealloc(options, oldlen + 1 + strlen(opt) + 1);
+	if (!oldlen)
+		strcpy(options, opt);
+	else {
+		strcat(options, ",");
+		strcat(options, opt);
+	}
+	return options;
+}
+
+int main(int argc, char *argv[])
+{
+	char *type = NULL;
+	char *source;
+	const char *mountpoint;
+	char *basename;
+	char *options = NULL;
+	char *command = NULL;
+	char *setuid = NULL;
+	int i;
+	int dev = 1;
+	int suid = 1;
+
+	progname = argv[0];
+	basename = strrchr(argv[0], '/');
+	if (basename)
+		basename++;
+	else
+		basename = argv[0];
+
+        type = "mergerfs";
+	if (strncmp(basename, "mount.fuse.", 11) == 0)
+		type = basename + 11;
+	if (strncmp(basename, "mount.fuseblk.", 14) == 0)
+		type = basename + 14;
+
+	if (type && !type[0])
+		type = NULL;
+
+	if (argc < 3) {
+		fprintf(stderr,
+			"usage: %s %s destination [-t type] [-o opt[,opts...]]\n",
+			progname, type ? "source" : "type#[source]");
+		exit(1);
+	}
+
+	source = argv[1];
+	if (!source[0])
+		source = NULL;
+
+	mountpoint = argv[2];
+
+	for (i = 3; i < argc; i++) {
+		if (strcmp(argv[i], "-v") == 0) {
+			continue;
+		} else if (strcmp(argv[i], "-t") == 0) {
+			i++;
+
+			if (i == argc) {
+				fprintf(stderr,
+					"%s: missing argument to option '-t'\n",
+					progname);
+				exit(1);
+			}
+			type = argv[i];
+			if (strncmp(type, "fuse.", 5) == 0)
+				type += 5;
+			else if (strncmp(type, "fuseblk.", 8) == 0)
+				type += 8;
+
+			if (!type[0]) {
+				fprintf(stderr,
+					"%s: empty type given as argument to option '-t'\n",
+					progname);
+				exit(1);
+			}
+		} else	if (strcmp(argv[i], "-o") == 0) {
+			char *opts;
+			char *opt;
+			i++;
+			if (i == argc)
+				break;
+
+			opts = xstrdup(argv[i]);
+			opt = strtok(opts, ",");
+			while (opt) {
+				int j;
+				int ignore = 0;
+				const char *ignore_opts[] = { "",
+							      "user",
+							      "nouser",
+							      "users",
+							      "auto",
+							      "noauto",
+							      "_netdev",
+							      NULL};
+				if (strncmp(opt, "setuid=", 7) == 0) {
+					setuid = xstrdup(opt + 7);
+					ignore = 1;
+				}
+				for (j = 0; ignore_opts[j]; j++)
+					if (strcmp(opt, ignore_opts[j]) == 0)
+						ignore = 1;
+
+				if (!ignore) {
+					if (strcmp(opt, "nodev") == 0)
+						dev = 0;
+					else if (strcmp(opt, "nosuid") == 0)
+						suid = 0;
+
+					options = add_option(opt, options);
+				}
+				opt = strtok(NULL, ",");
+			}
+		}
+	}
+
+	if (dev)
+		options = add_option("dev", options);
+	if (suid)
+		options = add_option("suid", options);
+
+	if (!type) {
+		if (source) {
+			type = xstrdup(source);
+			source = strchr(type, '#');
+			if (source)
+				*source++ = '\0';
+			if (!type[0]) {
+				fprintf(stderr, "%s: empty filesystem type\n",
+					progname);
+				exit(1);
+			}
+		} else {
+			fprintf(stderr, "%s: empty source\n", progname);
+			exit(1);
+		}
+	}
+
+	add_arg(&command, type);
+	if (source)
+		add_arg(&command, source);
+	add_arg(&command, mountpoint);
+	if (options) {
+		add_arg(&command, "-o");
+		add_arg(&command, options);
+	}
+
+	if (setuid && setuid[0]) {
+		char *sucommand = command;
+		command = NULL;
+		add_arg(&command, "su");
+		add_arg(&command, "-");
+		add_arg(&command, setuid);
+		add_arg(&command, "-c");
+		add_arg(&command, sucommand);
+	} else if (!getenv("HOME")) {
+		/* Hack to make filesystems work in the boot environment */
+		setenv("HOME", "/root", 0);
+	}
+
+	execl("/bin/sh", "/bin/sh", "-c", command, NULL);
+	fprintf(stderr, "%s: failed to execute /bin/sh: %s\n", progname,
+		strerror(errno));
+	return 1;
+}

libfuse/util/mount_util.c

@@ -0,0 +1,363 @@
+/*
+  FUSE: Filesystem in Userspace
+  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
+
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB.
+*/
+
+#include "mount_util.h"
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <dirent.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <paths.h>
+#ifndef __NetBSD__
+#include <mntent.h>
+#endif
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <sys/mount.h>
+#include <sys/param.h>
+
+#ifdef __NetBSD__
+#define umount2(mnt, flags) unmount(mnt, (flags == 2) ? MNT_FORCE : 0)
+#define mtab_needs_update(mnt) 0
+#else
+static int mtab_needs_update(const char *mnt)
+{
+	int res;
+	struct stat stbuf;
+
+	/* If mtab is within new mount, don't touch it */
+	if (strncmp(mnt, _PATH_MOUNTED, strlen(mnt)) == 0 &&
+	    _PATH_MOUNTED[strlen(mnt)] == '/')
+		return 0;
+
+	/*
+	 * Skip mtab update if /etc/mtab:
+	 *
+	 *  - doesn't exist,
+	 *  - is a symlink,
+	 *  - is on a read-only filesystem.
+	 */
+	res = lstat(_PATH_MOUNTED, &stbuf);
+	if (res == -1) {
+		if (errno == ENOENT)
+			return 0;
+	} else {
+		uid_t ruid;
+		int err;
+
+		if (S_ISLNK(stbuf.st_mode))
+			return 0;
+
+		ruid = getuid();
+		if (ruid != 0)
+			setreuid(0, -1);
+
+		res = access(_PATH_MOUNTED, W_OK);
+		err = (res == -1) ? errno : 0;
+		if (ruid != 0)
+			setreuid(ruid, -1);
+
+		if (err == EROFS)
+			return 0;
+	}
+
+	return 1;
+}
+#endif /* __NetBSD__ */
+
+static int add_mount(const char *progname, const char *fsname,
+		       const char *mnt, const char *type, const char *opts)
+{
+	int res;
+	int status;
+	sigset_t blockmask;
+	sigset_t oldmask;
+
+	sigemptyset(&blockmask);
+	sigaddset(&blockmask, SIGCHLD);
+	res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+	if (res == -1) {
+		fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+		return -1;
+	}
+
+	res = fork();
+	if (res == -1) {
+		fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+		goto out_restore;
+	}
+	if (res == 0) {
+		char *env = NULL;
+
+		sigprocmask(SIG_SETMASK, &oldmask, NULL);
+		setuid(geteuid());
+		execle("/bin/mount", "/bin/mount", "--no-canonicalize", "-i",
+		       "-f", "-t", type, "-o", opts, fsname, mnt, NULL, &env);
+		fprintf(stderr, "%s: failed to execute /bin/mount: %s\n",
+			progname, strerror(errno));
+		exit(1);
+	}
+	res = waitpid(res, &status, 0);
+	if (res == -1)
+		fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+
+	if (status != 0)
+		res = -1;
+
+ out_restore:
+	sigprocmask(SIG_SETMASK, &oldmask, NULL);
+
+	return res;
+}
+
+int fuse_mnt_add_mount(const char *progname, const char *fsname,
+		       const char *mnt, const char *type, const char *opts)
+{
+	if (!mtab_needs_update(mnt))
+		return 0;
+
+	return add_mount(progname, fsname, mnt, type, opts);
+}
+
+static int exec_umount(const char *progname, const char *rel_mnt, int lazy)
+{
+	int res;
+	int status;
+	sigset_t blockmask;
+	sigset_t oldmask;
+
+	sigemptyset(&blockmask);
+	sigaddset(&blockmask, SIGCHLD);
+	res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+	if (res == -1) {
+		fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+		return -1;
+	}
+
+	res = fork();
+	if (res == -1) {
+		fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+		goto out_restore;
+	}
+	if (res == 0) {
+		char *env = NULL;
+
+		sigprocmask(SIG_SETMASK, &oldmask, NULL);
+		setuid(geteuid());
+		if (lazy) {
+			execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
+			       "-l", NULL, &env);
+		} else {
+			execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
+			       NULL, &env);
+		}
+		fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
+			progname, strerror(errno));
+		exit(1);
+	}
+	res = waitpid(res, &status, 0);
+	if (res == -1)
+		fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+
+	if (status != 0) {
+		res = -1;
+	}
+
+ out_restore:
+	sigprocmask(SIG_SETMASK, &oldmask, NULL);
+	return res;
+
+}
+
+int fuse_mnt_umount(const char *progname, const char *abs_mnt,
+		    const char *rel_mnt, int lazy)
+{
+	int res;
+
+	if (!mtab_needs_update(abs_mnt)) {
+		res = umount2(rel_mnt, lazy ? 2 : 0);
+		if (res == -1)
+			fprintf(stderr, "%s: failed to unmount %s: %s\n",
+				progname, abs_mnt, strerror(errno));
+		return res;
+	}
+
+	return exec_umount(progname, rel_mnt, lazy);
+}
+
+static int remove_mount(const char *progname, const char *mnt)
+{
+	int res;
+	int status;
+	sigset_t blockmask;
+	sigset_t oldmask;
+
+	sigemptyset(&blockmask);
+	sigaddset(&blockmask, SIGCHLD);
+	res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+	if (res == -1) {
+		fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+		return -1;
+	}
+
+	res = fork();
+	if (res == -1) {
+		fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+		goto out_restore;
+	}
+	if (res == 0) {
+		char *env = NULL;
+
+		sigprocmask(SIG_SETMASK, &oldmask, NULL);
+		setuid(geteuid());
+		execle("/bin/umount", "/bin/umount", "--no-canonicalize", "-i",
+		       "--fake", mnt, NULL, &env);
+		fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
+			progname, strerror(errno));
+		exit(1);
+	}
+	res = waitpid(res, &status, 0);
+	if (res == -1)
+		fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+
+	if (status != 0)
+		res = -1;
+
+ out_restore:
+	sigprocmask(SIG_SETMASK, &oldmask, NULL);
+	return res;
+}
+
+int fuse_mnt_remove_mount(const char *progname, const char *mnt)
+{
+	if (!mtab_needs_update(mnt))
+		return 0;
+
+	return remove_mount(progname, mnt);
+}
+
+char *fuse_mnt_resolve_path(const char *progname, const char *orig)
+{
+	char buf[PATH_MAX];
+	char *copy;
+	char *dst;
+	char *end;
+	char *lastcomp;
+	const char *toresolv;
+
+	if (!orig[0]) {
+		fprintf(stderr, "%s: invalid mountpoint '%s'\n", progname,
+			orig);
+		return NULL;
+	}
+
+	copy = strdup(orig);
+	if (copy == NULL) {
+		fprintf(stderr, "%s: failed to allocate memory\n", progname);
+		return NULL;
+	}
+
+	toresolv = copy;
+	lastcomp = NULL;
+	for (end = copy + strlen(copy) - 1; end > copy && *end == '/'; end --);
+	if (end[0] != '/') {
+		char *tmp;
+		end[1] = '\0';
+		tmp = strrchr(copy, '/');
+		if (tmp == NULL) {
+			lastcomp = copy;
+			toresolv = ".";
+		} else {
+			lastcomp = tmp + 1;
+			if (tmp == copy)
+				toresolv = "/";
+		}
+		if (strcmp(lastcomp, ".") == 0 || strcmp(lastcomp, "..") == 0) {
+			lastcomp = NULL;
+			toresolv = copy;
+		}
+		else if (tmp)
+			tmp[0] = '\0';
+	}
+	if (realpath(toresolv, buf) == NULL) {
+		fprintf(stderr, "%s: bad mount point %s: %s\n", progname, orig,
+			strerror(errno));
+		free(copy);
+		return NULL;
+	}
+	if (lastcomp == NULL)
+		dst = strdup(buf);
+	else {
+		dst = (char *) malloc(strlen(buf) + 1 + strlen(lastcomp) + 1);
+		if (dst) {
+			unsigned buflen = strlen(buf);
+			if (buflen && buf[buflen-1] == '/')
+				sprintf(dst, "%s%s", buf, lastcomp);
+			else
+				sprintf(dst, "%s/%s", buf, lastcomp);
+		}
+	}
+	free(copy);
+	if (dst == NULL)
+		fprintf(stderr, "%s: failed to allocate memory\n", progname);
+	return dst;
+}
+
+int fuse_mnt_check_empty(const char *progname, const char *mnt,
+			 mode_t rootmode, off_t rootsize)
+{
+	int isempty = 1;
+
+	if (S_ISDIR(rootmode)) {
+		struct dirent *ent;
+		DIR *dp = opendir(mnt);
+		if (dp == NULL) {
+			fprintf(stderr,
+				"%s: failed to open mountpoint for reading: %s\n",
+				progname, strerror(errno));
+			return -1;
+		}
+		while ((ent = readdir(dp)) != NULL) {
+			if (strcmp(ent->d_name, ".") != 0 &&
+			    strcmp(ent->d_name, "..") != 0) {
+				isempty = 0;
+				break;
+			}
+		}
+		closedir(dp);
+	} else if (rootsize)
+		isempty = 0;
+
+	if (!isempty) {
+		fprintf(stderr, "%s: mountpoint is not empty\n", progname);
+		fprintf(stderr, "%s: if you are sure this is safe, use the 'nonempty' mount option\n", progname);
+		return -1;
+	}
+	return 0;
+}
+
+int fuse_mnt_check_fuseblk(void)
+{
+	char buf[256];
+	FILE *f = fopen("/proc/filesystems", "r");
+	if (!f)
+		return 1;
+
+	while (fgets(buf, sizeof(buf), f))
+		if (strstr(buf, "fuseblk\n")) {
+			fclose(f);
+			return 1;
+		}
+
+	fclose(f);
+	return 0;
+}

mergerfs.spec

@@ -0,0 +1,56 @@
+Name:		mergerfs
+Version:	__VERSION__
+Release:	1%{?dist}
+Summary:	A featureful FUSE based union filesystem
+
+Group:		Applications/System
+License:	ISC
+URL:		https://github.com/trapexit/mergerfs
+
+Source:		mergerfs-%{version}.tar.gz
+
+BuildRequires:	gcc-c++
+# rpmbuild driven by the Makefile uses git to generate a version number
+BuildRequires:	git
+
+Requires:	fuse
+
+%global debug_package %{nil}
+
+%prep
+%setup -q
+
+%description
+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.
+
+%build
+make %{?_smp_mflags}
+
+%install
+make install PREFIX=%{_prefix} DESTDIR=%{buildroot}
+
+%files
+/usr/bin/mergerfs
+/usr/bin/mergerfs-fusermount
+/sbin/mount.mergerfs
+%doc %{_mandir}/*
+
+%changelog
+* Fri Apr 26 2019 Antonio SJ Musumeci <trapexit@spawn.link>
+- Update description
+
+* Mon Jan 25 2016 Antonio SJ Musumeci <trapexit@spawn.link>
+- Remove sbin files
+
+* Sat Sep 05 2015 Antonio SJ Musumeci <trapexit@spawn.link>
+- Include PREFIX to install
+
+* Mon Dec 29 2014 Joe Lawrence <joe.lawrence@stratus.com>
+- Tweak rpmbuild to archive current git HEAD into a tarball, then (re)build in
+  the rpmbuild directory -- more complicated but seemingly better suited to
+  generate source and debug rpms.
+
+* Fri Jun 20 2014 Joe Lawrence <joe.lawrence@stratus.com>
+- Initial rpm spec file.

src/access.cpp

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

src/access.hpp

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

src/assert.hpp

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

src/branch.cpp

@@ -0,0 +1,97 @@
+/*
+  ISC License
+
+  Copyright (c) 2018, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "branch.hpp"
+#include "ef.hpp"
+#include "errno.hpp"
+#include "num.hpp"
+
+
+Branch::Branch(const uint64_t &default_minfreespace_)
+  : _default_minfreespace(&default_minfreespace_)
+{
+}
+
+int
+Branch::from_string(const std::string &str_)
+{
+  return -EINVAL;
+}
+
+std::string
+Branch::to_string(void) const
+{
+  std::string rv;
+
+  rv  = path;
+  rv += '=';
+  switch(mode)
+    {
+    default:
+    case Branch::Mode::RW:
+      rv += "RW";
+      break;
+    case Branch::Mode::RO:
+      rv += "RO";
+      break;
+    case Branch::Mode::NC:
+      rv += "NC";
+      break;
+    }
+
+  if(_minfreespace.has_value())
+    {
+      rv += ',';
+      rv += num::humanize(_minfreespace.value());
+    }
+
+  return rv;
+}
+
+void
+Branch::set_minfreespace(const uint64_t minfreespace_)
+{
+  _minfreespace = minfreespace_;
+}
+
+uint64_t
+Branch::minfreespace(void) const
+{
+  if(_minfreespace.has_value())
+    return _minfreespace.value();
+  return *_default_minfreespace;
+}
+
+bool
+Branch::ro(void) const
+{
+  return (mode == Branch::Mode::RO);
+}
+
+bool
+Branch::nc(void) const
+{
+  return (mode == Branch::Mode::NC);
+}
+
+bool
+Branch::ro_or_nc(void) const
+{
+  return ((mode == Branch::Mode::RO) ||
+          (mode == Branch::Mode::NC));
+}

src/branch.hpp

@@ -0,0 +1,67 @@
+/*
+  ISC License
+
+  Copyright (c) 2018, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "nonstd/optional.hpp"
+#include "strvec.hpp"
+#include "tofrom_string.hpp"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+
+class Branch final : public ToFromString
+{
+public:
+  typedef std::vector<Branch> Vector;
+
+public:
+  Branch(const uint64_t &default_minfreespace_);
+
+public:
+  enum class Mode
+    {
+     INVALID,
+     RO,
+     RW,
+     NC
+    };
+
+public:
+  bool ro(void) const;
+  bool nc(void) const;
+  bool ro_or_nc(void) const;
+
+public:
+  int from_string(const std::string &str) final;
+  std::string to_string(void) const final;
+
+public:
+  uint64_t minfreespace() const;
+  void set_minfreespace(const uint64_t);
+
+public:
+  Mode mode;
+  std::string path;
+
+private:
+  nonstd::optional<uint64_t>  _minfreespace;
+  const uint64_t             *_default_minfreespace;
+};

src/branches.cpp

@@ -0,0 +1,431 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "branches.hpp"
+#include "ef.hpp"
+#include "errno.hpp"
+#include "from_string.hpp"
+#include "fs_glob.hpp"
+#include "fs_realpathize.hpp"
+#include "nonstd/optional.hpp"
+#include "num.hpp"
+#include "str.hpp"
+
+#include <string>
+
+#include <fnmatch.h>
+
+using std::string;
+using std::vector;
+using nonstd::optional;
+
+
+Branches::Impl::Impl(const uint64_t &default_minfreespace_)
+  : _default_minfreespace(default_minfreespace_)
+{
+}
+
+Branches::Impl&
+Branches::Impl::operator=(Branches::Impl &rval_)
+{
+  auto this_base = dynamic_cast<Branch::Vector*>(this);
+  auto rval_base = dynamic_cast<Branch::Vector*>(&rval_);
+
+  *this_base = *rval_base;
+
+  return *this;
+}
+
+Branches::Impl&
+Branches::Impl::operator=(Branches::Impl &&rval_)
+{
+  auto this_base = dynamic_cast<Branch::Vector*>(this);
+  auto rval_base = dynamic_cast<Branch::Vector*>(&rval_);
+
+  *this_base = std::move(*rval_base);
+
+  return *this;
+}
+
+const
+uint64_t&
+Branches::Impl::minfreespace(void) const
+{
+  return _default_minfreespace;
+}
+
+namespace l
+{
+  static
+  void
+  split(const std::string &s_,
+        std::string       *instr_,
+        std::string       *values_)
+  {
+    uint64_t offset;
+
+    offset = s_.find_first_not_of("+<>-=");
+    if(offset > 1)
+      offset = 2;
+    *instr_ = s_.substr(0,offset);
+    if(offset != std::string::npos)
+      *values_ = s_.substr(offset);
+  }
+
+  static
+  int
+  parse_mode(const string &str_,
+             Branch::Mode *mode_)
+  {
+    if(str_ == "RW")
+      *mode_ = Branch::Mode::RW;
+    ef(str_ == "RO")
+      *mode_ = Branch::Mode::RO;
+    ef(str_ == "NC")
+      *mode_ = Branch::Mode::NC;
+    else
+      return -EINVAL;
+
+    return 0;
+  }
+
+  static
+  int
+  parse_minfreespace(const string       &str_,
+                     optional<uint64_t> *minfreespace_)
+  {
+    int rv;
+    uint64_t uint64;
+
+    rv = str::from(str_,&uint64);
+    if(rv < 0)
+      return rv;
+
+    *minfreespace_ = uint64;
+
+    return 0;
+  }
+
+  static
+  int
+  parse_branch(const string       &str_,
+               string             *glob_,
+               Branch::Mode       *mode_,
+               optional<uint64_t> *minfreespace_)
+  {
+    int rv;
+    string options;
+    vector<string> v;
+
+    str::rsplit1(str_,'=',&v);
+    switch(v.size())
+      {
+      case 1:
+        *glob_ = v[0];
+        *mode_ = Branch::Mode::RW;
+        break;
+      case 2:
+        *glob_  = v[0];
+        options = v[1];
+        v.clear();
+        str::split(options,',',&v);
+        switch(v.size())
+          {
+          case 2:
+            rv = l::parse_minfreespace(v[1],minfreespace_);
+            if(rv < 0)
+              return rv;
+          case 1:
+            rv = l::parse_mode(v[0],mode_);
+            if(rv < 0)
+              return rv;
+            break;
+          case 0:
+            return -EINVAL;
+          }
+        break;
+      default:
+        return -EINVAL;
+      }
+
+    return 0;
+  }
+
+  static
+  int
+  parse(const string   &str_,
+        Branches::Impl *branches_)
+  {
+    int rv;
+    string glob;
+    StrVec paths;
+    optional<uint64_t> minfreespace;
+    Branch branch(branches_->minfreespace());
+
+    rv = l::parse_branch(str_,&glob,&branch.mode,&minfreespace);
+    if(rv < 0)
+      return rv;
+
+    if(minfreespace.has_value())
+      branch.set_minfreespace(minfreespace.value());
+
+    fs::glob(glob,&paths);
+    fs::realpathize(&paths);
+    for(auto &path : paths)
+      {
+        branch.path = path;
+        branches_->push_back(branch);
+      }
+
+    return 0;
+  }
+
+  static
+  int
+  set(const std::string &str_,
+      Branches::Impl    *branches_)
+  {
+    int rv;
+    StrVec paths;
+    Branches::Impl tmp_branches(branches_->minfreespace());
+
+    str::split(str_,':',&paths);
+    for(auto &path : paths)
+      {
+        rv = l::parse(path,&tmp_branches);
+        if(rv < 0)
+          return rv;
+      }
+
+    *branches_ = std::move(tmp_branches);
+
+    return 0;
+  }
+
+  static
+  int
+  add_begin(const std::string &str_,
+            Branches::Impl    *branches_)
+  {
+    int rv;
+    vector<string> paths;
+    Branches::Impl tmp_branches(branches_->minfreespace());
+
+    str::split(str_,':',&paths);
+    for(auto &path : paths)
+      {
+        rv = l::parse(path,&tmp_branches);
+        if(rv < 0)
+          return rv;
+      }
+
+    branches_->insert(branches_->begin(),
+                      tmp_branches.begin(),
+                      tmp_branches.end());
+
+    return 0;
+  }
+
+  static
+  int
+  add_end(const std::string &str_,
+          Branches::Impl    *branches_)
+  {
+    int rv;
+    StrVec paths;
+    Branches::Impl tmp_branches(branches_->minfreespace());
+
+    str::split(str_,':',&paths);
+    for(auto &path : paths)
+      {
+        rv = l::parse(path,&tmp_branches);
+        if(rv < 0)
+          return rv;
+      }
+
+    branches_->insert(branches_->end(),
+                      tmp_branches.begin(),
+                      tmp_branches.end());
+
+    return 0;
+  }
+
+  static
+  int
+  erase_begin(Branches::Impl *branches_)
+  {
+    branches_->erase(branches_->begin());
+
+    return 0;
+  }
+
+  static
+  int
+  erase_end(Branches::Impl *branches_)
+  {
+    branches_->pop_back();
+
+    return 0;
+  }
+
+  static
+  int
+  erase_fnmatch(const std::string &str_,
+                Branches::Impl    *branches_)
+  {
+    StrVec patterns;
+
+    str::split(str_,':',&patterns);
+    for(auto i = branches_->begin(); i != branches_->end();)
+      {
+        int match = FNM_NOMATCH;
+
+        for(auto pi = patterns.cbegin(); pi != patterns.cend() && match != 0; ++pi)
+          {
+            match = ::fnmatch(pi->c_str(),i->path.c_str(),0);
+          }
+
+        i = ((match == 0) ? branches_->erase(i) : (i+1));
+      }
+
+    return 0;
+  }
+}
+
+int
+Branches::Impl::from_string(const std::string &s_)
+{
+  std::string instr;
+  std::string values;
+
+  l::split(s_,&instr,&values);
+
+  if(instr == "+")
+    return l::add_end(values,this);
+  if(instr == "+<")
+    return l::add_begin(values,this);
+  if(instr == "+>")
+    return l::add_end(values,this);
+  if(instr == "-")
+    return l::erase_fnmatch(values,this);
+  if(instr == "-<")
+    return l::erase_begin(this);
+  if(instr == "->")
+    return l::erase_end(this);
+  if(instr == "=")
+    return l::set(values,this);
+  if(instr.empty())
+    return l::set(values,this);
+
+  return -EINVAL;
+}
+
+std::string
+Branches::Impl::to_string(void) const
+{
+  string tmp;
+
+  if(empty())
+    return tmp;
+
+  for(auto &branch : *this)
+    {
+      tmp += branch.to_string();
+      tmp += ':';
+    }
+
+  tmp.pop_back();
+
+  return tmp;
+}
+
+void
+Branches::Impl::to_paths(StrVec &paths_) const
+{
+  for(auto &branch : *this)
+    {
+      paths_.push_back(branch.path);
+    }
+}
+
+int
+Branches::from_string(const std::string &str_)
+{
+  int rv;
+  Branches::Ptr impl;
+  Branches::Ptr new_impl;
+
+  {
+    std::lock_guard<std::mutex> lock_guard(_mutex);
+    impl = _impl;
+  }
+
+  new_impl = std::make_shared<Branches::Impl>(impl->minfreespace());
+  *new_impl = *impl;
+
+  rv = new_impl->from_string(str_);
+  if(rv < 0)
+    return rv;
+
+  {
+    std::lock_guard<std::mutex> lock_guard(_mutex);
+    _impl = new_impl;
+  }
+
+  return 0;
+}
+
+string
+Branches::to_string(void) const
+{
+  std::lock_guard<std::mutex> lock_guard(_mutex);
+
+  return _impl->to_string();
+}
+
+SrcMounts::SrcMounts(Branches &b_)
+  : _branches(b_)
+{
+
+}
+
+int
+SrcMounts::from_string(const std::string &s_)
+{
+  return _branches.from_string(s_);
+}
+
+std::string
+SrcMounts::to_string(void) const
+{
+  std::string rv;
+  Branches::CPtr branches = _branches;
+
+  if(branches->empty())
+    return rv;
+
+  for(const auto &branch : *branches)
+    {
+      rv += branch.path;
+      rv += ':';
+    }
+
+  rv.pop_back();
+
+  return rv;
+}

src/branches.hpp

@@ -0,0 +1,94 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "branch.hpp"
+#include "nonstd/optional.hpp"
+#include "strvec.hpp"
+#include "tofrom_string.hpp"
+
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+
+
+class Branches final : public ToFromString
+{
+public:
+  class Impl final : public ToFromString, public Branch::Vector
+  {
+  public:
+    typedef std::shared_ptr<Impl> Ptr;
+    typedef std::shared_ptr<const Impl> CPtr;
+
+  public:
+    Impl(const uint64_t &default_minfreespace_);
+
+  public:
+    int from_string(const std::string &str) final;
+    std::string to_string(void) const final;
+
+  public:
+    const uint64_t& minfreespace(void) const;
+    void to_paths(StrVec &strvec) const;
+
+  public:
+    Impl& operator=(Impl &impl_);
+    Impl& operator=(Impl &&impl_);
+
+  private:
+    const uint64_t &_default_minfreespace;
+  };
+
+public:
+  typedef Branches::Impl::Ptr  Ptr;
+  typedef Branches::Impl::CPtr CPtr;
+
+public:
+  Branches(const uint64_t &default_minfreespace_)
+    : _impl(std::make_shared<Impl>(default_minfreespace_))
+  {}
+
+public:
+  int from_string(const std::string &str) final;
+  std::string to_string(void) const final;
+
+public:
+  operator CPtr()   const { std::lock_guard<std::mutex> lg(_mutex); return _impl; }
+  CPtr operator->() const { std::lock_guard<std::mutex> lg(_mutex); return _impl; }
+
+private:
+  mutable std::mutex _mutex;
+  Ptr                _impl;
+};
+
+class SrcMounts : public ToFromString
+{
+public:
+  SrcMounts(Branches &b_);
+
+public:
+  int from_string(const std::string &str) final;
+  std::string to_string(void) const final;
+
+private:
+  Branches &_branches;
+};

src/buildmap.hpp

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

src/buildvector.hpp

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

src/category.cpp

@@ -1,70 +1,49 @@
 /*
-  The MIT License (MIT)
+  ISC License
 
-  Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
 
-  Permission is hereby granted, free of charge, to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction, including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#include <string>
-#include <vector>
-
 #include "category.hpp"
-#include "buildvector.hpp"
+#include "errno.hpp"
+#include "str.hpp"
 
-#define CATEGORY(X) Category(Category::Enum::X,#X)
+#include <string>
 
-namespace mergerfs
+int
+Category::Base::from_string(const std::string &s_)
 {
-  const std::vector<Category> Category::_categories_ =
-    buildvector<Category,true>
-    (CATEGORY(invalid))
-    (CATEGORY(action))
-    (CATEGORY(create))
-    (CATEGORY(search));
+  int rv;
 
-  const Category * const Category::categories = &_categories_[1];
+  for(auto func : funcs)
+    {
+      rv = func->from_string(s_);
+      if(rv < 0)
+        return rv;
+    }
 
-  const Category &Category::invalid = Category::categories[Category::Enum::invalid];
-  const Category &Category::action  = Category::categories[Category::Enum::action];
-  const Category &Category::create  = Category::categories[Category::Enum::create];
-  const Category &Category::search  = Category::categories[Category::Enum::search];
+  return 0;
+}
 
-  const Category&
-  Category::find(const std::string &str)
-  {
-    for(int i = Enum::BEGIN; i != Enum::END; ++i)
-      {
-        if(categories[i] == str)
-          return categories[i];
-      }
+std::string
+Category::Base::to_string(void) const
+{
+  std::set<std::string> rv;
 
-    return invalid;
-  }
+  for(const auto func : funcs)
+    rv.insert(func->to_string());
 
-  const Category&
-  Category::find(const Category::Enum::Type i)
-  {
-    if(i >= Category::Enum::BEGIN &&
-       i  < Category::Enum::END)
-      return categories[i];
-
-    return invalid;
-  }
+  return str::join(rv,',');
 }

src/category.hpp

@@ -1,98 +1,107 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#ifndef __CATEGORY_HPP__
-#define __CATEGORY_HPP__
+#pragma once
+
+#include "tofrom_string.hpp"
+#include "funcs.hpp"
+#include "func.hpp"
 
 #include <string>
-#include <vector>
 
-namespace mergerfs
+namespace Category
 {
-  class Category
+  class Base : public ToFromString
   {
   public:
-    struct Enum
-    {
-      enum Type
-        {
-          invalid = -1,
-          BEGIN   = 0,
-          action  = BEGIN,
-          create,
-          search,
-          END
-        };
-    };
+    int from_string(const std::string &s) final;
+    std::string to_string() const final;
 
+  protected:
+    std::vector<ToFromString*> funcs;
+  };
+
+  class Action final : public Base
+  {
   private:
-    Enum::Type  _enum;
-    std::string _str;
+    Action();
 
   public:
-    Category()
-      : _enum(invalid),
-        _str(invalid)
+    Action(Funcs &funcs_)
     {
+      funcs.push_back(&funcs_.chmod);
+      funcs.push_back(&funcs_.chown);
+      funcs.push_back(&funcs_.link);
+      funcs.push_back(&funcs_.removexattr);
+      funcs.push_back(&funcs_.rename);
+      funcs.push_back(&funcs_.rmdir);
+      funcs.push_back(&funcs_.setxattr);
+      funcs.push_back(&funcs_.truncate);
+      funcs.push_back(&funcs_.unlink);
+      funcs.push_back(&funcs_.utimens);
     }
+  };
 
-    Category(const Enum::Type   enum_,
-             const std::string &str_)
-      : _enum(enum_),
-        _str(str_)
+  class Create final : public Base
+  {
+  private:
+    Create();
+
+  public:
+    Create(Funcs &funcs_)
     {
+      funcs.push_back(&funcs_.create);
+      funcs.push_back(&funcs_.mkdir);
+      funcs.push_back(&funcs_.mknod);
+      funcs.push_back(&funcs_.symlink);
     }
+  };
+
+  class Search final : public Base
+  {
+  private:
+    Search();
 
   public:
-    operator const Enum::Type() const { return _enum; }
-    operator const std::string&() const { return _str; }
-    operator const Category*() const { return this; }
-
-    bool operator==(const std::string &str_) const
-    { return _str == str_; }
-
-    bool operator==(const Enum::Type enum_) const
-    { return _enum == enum_; }
-
-    bool operator!=(const Category &r) const
-    { return _enum != r._enum; }
-
-    bool operator<(const Category &r) const
-    { return _enum < r._enum; }
-
-  public:
-    static const Category &find(const std::string&);
-    static const Category &find(const Enum::Type);
-
-  public:
-    static const std::vector<Category>  _categories_;
-    static const Category * const       categories;
-    static const Category              &invalid;
-    static const Category              &action;
-    static const Category              &create;
-    static const Category              &search;
+    Search(Funcs &funcs_)
+    {
+      funcs.push_back(&funcs_.access);
+      funcs.push_back(&funcs_.getattr);
+      funcs.push_back(&funcs_.getxattr);
+      funcs.push_back(&funcs_.listxattr);
+      funcs.push_back(&funcs_.open);
+      funcs.push_back(&funcs_.readlink);
+    }
   };
 }
 
-#endif
+class Categories final
+{
+private:
+  Categories();
+
+public:
+  Categories(Funcs &funcs_)
+    : action(funcs_),
+      create(funcs_),
+      search(funcs_)
+  {}
+
+public:
+  Category::Action action;
+  Category::Create create;
+  Category::Search search;
+};

src/chmod.cpp

@@ -1,89 +0,0 @@
-/*
-   The MIT License (MIT)
-
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
-
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
-*/
-
-#include <fuse.h>
-
-#include <errno.h>
-#include <string>
-#include <vector>
-
-#include "ugid.hpp"
-#include "fs.hpp"
-#include "config.hpp"
-#include "rwlock.hpp"
-
-using std::string;
-using std::vector;
-using mergerfs::Policy;
-
-static
-int
-_chmod(Policy::Func::Action  actionFunc,
-       const vector<string> &srcmounts,
-       const size_t          minfreespace,
-       const string         &fusepath,
-       const mode_t          mode)
-{
-  int rv;
-  int error;
-  vector<string> paths;
-
-  rv = actionFunc(srcmounts,fusepath,minfreespace,paths);
-  if(rv == -1)
-    return -errno;
-
-  error = 0;
-  for(size_t i = 0, ei = paths.size(); i != ei; i++)
-    {
-      fs::path::append(paths[i],fusepath);
-
-      rv = ::chmod(paths[i].c_str(),mode);
-      if(rv == -1)
-        error = errno;
-    }
-
-  return -error;
-}
-
-namespace mergerfs
-{
-  namespace chmod
-  {
-    int
-    chmod(const char *fusepath,
-          mode_t      mode)
-    {
-      const struct fuse_context *fc     = fuse_get_context();
-      const config::Config      &config = config::get();
-      const ugid::SetResetGuard  ugid(fc->uid,fc->gid);
-      const rwlock::ReadGuard    readlock(&config.srcmountslock);
-
-      return _chmod(config.chmod,
-                    config.srcmounts,
-                    config.minfreespace,
-                    fusepath,
-                    mode);
-    }
-  }
-}

src/chmod.hpp

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

src/chown.cpp

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

src/chown.hpp

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

src/clonepath.cpp

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

src/clonepath.hpp

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

src/config.cpp

@@ -1,141 +1,401 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#include <string>
-#include <vector>
-
-#include <unistd.h>
-#include <sys/stat.h>
-#include <errno.h>
-
 #include "config.hpp"
+#include "ef.hpp"
+#include "errno.hpp"
+#include "from_string.hpp"
+#include "num.hpp"
 #include "rwlock.hpp"
-#include "fs.hpp"
+#include "str.hpp"
+#include "to_string.hpp"
+#include "version.hpp"
 
-#define POLICYINIT(X) X(policies[FuseFunc::Enum::X])
+#include <algorithm>
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <string>
+
+#include <pthread.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#define MINFREESPACE_DEFAULT (4294967295ULL)
 
 using std::string;
-using std::vector;
 
-namespace mergerfs
+#define IFERT(S) if(S == s_) return true
+
+const std::string CONTROLFILE = "/.mergerfs";
+
+Config Config::_singleton;
+
+
+namespace l
 {
-  namespace config
+  static
+  bool
+  readonly(const std::string &s_)
   {
-    Config::Config()
-      : destmount(),
-        srcmounts(),
-        srcmountslock(),
-        minfreespace(UINT32_MAX),
-        POLICYINIT(access),
-        POLICYINIT(chmod),
-        POLICYINIT(chown),
-        POLICYINIT(create),
-        POLICYINIT(getattr),
-        POLICYINIT(getxattr),
-        POLICYINIT(link),
-        POLICYINIT(listxattr),
-        POLICYINIT(mkdir),
-        POLICYINIT(mknod),
-        POLICYINIT(open),
-        POLICYINIT(readlink),
-        POLICYINIT(removexattr),
-        POLICYINIT(rename),
-        POLICYINIT(rmdir),
-        POLICYINIT(setxattr),
-        POLICYINIT(symlink),
-        POLICYINIT(truncate),
-        POLICYINIT(unlink),
-        POLICYINIT(utimens),
-        controlfile("/.mergerfs")
-    {
-      pthread_rwlock_init(&srcmountslock,NULL);
+    IFERT("async_read");
+    IFERT("cache.symlinks");
+    IFERT("cache.writeback");
+    IFERT("fsname");
+    IFERT("fuse_msg_size");
+    IFERT("mount");
+    IFERT("nullrw");
+    IFERT("pid");
+    IFERT("readdirplus");
+    IFERT("threads");
+    IFERT("version");
 
-      set_category_policy("action","all");
-      set_category_policy("create","epmfs");
-      set_category_policy("search","ff");
-    }
-
-    int
-    Config::set_func_policy(const string &fusefunc_,
-                            const string &policy_)
-    {
-      const Policy   *policy;
-      const FuseFunc *fusefunc;
-
-      fusefunc = FuseFunc::find(fusefunc_);
-      if(fusefunc == FuseFunc::invalid)
-        return (errno=ENODATA,-1);
-
-      policy = Policy::find(policy_);
-      if(policy == Policy::invalid)
-        return (errno=EINVAL,-1);
-
-      policies[(FuseFunc::Enum::Type)*fusefunc] = policy;
-
-      return 0;
-    }
-
-    int
-    Config::set_category_policy(const string &category_,
-                                const string &policy_)
-    {
-      const Policy   *policy;
-      const Category *category;
-
-      category = Category::find(category_);
-      if(category == Category::invalid)
-        return (errno=ENODATA,-1);
-
-      policy = Policy::find(policy_);
-      if(policy == Policy::invalid)
-        return (errno=EINVAL,-1);
-
-      for(int i = 0; i < FuseFunc::Enum::END; i++)
-        {
-          if(FuseFunc::fusefuncs[i] == (Category::Enum::Type)*category)
-            policies[(FuseFunc::Enum::Type)FuseFunc::fusefuncs[i]] = policy;
-        }
-
-      return 0;
-    }
-
-    const Config&
-    get(const struct fuse_context *fc)
-    {
-      return *((Config*)fc->private_data);
-    }
-
-    const Config&
-    get(void)
-    {
-      return get(fuse_get_context());
-    }
-
-    Config&
-    get_writable(void)
-    {
-      return (*((Config*)fuse_get_context()->private_data));
-    }
+    return false;
   }
 }
+
+Config::Config()
+  : async_read(true),
+    auto_cache(false),
+    minfreespace(MINFREESPACE_DEFAULT),
+    branches(minfreespace),
+    cache_attr(1),
+    cache_entry(1),
+    cache_files(CacheFiles::ENUM::LIBFUSE),
+    cache_negative_entry(0),
+    cache_readdir(false),
+    cache_statfs(0),
+    cache_symlinks(false),
+    category(func),
+    direct_io(false),
+    dropcacheonclose(false),
+    fsname(),
+    follow_symlinks(FollowSymlinks::ENUM::NEVER),
+    func(),
+    fuse_msg_size(FUSE_MAX_MAX_PAGES),
+    ignorepponrename(false),
+    inodecalc("hybrid-hash"),
+    link_cow(false),
+    link_exdev(LinkEXDEV::ENUM::PASSTHROUGH),
+    log_metrics(false),
+    mount(),
+    moveonenospc(false),
+    nfsopenhack(NFSOpenHack::ENUM::OFF),
+    nullrw(false),
+    pid(::getpid()),
+    posix_acl(false),
+    readdir(ReadDir::ENUM::POSIX),
+    readdirplus(false),
+    rename_exdev(RenameEXDEV::ENUM::PASSTHROUGH),
+    security_capability(true),
+    srcmounts(branches),
+    statfs(StatFS::ENUM::BASE),
+    statfs_ignore(StatFSIgnore::ENUM::NONE),
+    symlinkify(false),
+    symlinkify_timeout(3600),
+    threads(0),
+    version(MERGERFS_VERSION),
+    writeback_cache(false),
+    xattr(XAttr::ENUM::PASSTHROUGH)
+{
+  _map["async_read"]           = &async_read;
+  _map["auto_cache"]           = &auto_cache;
+  _map["branches"]             = &branches;
+  _map["cache.attr"]           = &cache_attr;
+  _map["cache.entry"]          = &cache_entry;
+  _map["cache.files"]          = &cache_files;
+  _map["cache.negative_entry"] = &cache_negative_entry;
+  _map["cache.readdir"]        = &cache_readdir;
+  _map["cache.statfs"]         = &cache_statfs;
+  _map["cache.symlinks"]       = &cache_symlinks;
+  _map["cache.writeback"]      = &writeback_cache;
+  _map["category.action"]      = &category.action;
+  _map["category.create"]      = &category.create;
+  _map["category.search"]      = &category.search;
+  _map["direct_io"]            = &direct_io;
+  _map["dropcacheonclose"]     = &dropcacheonclose;
+  _map["follow-symlinks"]      = &follow_symlinks;
+  _map["fsname"]               = &fsname;
+  _map["func.access"]          = &func.access;
+  _map["func.chmod"]           = &func.chmod;
+  _map["func.chown"]           = &func.chown;
+  _map["func.create"]          = &func.create;
+  _map["func.getattr"]         = &func.getattr;
+  _map["func.getxattr"]        = &func.getxattr;
+  _map["func.link"]            = &func.link;
+  _map["func.listxattr"]       = &func.listxattr;
+  _map["func.mkdir"]           = &func.mkdir;
+  _map["func.mknod"]           = &func.mknod;
+  _map["func.open"]            = &func.open;
+  _map["func.readlink"]        = &func.readlink;
+  _map["func.removexattr"]     = &func.removexattr;
+  _map["func.rename"]          = &func.rename;
+  _map["func.rmdir"]           = &func.rmdir;
+  _map["func.setxattr"]        = &func.setxattr;
+  _map["func.symlink"]         = &func.symlink;
+  _map["func.truncate"]        = &func.truncate;
+  _map["func.unlink"]          = &func.unlink;
+  _map["func.utimens"]         = &func.utimens;
+  _map["fuse_msg_size"]        = &fuse_msg_size;
+  _map["ignorepponrename"]     = &ignorepponrename;
+  _map["inodecalc"]            = &inodecalc;
+  _map["kernel_cache"]         = &kernel_cache;
+  _map["link_cow"]             = &link_cow;
+  _map["link-exdev"]           = &link_exdev;
+  _map["log.metrics"]          = &log_metrics;
+  _map["minfreespace"]         = &minfreespace;
+  _map["mount"]                = &mount;
+  _map["moveonenospc"]         = &moveonenospc;
+  _map["nfsopenhack"]          = &nfsopenhack;
+  _map["nullrw"]               = &nullrw;
+  _map["pid"]                  = &pid;
+  _map["posix_acl"]            = &posix_acl;
+  //  _map["readdir"]              = &readdir;
+  _map["readdirplus"]          = &readdirplus;
+  _map["rename-exdev"]         = &rename_exdev;
+  _map["security_capability"]  = &security_capability;
+  _map["srcmounts"]            = &srcmounts;
+  _map["statfs"]               = &statfs;
+  _map["statfs_ignore"]        = &statfs_ignore;
+  _map["symlinkify"]           = &symlinkify;
+  _map["symlinkify_timeout"]   = &symlinkify_timeout;
+  _map["threads"]              = &threads;
+  _map["version"]              = &version;
+  _map["xattr"]                = &xattr;
+}
+
+Config&
+Config::operator=(const Config &cfg_)
+{
+  int rv;
+  std::string val;
+
+  for(auto &kv : _map)
+    {
+      rv = cfg_.get(kv.first,&val);
+      if(rv)
+        continue;
+
+      kv.second->from_string(val);
+    }
+
+  return *this;
+}
+
+bool
+Config::has_key(const std::string &key_) const
+{
+  return _map.count(key_);
+}
+
+void
+Config::keys(std::string &s_) const
+{
+  Str2TFStrMap::const_iterator i;
+  Str2TFStrMap::const_iterator ei;
+
+  s_.reserve(512);
+
+  i  = _map.begin();
+  ei = _map.end();
+
+  for(; i != ei; ++i)
+    {
+      s_ += i->first;
+      s_ += '\0';
+    }
+
+  s_.resize(s_.size() - 1);
+}
+
+
+void
+Config::keys_xattr(std::string &s_) const
+{
+  Str2TFStrMap::const_iterator i;
+  Str2TFStrMap::const_iterator ei;
+
+  s_.reserve(1024);
+  for(i = _map.begin(), ei = _map.end(); i != ei; ++i)
+    {
+      s_ += "user.mergerfs.";
+      s_ += i->first;
+      s_ += '\0';
+    }
+}
+
+int
+Config::get(const std::string &key_,
+            std::string       *val_) const
+{
+  Str2TFStrMap::const_iterator i;
+
+  i = _map.find(key_);
+  if(i == _map.end())
+    return -ENOATTR;
+
+  *val_ = i->second->to_string();
+
+  return 0;
+}
+
+int
+Config::set_raw(const std::string &key_,
+                const std::string &value_)
+{
+  Str2TFStrMap::iterator i;
+
+  i = _map.find(key_);
+  if(i == _map.end())
+    return -ENOATTR;
+
+  return i->second->from_string(value_);
+}
+
+int
+Config::set(const std::string &key_,
+            const std::string &value_)
+{
+  if(l::readonly(key_))
+    return -EROFS;
+
+  return set_raw(key_,value_);
+}
+
+int
+Config::set(const std::string &kv_)
+{
+  std::string key;
+  std::string val;
+
+  str::splitkv(kv_,'=',&key,&val);
+  key = str::trim(key);
+  val = str::trim(val);
+
+  return set(key,val);
+}
+
+int
+Config::from_stream(std::istream &istrm_,
+                    ErrVec       *errs_)
+{
+  int rv;
+  std::string line;
+  std::string key;
+  std::string val;
+  Config newcfg;
+
+  newcfg = *this;
+
+  while(std::getline(istrm_,line,'\n'))
+    {
+      line = str::trim(line);
+      if(!line.empty() && (line[0] == '#'))
+        continue;
+
+      str::splitkv(line,'=',&key,&val);
+      key = str::trim(key);
+      val = str::trim(val);
+
+      rv = newcfg.set(key,val);
+      if(rv < 0)
+        errs_->push_back({rv,key});
+    }
+
+  if(!errs_->empty())
+    return -EINVAL;
+
+  *this = newcfg;
+
+  return 0;
+}
+
+int
+Config::from_file(const std::string &filepath_,
+                  ErrVec            *errs_)
+{
+  int rv;
+  std::ifstream ifstrm;
+
+  ifstrm.open(filepath_);
+  if(!ifstrm.good())
+    {
+      errs_->push_back({-errno,filepath_});
+      return -errno;
+    }
+
+  rv = from_stream(ifstrm,errs_);
+
+  ifstrm.close();
+
+  return rv;
+}
+
+std::ostream&
+operator<<(std::ostream &os_,
+           const Config &c_)
+{
+  Str2TFStrMap::const_iterator i;
+  Str2TFStrMap::const_iterator ei;
+
+  for(i = c_._map.begin(), ei = c_._map.end(); i != ei; ++i)
+    {
+      os_ << i->first << '=' << i->second->to_string() << std::endl;
+    }
+
+  return os_;
+}
+
+
+static
+std::string
+err2str(const int err_)
+{
+  switch(err_)
+    {
+    case 0:
+      return std::string();
+    case -EINVAL:
+      return "invalid value";
+    case -ENOATTR:
+      return "unknown option";
+    case -EROFS:
+      return "read-only option";
+    default:
+      return strerror(-err_);
+    }
+
+  return std::string();
+}
+
+std::ostream&
+operator<<(std::ostream         &os_,
+           const Config::ErrVec &ev_)
+{
+  std::string errstr;
+
+  for(auto &err : ev_)
+    {
+      os_ << "* ERROR: ";
+      errstr = err2str(err.err);
+      if(!errstr.empty())
+        os_ << errstr << " - ";
+      os_ << err.str << std::endl;
+    }
+
+  return os_;
+}

src/config.hpp

@@ -1,93 +1,205 @@
 /*
-   The MIT License (MIT)
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
-   Copyright (c) 2014 Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
 
-   Permission is hereby granted, free of charge, to any person obtaining a copy
-   of this software and associated documentation files (the "Software"), to deal
-   in the Software without restriction, including without limitation the rights
-   to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-   copies of the Software, and to permit persons to whom the Software is
-   furnished to do so, subject to the following conditions:
-
-   The above copyright notice and this permission notice shall be included in
-   all copies or substantial portions of the Software.
-
-   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-   THE SOFTWARE.
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#ifndef __CONFIG_HPP__
-#define __CONFIG_HPP__
+#pragma once
 
-#include <fuse.h>
+#include "branches.hpp"
+#include "category.hpp"
+#include "config_cachefiles.hpp"
+#include "config_follow_symlinks.hpp"
+#include "config_inodecalc.hpp"
+#include "config_link_exdev.hpp"
+#include "config_log_metrics.hpp"
+#include "config_moveonenospc.hpp"
+#include "config_nfsopenhack.hpp"
+#include "config_readdir.hpp"
+#include "config_rename_exdev.hpp"
+#include "config_statfs.hpp"
+#include "config_statfsignore.hpp"
+#include "config_xattr.hpp"
+#include "enum.hpp"
+#include "errno.hpp"
+#include "funcs.hpp"
+#include "policy.hpp"
+#include "rwlock.hpp"
+#include "tofrom_wrapper.hpp"
 
-#include <sys/stat.h>
-#include <stdint.h>
+#include "fuse.h"
 
+#include <cstdint>
+#include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
-#include "policy.hpp"
-#include "fusefunc.hpp"
+#include <sys/stat.h>
 
-namespace mergerfs
+typedef ToFromWrapper<bool>                 ConfigBOOL;
+typedef ToFromWrapper<uint64_t>             ConfigUINT64;
+typedef ToFromWrapper<int>                  ConfigINT;
+typedef ToFromWrapper<std::string>          ConfigSTR;
+typedef std::map<std::string,ToFromString*> Str2TFStrMap;
+
+extern const std::string CONTROLFILE;
+
+class Config
 {
-  namespace config
+public:
+  struct Err
   {
-    class Config
-    {
-    public:
-      Config();
+    int err;
+    std::string str;
+  };
 
-    public:
-      int set_func_policy(const std::string &fusefunc_,
-                          const std::string &policy_);
-      int set_category_policy(const std::string &category,
-                              const std::string &policy);
+  typedef std::vector<Err> ErrVec;
 
-    public:
-      std::string              destmount;
-      std::vector<std::string> srcmounts;
-      mutable pthread_rwlock_t srcmountslock;
-      size_t                   minfreespace;
+public:
+  class Read
+  {
+  public:
+    Read();
 
-    public:
-      const Policy  *policies[FuseFunc::Enum::END];
-      const Policy *&access;
-      const Policy *&chmod;
-      const Policy *&chown;
-      const Policy *&create;
-      const Policy *&getattr;
-      const Policy *&getxattr;
-      const Policy *&link;
-      const Policy *&listxattr;
-      const Policy *&mkdir;
-      const Policy *&mknod;
-      const Policy *&open;
-      const Policy *&readlink;
-      const Policy *&removexattr;
-      const Policy *&rename;
-      const Policy *&rmdir;
-      const Policy *&setxattr;
-      const Policy *&symlink;
-      const Policy *&truncate;
-      const Policy *&unlink;
-      const Policy *&utimens;
+  public:
+    inline const Config* operator->() const;
 
-    public:
-      const std::string controlfile;
-    };
+  private:
+    const Config &_cfg;
+  };
+
+public:
+  class Write
+  {
+  public:
+    Write();
+
+  public:
+    Config* operator->();
+
+  private:
+    Config &_cfg;
+  };
+
+public:
+  Config();
+
+public:
+  Config& operator=(const Config&);
+
+public:
+  ConfigBOOL     async_read;
+  ConfigBOOL     auto_cache;
+  ConfigUINT64   minfreespace;
+  Branches       branches;
+  ConfigUINT64   cache_attr;
+  ConfigUINT64   cache_entry;
+  CacheFiles     cache_files;
+  ConfigUINT64   cache_negative_entry;
+  ConfigBOOL     cache_readdir;
+  ConfigUINT64   cache_statfs;
+  ConfigBOOL     cache_symlinks;
+  Categories     category;
+  ConfigBOOL     direct_io;
+  ConfigBOOL     dropcacheonclose;
+  ConfigSTR      fsname;
+  FollowSymlinks follow_symlinks;
+  Funcs          func;
+  ConfigUINT64   fuse_msg_size;
+  ConfigBOOL     ignorepponrename;
+  InodeCalc      inodecalc;
+  ConfigBOOL     kernel_cache;
+  ConfigBOOL     link_cow;
+  LinkEXDEV      link_exdev;
+  LogMetrics     log_metrics;
+  ConfigSTR      mount;
+  MoveOnENOSPC   moveonenospc;
+  NFSOpenHack    nfsopenhack;
+  ConfigBOOL     nullrw;
+  ConfigUINT64   pid;
+  ConfigBOOL     posix_acl;
+  ReadDir        readdir;
+  ConfigBOOL     readdirplus;
+  RenameEXDEV    rename_exdev;
+  ConfigBOOL     security_capability;
+  SrcMounts      srcmounts;
+  StatFS         statfs;
+  StatFSIgnore   statfs_ignore;
+  ConfigBOOL     symlinkify;
+  ConfigUINT64   symlinkify_timeout;
+  ConfigINT      threads;
+  ConfigSTR      version;
+  ConfigBOOL     writeback_cache;
+  XAttr          xattr;
+
+public:
+  friend std::ostream& operator<<(std::ostream &s,
+                                  const Config &c);
+
+public:
+  bool has_key(const std::string &key) const;
+  void keys(std::string &s) const;
+  void keys_xattr(std::string &s) const;
+
+public:
+  int get(const std::string &key, std::string *val) const;
+  int set_raw(const std::string &key, const std::string &val);
+  int set(const std::string &key, const std::string &val);
+  int set(const std::string &kv);
+
+public:
+  int from_stream(std::istream &istrm, ErrVec *errs);
+  int from_file(const std::string &filepath, ErrVec *errs);
+
+private:
+  Str2TFStrMap _map;
+
+private:
+  static Config _singleton;
+
+public:
+  friend class Read;
+  friend class Write;
+};
+
+std::ostream& operator<<(std::ostream &s,const Config::ErrVec &ev);
+
+inline
+Config::Read::Read()
+  : _cfg(Config::_singleton)
+{
 
-    const Config &get(const struct fuse_context *fc);
-    const Config &get(void);
-    Config       &get_writable(void);
-  }
 }
 
-#endif
+inline
+const
+Config*
+Config::Read::operator->() const
+{
+  return &_cfg;
+}
+
+inline
+Config::Write::Write()
+  : _cfg(Config::_singleton)
+{
+
+}
+
+inline
+Config*
+Config::Write::operator->()
+{
+  return &_cfg;
+}

src/config_cachefiles.cpp

@@ -0,0 +1,62 @@
+/*
+  ISC License
+
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "config_cachefiles.hpp"
+#include "ef.hpp"
+#include "errno.hpp"
+
+template<>
+std::string
+CacheFiles::to_string() const
+{
+  switch(_data)
+    {
+    case CacheFiles::ENUM::LIBFUSE:
+      return "libfuse";
+    case CacheFiles::ENUM::OFF:
+      return "off";
+    case CacheFiles::ENUM::PARTIAL:
+      return "partial";
+    case CacheFiles::ENUM::FULL:
+      return "full";
+    case CacheFiles::ENUM::AUTO_FULL:
+      return "auto-full";
+    }
+
+  return "invalid";
+}
+
+template<>
+int
+CacheFiles::from_string(const std::string &s_)
+{
+  if(s_ == "libfuse")
+    _data = CacheFiles::ENUM::LIBFUSE;
+  ef(s_ == "off")
+    _data = CacheFiles::ENUM::OFF;
+  ef(s_ == "partial")
+    _data = CacheFiles::ENUM::PARTIAL;
+  ef(s_ == "full")
+    _data = CacheFiles::ENUM::FULL;
+  ef(s_ == "auto-full")
+    _data = CacheFiles::ENUM::AUTO_FULL;
+  else
+    return -EINVAL;
+
+  return 0;
+}