fs_stat.hpp

Also have special error handling for when branches are invalid and
ENOENT would be returned for getattr and readdir so users understand
what is going on and the runtime interface can still be used to fix
the problem.

.cirrus.yml

@@ -0,0 +1,150 @@
+linux_task:
+  name: "alpine:latest"
+  container:
+    image: alpine:latest
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine-arm:latest"
+  arm_container:
+    image: alpine:latest
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "fedora:41"
+  container:
+    image: fedora:41
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora-arm:41"
+  arm_container:
+    image: fedora:41
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "ubuntu:22.04"
+  container:
+    image: ubuntu:22.04
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "ubuntu:24.04"
+  container:
+    image: ubuntu:24.04
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/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: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/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: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:12"
+  container:
+    image: debian:12
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/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: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/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: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+github: [trapexit]
+custom: ['https://github.com/trapexit/support']

.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 }}"

.github/workflows/mkdocs.yml

@@ -0,0 +1,49 @@
+name: "mkdocs"
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - '*'
+
+permissions:
+  contents: write
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.x'
+
+      - name: Configure Git Credentials
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+
+      - name: Install dependencies
+        working-directory: ./mkdocs
+        run: |
+          pip install --no-cache-dir mkdocs mkdocs-material pymdown-extensions mike
+
+      - name: Deploy docs
+        working-directory: ./mkdocs
+        env:
+          REF_TYPE: ${{ github.ref_type }}
+          REF_NAME: ${{ github.ref_name }}
+        run: |
+          if [ "$REF_TYPE" = "tag" ]; then
+            mike deploy "$REF_NAME" "latest" --allow-empty --ignore-remote-status --update-aliases
+            mike set-default "latest"
+            #git checkout gh-pages
+            #git push -f origin gh-pages
+          elif [ "$REF_TYPE" = "branch" ] && [ "$REF_NAME" = "master" ]; then
+            mike deploy "master" --ignore-remote-status --allow-empty
+            #git checkout gh-pages
+            #git push -f origin gh-pages
+          fi

.gitignore

@@ -23,3 +23,7 @@ debian/changelog
 
 # RPM files
 rpmbuild/
+
+# mkdocs files
+mkdocs/venv
+__pycache__/

DEPENDENCIES

@@ -0,0 +1,16 @@
+## Libraries
+
+### included in repo
+
+* libfuse: https://github.com/libfuse/libfuse (heavily modified fork of v2.x)
+* rapidhash: https://github.com/Nicoshev/rapidhash
+* fmt: https://github.com/fmtlib/fmt
+* concurrentqueue: https://github.com/cameron314/concurrentqueue
+* scope_guard: https://github.com/Neargye/scope_guard
+* subprocess: https://github.com/arun11299/cpp-subprocess
+* CLI11: https://github.com/CLIUtils/CLI11
+* boost
+  * download boost
+  * ./bootstrap.sh
+  * ./b2 tools/bcp
+  * ./dist/bin/bcp unordered/concurrent_flat_map.hpp <target_dir>

LICENSE

@@ -1,7 +1,7 @@
 /*
   ISC License
 
-  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+  Copyright (c) 2025, 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

Makefile

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+#  Copyright (c) 2024, 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
@@ -12,155 +12,202 @@
 #  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 #  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 
+GIT 	  = git
+TAR 	  = tar
+MKDIR     = mkdir
+TOUCH 	  = touch
+CP        = cp
+RM 	  = rm
+LN        = ln
+FIND 	  = find
+INSTALL   = install
+MKTEMP    = mktemp
+STRIP    ?= strip
+SED       = sed
+GIT2DEBCL = ./buildtools/git2debcl
+PKGCONFIG = pkg-config
 
-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)
-SED       =     $(shell which sed)
-GZIP      =     $(shell which gzip)
-RPMBUILD  =     $(shell which rpmbuild)
-GIT2DEBCL =     ./tools/git2debcl
-CPPFIND   =     ./tools/cppfind
-
-ifeq ($(PKGCONFIG),"")
-$(error "pkg-config not installed")
+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")
-endif
-
-XATTR_AVAILABLE = $(shell test ! -e /usr/include/attr/xattr.h; echo $$?)
-
-FUSE_AVAILABLE = $(shell ! pkg-config --exists fuse; echo $$?)
-
-ifeq ($(FUSE_AVAILABLE),0)
-FUSE_AVAILABLE = $(shell test ! -e /usr/include/fuse.h; echo $$?)
-endif
-
-ifeq ($(FUSE_AVAILABLE),0)
-$(error "FUSE development package doesn't appear available")
-endif
-
-FLAG_NOPATH = $(shell $(CPPFIND) "flag_nopath")
-FALLOCATE   = $(shell $(CPPFIND) "fuse_fs_fallocate")
-FLOCK       = $(shell $(CPPFIND) "fuse_fs_flock")
-READ_BUF    = $(shell $(CPPFIND) "fuse_fs_read_buf")
-WRITE_BUF   = $(shell $(CPPFIND) "fuse_fs_write_buf")
-
+USE_XATTR = 1
 UGID_USE_RWLOCK = 0
 
-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) \
-	      -Wno-unused-result \
-              $(FUSE_CFLAGS) \
-              -DFUSE_USE_VERSION=29 \
-              -MMD \
-	      -DFLAG_NOPATH=$(FLAG_NOPATH) \
-	      -DFALLOCATE=$(FALLOCATE) \
-              -DFLOCK=$(FLOCK) \
-	      -DREAD_BUF=$(READ_BUF) \
-              -DWRITE_BUF=$(WRITE_BUF) \
-	      -DUGID_USE_RWLOCK=$(UGID_USE_RWLOCK)
-LDFLAGS       = $(shell $(PKGCONFIG) fuse --libs)
+ifeq ($(NDEBUG),1)
+OPT_FLAGS := -O2 -DNDEBUG
+else
+OPT_FLAGS := -O0 -DDEBUG -g
+endif
 
+ifeq ($(STATIC),1)
+STATIC_FLAGS := -static
+else
+STATIC_FLAGS :=
+endif
+
+ifeq ($(LTO),1)
+LTO_FLAGS := -flto
+else
+LTO_FLAGS :=
+endif
+
+SRC	    = $(wildcard src/*.cpp)
+OBJS        = $(SRC:src/%.cpp=build/.src/%.o)
+DEPS        = $(SRC:src/%.cpp=build/.src/%.d)
+
+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)
+
+MANPAGE     = mergerfs.1
+CFLAGS      ?= ${OPT_FLAGS}
+CFLAGS      := ${CFLAGS} \
+               -Wall \
+               -Wno-unused-result
+CXXFLAGS    ?= ${OPT_FLAGS}
+CXXFLAGS    := \
+              ${CXXFLAGS} \
+              -std=c++17 \
+	      -fno-rtti \
+              $(STATIC_FLAGS) \
+              $(LTO_FLAGS) \
+	      -Isrc \
+              -Wall \
+              -Wno-unused-result \
+              -MMD
+FUSE_FLAGS = \
+              -Ilibfuse/include \
+              -D_FILE_OFFSET_BITS=64
+MFS_FLAGS  = \
+	      -DUSE_XATTR=$(USE_XATTR) \
+	      -DUGID_USE_RWLOCK=$(UGID_USE_RWLOCK)
+TESTS_FLAGS = \
+              -Isrc \
+              -DTESTS
+
+LDFLAGS := \
+    ${LDFLAGS} \
+    -pthread \
+    -lrt \
+    -lstdc++fs
+
+# https://www.gnu.org/prep/standards/html_node/Directory-Variables.html
+DESTDIR       =
 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
 DATAROOTDIR   = $(PREFIX)/share
 DATADIR       = $(DATAROOTDIR)
 BINDIR        = $(EXEC_PREFIX)/bin
 SBINDIR       = $(EXEC_PREFIX)/sbin
+LIBDIR        = $(EXEC_PREFIX)/lib
 MANDIR        = $(DATAROOTDIR)/man
 MAN1DIR       = $(MANDIR)/man1
 
 INSTALLBINDIR  = $(DESTDIR)$(BINDIR)
 INSTALLSBINDIR = $(DESTDIR)$(SBINDIR)
+INSTALLLIBDIR  = $(DESTDIR)$(LIBDIR)/mergerfs
 INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)
 
-ifeq ($(XATTR_AVAILABLE),0)
-$(warning "xattr not available: disabling")
-CFLAGS += -DWITHOUT_XATTR
-endif
-
-all: $(TARGET)
+.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): src/version.hpp obj/obj-stamp $(OBJ)
-	$(CXX) $(CFLAGS) $(OBJ) -o $@ $(LDFLAGS)
+objects: version build/stamp
+	$(MAKE) $(OBJS)
 
-mount.mergerfs: $(TARGET)
-	$(LN) -fs "$<" "$@"
+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
+	ln -fs "mergerfs" "build/fsck.mergerfs"
+	ln -fs "mergerfs" "build/mergerfs.collect-info"
+
+tests: build/tests
 
 changelog:
-	$(GIT2DEBCL) --name $(TARGET) > ChangeLog
+ifeq ($(GIT_REPO),1)
+	$(GIT2DEBCL) --name mergerfs > ChangeLog
+else
+	@echo "WARNING: need git repo to generate ChangeLog"
+endif
 
-authors:
-	$(GIT) log --format='%aN <%aE>' | sort -f | uniq > AUTHORS
+.PHONY: version
+version:
+	./buildtools/update-version
 
-src/version.hpp:
-	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
-	@echo "#ifndef _VERSION_HPP" > src/version.hpp
-	@echo "#define _VERSION_HPP" >> src/version.hpp
-	@echo "static const char MERGERFS_VERSION[] = \"$(VERSION)\";" >> src/version.hpp
-	@echo "#endif" >> src/version.hpp
-
-obj/obj-stamp:
-	$(MKDIR) -p obj
+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 $@
 
+build/.tests/%.o: tests/%.cpp
+	$(CXX) $(CXXFLAGS) $(TESTS_FLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) -c $< -o $@
+
+build/preload.so: build/stamp tools/preload.c
+	$(CC) -shared -fPIC $(CFLAGS) $(CPPFLAGS) -o $@ tools/preload.c
+
+preload: build/preload.so
+
+.PHONY: clean
 clean: rpm-clean
-	$(RM) -rf obj
-	$(RM) -f src/version.hpp
-	$(RM) -f "$(TARGET)" mount.mergerfs
+	$(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-mount.mergerfs install-man
+.PHONY: install
+install: install-base install-mount-tools install-preload install-man
 
-install-base: $(TARGET)
+install-base: build/mergerfs
 	$(MKDIR) -p "$(INSTALLBINDIR)"
-	$(INSTALL) -v -m 0755 "$(TARGET)" "$(INSTALLBINDIR)/$(TARGET)"
+	$(INSTALL) -v -m 0755 "build/mergerfs" "$(INSTALLBINDIR)/mergerfs"
+	ln -s "mergerfs" "${INSTALLBINDIR}/fsck.mergerfs"
+	ln -s "mergerfs" "${INSTALLBINDIR}/mergerfs.collect-info"
 
-install-mount.mergerfs: mount.mergerfs
+install-mount-tools: install-base
 	$(MKDIR) -p "$(INSTALLBINDIR)"
-	$(CP) -a "$<" "$(INSTALLBINDIR)/$<"
+	$(MAKE) -C libfuse install
 
-install-man: $(MANPAGE)
+install-man: man/$(MANPAGE)
 	$(MKDIR) -p "$(INSTALLMAN1DIR)"
 	$(INSTALL) -v -m 0644 "man/$(MANPAGE)" "$(INSTALLMAN1DIR)/$(MANPAGE)"
 
-install-strip: install-base
-	$(STRIP) "$(INSTALLBINDIR)/$(TARGET)"
+install-preload: preload
+	$(MKDIR) -p "$(INSTALLLIBDIR)"
+	$(INSTALL) -v -m 444 "build/preload.so" "$(INSTALLLIBDIR)/preload.so"
 
+install-strip: install-base
+	$(STRIP) "$(INSTALLBINDIR)/mergerfs"
+
+.PHONY: uninstall
 uninstall: uninstall-base uninstall-mount.mergerfs uninstall-man
 
 uninstall-base:
-	$(RM) -f "$(INSTALLBINDIR)/$(TARGET)"
+	$(RM) -f "$(INSTALLBINDIR)/mergerfs"
 
 uninstall-mount.mergerfs:
 	$(RM) -f "$(INSTALLBINDIR)/mount.mergerfs"
@@ -168,17 +215,11 @@ uninstall-mount.mergerfs:
 uninstall-man:
 	$(RM) -f "$(INSTALLMAN1DIR)/$(MANPAGE)"
 
-$(MANPAGE): README.md
-ifneq (,$(PANDOC))
-	$(PANDOC) -s -t man -o "man/$(MANPAGE)" README.md
-endif
-
-man: $(MANPAGE)
-
-tarball: clean man changelog authors src/version.hpp
-	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
+.PHONY: tarball
+tarball: changelog version
+	$(eval VERSION := $(shell cat VERSION))
 	$(eval VERSION := $(subst -,_,$(VERSION)))
-	$(eval FILENAME := $(TARGET)-$(VERSION))
+	$(eval FILENAME := mergerfs-$(VERSION))
 	$(eval TMPDIR := $(shell $(MKTEMP) --tmpdir -d .$(FILENAME).XXXXXXXX))
 	$(MKDIR) $(TMPDIR)/$(FILENAME)
 	$(CP) -ar . $(TMPDIR)/$(FILENAME)
@@ -186,27 +227,79 @@ tarball: clean man changelog authors src/version.hpp
 	$(RM) -rf $(TMPDIR)
 
 debian-changelog:
-	$(GIT2DEBCL) --name $(TARGET) > debian/changelog
+ifeq ($(GIT_REPO),1)
+	$(GIT2DEBCL) --name mergerfs > debian/changelog
+else
+	cp ChangeLog debian/changelog
+endif
 
-signed-deb: debian-changelog
-	dpkg-buildpackage
+signed-deb:
+	$(MAKE) distclean
+	$(MAKE) debian-changelog
+	fakeroot dpkg-buildpackage -nc
 
-deb: debian-changelog
-	dpkg-buildpackage -uc -us
+deb:
+	$(MAKE) distclean
+	$(MAKE) debian-changelog
+	fakeroot dpkg-buildpackage -nc -uc -us
+	mkdir -p ./build/pkgs/
+	mv -v ../mergerfs*deb ./build/pkgs/
 
+.PHONY: rpm-clean
 rpm-clean:
 	$(RM) -rf rpmbuild
 
 rpm: tarball
-	$(eval VERSION := $(shell $(GIT) describe --always --tags --dirty))
+	$(eval VERSION := $(shell cat VERSION))
 	$(eval VERSION := $(subst -,_,$(VERSION)))
 	$(MKDIR) -p rpmbuild/BUILD rpmbuild/RPMS rpmbuild/SOURCES
-	$(SED) 's/__VERSION__/$(VERSION)/g' $(TARGET).spec > \
-		rpmbuild/SOURCES/$(TARGET).spec
-	cp -ar $(TARGET)-$(VERSION).tar.gz rpmbuild/SOURCES
-	$(RPMBUILD) -ba rpmbuild/SOURCES/$(TARGET).spec \
+	$(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: all clean install help
+.PHONY: install-build-pkgs
+install-build-pkgs:
+	./buildtools/install-build-pkgs
 
-include $(wildcard obj/*.d)
+.PHONY: libfuse
+libfuse:
+	$(MAKE) NDEBUG=$(NDEBUG) -C libfuse
+
+.PHONY: release release-amd64
+release:
+	./buildtools/build-release \
+		--target=all \
+		--cleanup \
+		--branch=$(shell git branch --show-current)
+release-sample:
+	./buildtools/build-release \
+		--target=debian.12.amd64 \
+		--cleanup \
+		--branch=$(shell git branch --show-current)
+release-amd64:
+	./buildtools/build-release \
+		--target=amd64 \
+		--cleanup \
+		--branch=$(shell git branch --show-current)
+release-arm64:
+	./buildtools/build-release \
+		--target=arm64 \
+		--cleanup \
+		--branch=$(shell git branch --show-current)
+release-static:
+	./buildtools/build-release \
+		--target=static \
+		--cleanup \
+		--branch=$(shell git branch --show-current)
+
+tags:
+	rm -fv TAGS
+	find . -name "*.c" -print | etags --append -
+	find . -name "*.h" -print | etags --append -
+	find . -name "*.cpp" -print | etags --append -
+	find . -name "*.hpp" -print | etags --append -
+
+
+-include $(DEPS)

README.md

@@ -1,455 +1,112 @@
-% mergerfs(1) mergerfs user manual
-% Antonio SJ Musumeci <trapexit@spawn.link>
-% 2016-10-13
+# mergerfs - a featureful union filesystem
 
-# NAME
+**mergerfs** is a
+[FUSE](https://en.wikipedia.org/wiki/Filesystem_in_Userspace) based
+[union filesystem](https://en.wikipedia.org/wiki/Union_mount) geared
+towards simplifying storage and management of files across numerous
+commodity storage devices. It is similar to **mhddfs**, **unionfs**,
+and **aufs**.
 
-mergerfs - another (FUSE based) union filesystem
+## Features
 
-# SYNOPSIS
-
-mergerfs -o&lt;options&gt; &lt;srcmounts&gt; &lt;mountpoint&gt;
-
-# 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**.
-
-# FEATURES
-
-* Runs in userspace (FUSE)
-* Configurable behaviors
+* Logically combine numerous filesystems/paths into a single
+  mount point
+* Combine paths of the same or different filesystems
+* Ability to add or remove filesystems/paths without impacting the
+  rest of the data
+* Unaffected by individual filesystem failure
+* Configurable file selection and creation placement
+* Works with filesystems of any size
+* Works with filesystems of almost any type
+* Ignore read-only filesystems when creating files
+* Hard link copy-on-write / CoW
+* Runtime configurable
 * Support for extended attributes (xattrs)
 * Support for file attributes (chattr)
-* Runtime configurable (via xattrs)
-* Safe to run as root
-* Opportunistic credential caching
-* Works with heterogeneous filesystem types
-* Handling of writes to full drives (transparently move file to drive with capacity)
-* Handles pool of readonly and read/write drives
+* Support for POSIX ACLs
 
-# OPTIONS
 
-###options###
+## Non-features
 
-* **defaults**: a shortcut for FUSE's **atomic_o_trunc**, **auto_cache**, **big_writes**, **default_permissions**, **splice_move**, **splice_read**, and **splice_write**. These options seem to provide the best performance.
-* **direct_io**: causes FUSE to bypass an addition caching step which can increase write speeds at the detriment of read speed. 
-* **minfreespace**: the minimum space value used for creation policies. Understands 'K', 'M', and 'G' to represent kilobyte, megabyte, and gigabyte respectively. (default: 4G)
-* **moveonenospc**: when enabled (set to **true**) if a **write** fails with **ENOSPC** or **EDQUOT** a scan of all drives will be done looking for the drive with most free space which is at least the size of the file plus the amount which failed to write. An attempt to move the file to that drive will occur (keeping all metadata possible) and if successful the original is unlinked and the write retried. (default: false)
-* **func.&lt;func&gt;=&lt;policy&gt;**: sets the specific FUSE function's policy. See below for the list of value types. Example: **func.getattr=newest**
-* **category.&lt;category&gt;=&lt;policy&gt;**: Sets policy of all FUSE functions in the provided category. Example: **category.create=mfs**
-* **fsname**: sets the name of the filesystem as seen in **mount**, **df**, etc. Defaults to a list of the source paths concatenated together with the longest common prefix removed.
+* Read/write overlay on top of read-only filesystem like OverlayFS
+* File whiteout
+* RAID like parity calculation
+* Redundancy
+* Splitting of files across branches
 
-**NOTE:** Options are evaluated in the order listed so if the options are **func.rmdir=rand,category.action=ff** the **action** category setting will override the **rmdir** setting.
 
-###srcmounts###
+## How it works
 
-The srcmounts (source mounts) argument is a colon (':') delimited list of paths to be included in the pool. It does not matter if the paths are on the same or different drives nor does it matter the filesystem. Used and available space will not be duplicated for paths on the same device and any features which aren't supported by the underlying filesystem (such as file attributes or extended attributes) will return the appropriate errors.
+mergerfs logically merges multiple filesystem paths together. It acts
+as a proxy to the underlying filesystem paths. Combining the behaviors
+of some functions and being a selector for others.
 
-To make it easier to include multiple source mounts mergerfs supports [globbing](http://linux.die.net/man/7/glob). **The globbing tokens MUST be escaped when using via the shell else the shell itself will expand it.**
+When the contents of a directory are requested mergerfs combines the
+list of files from each directory, deduplicating entries, and returns
+that list.
+
+When a file or directory is created a policy is first run to determine
+which branch will be selected for the creation.
+
+For functions which change attributes or remove the file the behavior
+may be applied to all instances found.
+
+Read more about [policies
+here](https://trapexit.github.io/mergerfs/config/functions_categories_policies/).
+
+
+### Visualization
 
 ```
-$ mergerfs -o defaults,allow_other /mnt/disk\*:/mnt/cdrom /media/drives
+A         +      B        =       C
+/disk1           /disk2           /merged
+|                |                |
++-- /dir1        +-- /dir1        +-- /dir1
+|   |            |   |            |   |
+|   +-- file1    |   +-- file2    |   +-- file1
+|                |   +-- file3    |   +-- file2
++-- /dir2        |                |   +-- file3
+|   |            +-- /dir3        |
+|   +-- file4        |            +-- /dir2
+|                     +-- file5   |   |
++-- file6                         |   +-- file4
+                                  |
+                                  +-- /dir3
+                                  |   |
+                                  |   +-- file5
+                                  |
+                                  +-- file6
 ```
 
-The above line will use all mount points in /mnt prefixed with **disk** and the **cdrom**.
+## QuickStart
 
-To have the pool mounted at boot or otherwise accessable from related tools use **/etc/fstab**.
+https://trapexit.github.io/mergerfs/quickstart/
 
-```
-# <file system>        <mount point>  <type>         <options>             <dump>  <pass>
-/mnt/disk*:/mnt/cdrom  /media/drives  fuse.mergerfs  defaults,allow_other  0       0
-```
 
-**NOTE:** the globbing is done at mount or xattr update time (see below). If a new directory is added matching the glob after the fact it will not be automatically included.
+## Documentation
 
-**NOTE:** for mounting via **fstab** to work you must have **mount.fuse** installed. For Ubuntu/Debian it is included in the **fuse** package.
+https://trapexit.github.io/mergerfs
 
-# FUNCTIONS / POLICIES / CATEGORIES
 
-The POSIX filesystem API has a number of functions. **creat**, **stat**, **chown**, etc. In mergerfs these functions are grouped into 3 categories: **action**, **create**, and **search**. Functions and categories can be assigned a policy which dictates how **mergerfs** behaves. Any policy can be assigned to a function or category though some are not very practical. For instance: **rand** (random) may be useful for file creation (create) but could lead to very odd behavior if used for `chmod` (though only if there were more than one copy of the file).
+## Support
 
-Policies, when called to create, will ignore drives which are readonly or have less than **minfreespace**. This allows for read/write and readonly drives to be mixed together and keep drives which may remount as readonly on error from further affecting the pool.
+https://trapexit.github.io/mergerfs/support/
 
-#### Function / Category classifications ####
 
-| Category | FUSE Functions |
-|----------|----------------|
-| action   | chmod, chown, link, removexattr, rename, rmdir, setxattr, truncate, unlink, utimens |
-| create   | create, mkdir, mknod, symlink |
-| search   | access, getattr, getxattr, ioctl, listxattr, open, readlink |
-| N/A      | fallocate, fgetattr, fsync, ftruncate, ioctl, read, readdir, release, statfs, write |
+## Sponsorship and Donations
 
-Due to FUSE limitations **ioctl** behaves differently if its acting on a directory. It'll use the **getattr** policy to find and open the directory before issuing the **ioctl**. In other cases where something may be searched (to confirm a directory exists across all source mounts) **getattr** will also be used.
+[https://github.com/trapexit/support](https://github.com/trapexit/support)
 
-#### Policy descriptions ####
+Development and support of a project like mergerfs requires a
+significant amount of time and effort. The software is released under
+the very liberal [ISC](https://opensource.org/license/isc-license-txt)
+license and is therefore free to use for personal or commercial uses.
 
-| Policy | Description |
-|--------------|-------------|
-| all | Search category: acts like **ff**. Action category: apply to all found. Create category: for **mkdir**, **mknod**, and **symlink** it will apply to all found. **create** works like **ff**. It will exclude readonly drives and those with free space less than **minfreespace**. |
-| epall (existing path, all) | Search category: acts like **epff**. Action category: apply to all found. Create category: for **mkdir**, **mknod**, and **symlink** it will apply to all existing paths found. **create** works like **epff**. It will exclude readonly drives and those with free space less than **minfreespace**. |
-| epff | Given the order of the drives, as defined at mount time or when configured via the xattr interface, act on the first one found where the path already exists. For **create** category it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). Falls back to **ff**. |
-| eplfs (existing path, least free space) | If the path exists on multiple drives use the one with the least free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **lfs**. |
-| eplus (existing path, least used space) | If the path exists on multiple drives use the one with the least used space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **lus**. |
-| epmfs (existing path, most free space) | If the path exists on multiple drives use the one with the most free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
-| eprand (existing path, random) | Calls **epall** and then randomizes. |
-| erofs | Exclusively return **-1** with **errno** set to **EROFS**. By setting **create** functions to this you can in effect turn the filesystem readonly. |
-| ff (first found) | Given the order of the drives, as defined at mount time or when configured via xattr interface, act on the first one found. For **create** category it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). |
-| lfs (least free space) | Pick the drive with the least available free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
-| lus (least used space) | Pick the drive with the least used space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **mfs**. |
-| mfs (most free space) | Pick the drive with the most available free space. For **create** category it will exclude readonly drives and those with free space less than **minfreespace**. Falls back to **ff**. |
-| newest (newest file) | Pick the file / directory with the largest mtime. For **create** category it will exclude readonly drives and those with free space less than **minfreespace** (unless there is no other option). |
-| rand (random) | Calls **all** and then randomizes. |
+If you are a non-commercial user and find mergerfs and its support valuable
+and would like to support the project financially it would be very
+much appreciated.
 
-**epff**, **eplfs**, **eplus**, and **epmf** are path preserving policies. As the descriptions above explain they will only consider drives where the path being accessed exists. Non-path preserving policies will clone paths as necessary.
-
-#### Defaults ####
-
-| Category | Policy |
-|----------|--------|
-| action   | all    |
-| create   | epmfs  |
-| search   | ff     |
-
-#### rename & link ####
-
-[rename](http://man7.org/linux/man-pages/man2/rename.2.html) is a tricky function in a merged system. Normally if a rename can't be done atomically due to the source and destination paths existing on different mount points it will return **-1** with **errno = EXDEV**. The atomic rename is most critical for replacing files in place atomically (such as securing writing to a temp file and then replacing a target). The problem is that by merging multiple paths you can have N instances of the source and destinations on different drives. This can lead to several undesirable situtations with or without errors and it's not entirely obvious what to do when an error occurs.
-
-Originally mergerfs would return EXDEV whenever a rename was requested which was cross directory in any way. This made the code simple and was technically complient with POSIX requirements. However, many applications fail to handle EXDEV at all and treat it as a normal error or they only partially support EXDEV (don't respond the same as `mv` would). Such apps include: gvfsd-fuse v1.20.3 and prior, Finder / CIFS/SMB client in Apple OSX 10.9+, NZBGet, Samba's recycling bin feature.
-
-* If using a **create** policy which tries to preserve directory paths (epff,eplfs,eplus,epmfs)
-  * Using the **rename** policy get the list of files to rename
-  * For each file attempt rename:
-    * If failure with ENOENT run **create** policy
-    * If create policy returns the same drive as currently evaluating then clone the path
-    * Re-attempt rename
-  * If **any** of the renames succeed the higher level rename is considered a success
-  * If **no** renames succeed the first error encountered will be returned
-  * On success:
-    * Remove the target from all drives with no source file
-    * Remove the source from all drives which failed to rename
-* If using a **create** policy which does **not** try to preserve directory paths
-  * Using the **rename** policy get the list of files to rename
-  * Using the **getattr** policy get the target path
-  * For each file attempt rename:
-    * If the source drive != target drive:
-      * Clone target path from target drive to source drive
-    * Rename
-  * If **any** of the renames succeed the higher level rename is considered a success
-  * If **no** renames succeed the first error encountered will be returned
-  * On success:
-    * Remove the target from all drives with no source file
-    * Remove the source from all drives which failed to rename
-
-The the removals are subject to normal entitlement checks.
-
-The above behavior will help minimize the likelihood of EXDEV being returned but it will still be possible. To remove the possibility all together mergerfs would need to perform the as **mv** does when it receives EXDEV normally.
-
-**link** uses the same basic strategy.
-
-#### readdir ####
-
-[readdir](http://linux.die.net/man/3/readdir) is different from all other filesystem functions. While it could have it's own set of policies to tweak its behavior at this time it provides a simple union of files and directories found. Remember that any action or information queried about these files and directories come from the respective function. For instance: an **ls** is a **readdir** and for each file/directory returned **getattr** is called. Meaning the policy of **getattr** is responsible for choosing the file/directory which is the source of the metadata you see in an **ls**.
-
-#### statvfs ####
-
-[statvfs](http://linux.die.net/man/2/statvfs) normalizes the source drives based on the fragment size and sums the number of adjusted blocks and inodes. This means you will see the combined space of all sources. Total, used, and free. The sources however are dedupped based on the drive so multiple sources on the same drive will not result in double counting it's space.
-
-# BUILDING
-
-**NOTE:** Prebuilt packages can be found at: https://github.com/trapexit/mergerfs/releases
-
-First get the code from [github](http://github.com/trapexit/mergerfs).
-
-```
-$ git clone https://github.com/trapexit/mergerfs.git
-$ # or
-$ wget https://github.com/trapexit/mergerfs/releases/download/<ver>/mergerfs-<ver>.tar.gz
-```
-
-#### Debian / Ubuntu
-```
-$ sudo apt-get install g++ pkg-config git git-buildpackage pandoc debhelper libfuse-dev libattr1-dev python
-$ cd mergerfs
-$ make deb
-$ sudo dpkg -i ../mergerfs_version_arch.deb
-```
-
-#### Fedora
-```
-$ su -
-# dnf install rpm-build fuse-devel libattr-devel pandoc gcc-c++ git make which python
-# cd mergerfs
-# make rpm
-# rpm -i rpmbuild/RPMS/<arch>/mergerfs-<verion>.<arch>.rpm
-```
-
-#### Generically
-
-Have git, python, pkg-config, pandoc, libfuse, libattr1 installed.
-
-```
-$ cd mergerfs
-$ make
-$ make man
-$ sudo make install
-```
-
-# RUNTIME
-
-#### .mergerfs pseudo file ####
-```
-<mountpoint>/.mergerfs
-```
-
-There is a pseudo file available at the mount point which allows for the runtime modification of certain **mergerfs** options. The file will not show up in **readdir** but can be **stat**'ed and manipulated via [{list,get,set}xattrs](http://linux.die.net/man/2/listxattr) calls.
-
-Even if xattrs are disabled for mergerfs the [{list,get,set}xattrs](http://linux.die.net/man/2/listxattr) calls against this pseudo file will still work.
-
-Any changes made at runtime are **not** persisted. If you wish for values to persist they must be included as options wherever you configure the mounting of mergerfs (fstab).
-
-##### Keys #####
-
-Use `xattr -l /mount/point/.mergerfs` to see all supported keys. Some are informational and therefore readonly.
-
-###### user.mergerfs.srcmounts ######
-
-Used to query or modify the list of source mounts. When modifying there are several shortcuts to easy manipulation of the list.
-
-| Value        | Description |
-|--------------|-------------|
-| [list]       | set         |
-| +<[list]     | prepend     |
-| +>[list]     | append      |
-| -[list]      | remove all values provided |
-| -<           | remove first in list |
-| ->           | remove last in list |
-
-###### minfreespace ######
-
-Input: interger with an optional multiplier suffix. **K**, **M**, or **G**.
-
-Output: value in bytes
-
-###### moveonenospc ######
-
-Input: **true** and **false**
-
-Ouput: **true** or **false**
-
-###### categories / funcs ######
-
-Input: short policy string as described elsewhere in this document
-
-Output: the policy string except for categories where its funcs have multiple types. In that case it will be a comma separated list
-
-##### Example #####
-
-```
-[trapexit:/tmp/mount] $ xattr -l .mergerfs
-user.mergerfs.srcmounts: /tmp/a:/tmp/b
-user.mergerfs.minfreespace: 4294967295
-user.mergerfs.moveonenospc: false
-...
-
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.category.search .mergerfs
-ff
-
-[trapexit:/tmp/mount] $ xattr -w user.mergerfs.category.search newest .mergerfs
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.category.search .mergerfs
-newest
-
-[trapexit:/tmp/mount] $ xattr -w user.mergerfs.srcmounts +/tmp/c .mergerfs
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.srcmounts .mergerfs
-/tmp/a:/tmp/b:/tmp/c
-
-[trapexit:/tmp/mount] $ xattr -w user.mergerfs.srcmounts =/tmp/c .mergerfs
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.srcmounts .mergerfs
-/tmp/c
-
-[trapexit:/tmp/mount] $ xattr -w user.mergerfs.srcmounts '+</tmp/a:/tmp/b' .mergerfs
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.srcmounts .mergerfs
-/tmp/a:/tmp/b:/tmp/c
-```
-
-#### file / directory xattrs ####
-
-While they won't show up when using [listxattr](http://linux.die.net/man/2/listxattr) **mergerfs** offers a number of special xattrs to query information about the files served. To access the values you will need to issue a [getxattr](http://linux.die.net/man/2/getxattr) for one of the following:
-
-* **user.mergerfs.basepath:** the base mount point for the file given the current getattr policy
-* **user.mergerfs.relpath:** the relative path of the file from the perspective of the mount point
-* **user.mergerfs.fullpath:** the full path of the original file given the getattr policy
-* **user.mergerfs.allpaths:** a NUL ('\0') separated list of full paths to all files found
-
-```
-[trapexit:/tmp/mount] $ ls
-A B C
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.fullpath A
-/mnt/a/full/path/to/A
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.basepath A
-/mnt/a
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.relpath A
-/full/path/to/A
-[trapexit:/tmp/mount] $ xattr -p user.mergerfs.allpaths A | tr '\0' '\n'
-/mnt/a/full/path/to/A
-/mnt/b/full/path/to/A
-```
-
-# TOOLING
-
-* https://github.com/trapexit/mergerfs-tools
-  * mergerfs.ctl: A tool to make it easier to query and configure mergerfs at runtime
-  * mergerfs.fsck: Provides permissions and ownership auditing and the ability to fix them
-  * mergerfs.dedup: Will help identify and optionally remove duplicate files
-  * mergerfs.mktrash: Creates FreeDesktop.org Trash specification compatible directories on a mergerfs mount
-* https://github.com/trapexit/scorch
-  * scorch: A tool to help discover silent corruption of files
-
-# TIPS / NOTES
-
-* https://github.com/trapexit/backup-and-recovery-howtos : A set of guides / howtos on creating a data storage system, backing it up, maintaining it, and recovering from failure.
-* If you don't see some directories / files you expect in a merged point be sure the user has permission to all the underlying directories. If `/drive0/a` has is owned by `root:root` with ACLs set to `0700` and `/drive1/a` is `root:root` and `0755` you'll see only `/drive1/a`. Use `mergerfs.fsck` to audit the drive for out of sync permissions.
-* Do *not* use `direct_io` if you expect applications (such as rtorrent) to [mmap](http://linux.die.net/man/2/mmap) files. It is not currently supported in FUSE w/ `direct_io` enabled.
-* Since POSIX gives you only error or success on calls its difficult to determine the proper behavior when applying the behavior to multiple targets. **mergerfs** will return an error only if all attempts of an action fail. Any success will lead to a success returned.
-* The recommended options are **defaults,allow_other**. The **allow_other** is to allow users who are not the one which executed mergerfs access to the mountpoint. **defaults** is described above and should offer the best performance. It's possible that if you're running on an older platform the **splice** features aren't available and could error. In that case simply use the other options manually.
-* If write performance is valued more than read it may be useful to enable **direct_io**. Best to benchmark with and without and choose appropriately.
-* Remember: some policies mixed with some functions may result in strange behaviors. Not that some of these behaviors and race conditions couldn't happen outside **mergerfs** but that they are far more likely to occur on account of attempt to merge together multiple sources of data which could be out of sync due to the different policies.
-* An example: [Kodi](http://kodi.tv) and [Plex](http://plex.tv) can use directory [mtime](http://linux.die.net/man/2/stat) to more efficiently determine whether to scan for new content rather than simply performing a full scan. If using the current default **getattr** policy of **ff** its possible **Kodi** will miss an update on account of it returning the first directory found's **stat** info and its a later directory on another mount which had the **mtime** recently updated. To fix this you will want to set **func.getattr=newest**. Remember though that this is just **stat**. If the file is later **open**'ed or **unlink**'ed and the policy is different for those then a completely different file or directory could be acted on.
-* Due to previously mentioned issues its generally best to set **category** wide policies rather than individual **func**'s. This will help limit the confusion of tools such as [rsync](http://linux.die.net/man/1/rsync).
-
-# KNOWN ISSUES / BUGS
-
-#### rtorrent fails with ENODEV (No such device)
-
-Be sure to turn off `direct_io`. rtorrent and some other applications use [mmap](http://linux.die.net/man/2/mmap) to read and write to files and offer no failback to traditional methods. FUSE does not currently support mmap while using `direct_io`. There will be a performance penalty on writes with `direct_io` off but it's the only way to get such applications to work. If the performance loss is too high for other apps you can mount mergerfs twice. Once with `direct_io` enabled and one without it.
-
-#### mmap performance is really bad
-
-There [is a bug](https://lkml.org/lkml/2016/3/16/260) in caching which affects overall performance of mmap through FUSE in Linux 4.x kernels. It is fixed in [4.4.10 and 4.5.4](https://lkml.org/lkml/2016/5/11/59). 
-
-#### Trashing files occasionally fails
-
-This is the same issue as with Samba. `rename` returns `EXDEV` (in our case that will really only happen with path preserving policies like `epmfs`) and the software doesn't handle the situtation well. This is unfortunately a common failure of software which moves files around. The standard indicates that an implementation `MAY` choose to support non-user home directory trashing of files (which is a `MUST`). The implementation `MAY` also support "top directory trashes" which many probably do. 
-
-To create a `$topdir/.Trash` directory as defined in the standard use the [mergerfs-tools](https://github.com/trapexit/mergerfs-tools) tool `mergerfs.mktrash`.
-
-#### Samba: Moving files / directories fails
-
-Workaround: Copy the file/directory and then remove the original rather than move.
-
-This isn't an issue with Samba but some SMB clients. GVFS-fuse v1.20.3 and prior (found in Ubuntu 14.04 among others) failed to handle certain error codes correctly. Particularly **STATUS_NOT_SAME_DEVICE** which comes from the **EXDEV** which is returned by **rename** when the call is crossing mount points. When a program gets an **EXDEV** it needs to explicitly take an alternate action to accomplish it's goal. In the case of **mv** or similar it tries **rename** and on **EXDEV** falls back to a manual copying of data between the two locations and unlinking the source. In these older versions of GVFS-fuse if it received **EXDEV** it would translate that into **EIO**. This would cause **mv** or most any application attempting to move files around on that SMB share to fail with a IO error.
-
-[GVFS-fuse v1.22.0](https://bugzilla.gnome.org/show_bug.cgi?id=734568) and above fixed this issue but a large number of systems use the older release. On Ubuntu the version can be checked by issuing `apt-cache showpkg gvfs-fuse`. Most distros released in 2015 seem to have the updated release and will work fine but older systems may not. Upgrading gvfs-fuse or the distro in general will address the problem.
-
-In Apple's MacOSX 10.9 they replaced Samba (client and server) with their own product. It appears their new client does not handle **EXDEV** either and responds similar to older release of gvfs on Linux.
-
-#### Supplemental user groups
-
-Due to the overhead of [getgroups/setgroups](http://linux.die.net/man/2/setgroups) mergerfs utilizes a cache. This cache is opportunistic and per thread. Each thread will query the supplemental groups for a user when that particular thread needs to change credentials and will keep that data for the lifetime of the thread. This means that if a user is added to a group it may not be picked up without the restart of mergerfs. However, since the high level FUSE API's (at least the standard version) thread pool dynamically grows and shrinks it's possible that over time a thread will be killed and later a new thread with no cache will start and query the new data.
-
-The gid cache uses fixed storage to simplify the design and be compatible with older systems which may not have C++11 compilers. There is enough storage for 256 users' supplemental groups. Each user is allowed upto 32 supplemental groups. Linux >= 2.6.3 allows upto 65535 groups per user but most other *nixs allow far less. NFS allowing only 16. The system does handle overflow gracefully. If the user has more than 32 supplemental groups only the first 32 will be used. If more than 256 users are using the system when an uncached user is found it will evict an existing user's cache at random. So long as there aren't more than 256 active users this should be fine. If either value is too low for your needs you will have to modify `gidcache.hpp` to increase the values. Note that doing so will increase the memory needed by each thread.
-
-#### mergerfs or libfuse crashing
-
-If suddenly the mergerfs mount point disappears and `Transport endpoint is not connected` is returned when attempting to perform actions within the mount directory **and** the version of libfuse (use `mergerfs -v` to find the version) is older than `2.9.4` its likely due to a bug in libfuse. Affected versions of libfuse can be found in Debian Wheezy, Ubuntu Precise and others.
-
-In order to fix this please install newer versions of libfuse. If using a Debian based distro (Debian,Ubuntu,Mint) you can likely just install newer versions of [libfuse](https://packages.debian.org/unstable/libfuse2) and [fuse](https://packages.debian.org/unstable/fuse) from the repo of a newer release.
-
-#### mergerfs under heavy load and memory preasure leads to kernel panic
-
-https://lkml.org/lkml/2016/9/14/527
-
-```
-[25192.515454] kernel BUG at /build/linux-a2WvEb/linux-4.4.0/mm/workingset.c:346!
-[25192.517521] invalid opcode: 0000 [#1] SMP
-[25192.519602] Modules linked in: netconsole ip6t_REJECT nf_reject_ipv6 ipt_REJECT nf_reject_ipv4 configfs binfmt_misc veth bridge stp llc nf_conntrack_ipv6 nf_defrag_ipv6 xt_conntrack ip6table_filter ip6_tables xt_multiport iptable_filter ipt_MASQUERADE nf_nat_masquerade_ipv4 xt_comment xt_nat iptable_nat nf_conntrack_ipv4 nf_defrag_ipv4 nf_nat_ipv4 nf_nat nf_conntrack xt_CHECKSUM xt_tcpudp iptable_mangle ip_tables x_tables intel_rapl x86_pkg_temp_thermal intel_powerclamp eeepc_wmi asus_wmi coretemp sparse_keymap kvm_intel ppdev kvm irqbypass mei_me 8250_fintek input_leds serio_raw parport_pc tpm_infineon mei shpchp mac_hid parport lpc_ich autofs4 drbg ansi_cprng dm_crypt algif_skcipher af_alg btrfs raid456 async_raid6_recov async_memcpy async_pq async_xor async_tx xor raid6_pq libcrc32c raid0 multipath linear raid10 raid1 i915 crct10dif_pclmul crc32_pclmul aesni_intel i2c_algo_bit aes_x86_64 drm_kms_helper lrw gf128mul glue_helper ablk_helper syscopyarea cryptd sysfillrect sysimgblt fb_sys_fops drm ahci r8169 libahci mii wmi fjes video [last unloaded: netconsole]
-[25192.540910] CPU: 2 PID: 63 Comm: kswapd0 Not tainted 4.4.0-36-generic #55-Ubuntu
-[25192.543411] Hardware name: System manufacturer System Product Name/P8H67-M PRO, BIOS 3904 04/27/2013
-[25192.545840] task: ffff88040cae6040 ti: ffff880407488000 task.ti: ffff880407488000
-[25192.548277] RIP: 0010:[<ffffffff811ba501>]  [<ffffffff811ba501>] shadow_lru_isolate+0x181/0x190
-[25192.550706] RSP: 0018:ffff88040748bbe0  EFLAGS: 00010002
-[25192.553127] RAX: 0000000000001c81 RBX: ffff8802f91ee928 RCX: ffff8802f91eeb38
-[25192.555544] RDX: ffff8802f91ee938 RSI: ffff8802f91ee928 RDI: ffff8804099ba2c0
-[25192.557914] RBP: ffff88040748bc08 R08: 000000000001a7b6 R09: 000000000000003f
-[25192.560237] R10: 000000000001a750 R11: 0000000000000000 R12: ffff8804099ba2c0
-[25192.562512] R13: ffff8803157e9680 R14: ffff8803157e9668 R15: ffff8804099ba2c8
-[25192.564724] FS:  0000000000000000(0000) GS:ffff88041f280000(0000) knlGS:0000000000000000
-[25192.566990] CS:  0010 DS: 0000 ES: 0000 CR0: 0000000080050033
-[25192.569201] CR2: 00007ffabb690000 CR3: 0000000001e0a000 CR4: 00000000000406e0
-[25192.571419] Stack:
-[25192.573550]  ffff8804099ba2c0 ffff88039e4f86f0 ffff8802f91ee928 ffff8804099ba2c8
-[25192.575695]  ffff88040748bd08 ffff88040748bc58 ffffffff811b99bf 0000000000000052
-[25192.577814]  0000000000000000 ffffffff811ba380 000000000000008a 0000000000000080
-[25192.579947] Call Trace:
-[25192.582022]  [<ffffffff811b99bf>] __list_lru_walk_one.isra.3+0x8f/0x130
-[25192.584137]  [<ffffffff811ba380>] ? memcg_drain_all_list_lrus+0x190/0x190
-[25192.586165]  [<ffffffff811b9a83>] list_lru_walk_one+0x23/0x30
-[25192.588145]  [<ffffffff811ba544>] scan_shadow_nodes+0x34/0x50
-[25192.590074]  [<ffffffff811a0e9d>] shrink_slab.part.40+0x1ed/0x3d0
-[25192.591985]  [<ffffffff811a53da>] shrink_zone+0x2ca/0x2e0
-[25192.593863]  [<ffffffff811a64ce>] kswapd+0x51e/0x990
-[25192.595737]  [<ffffffff811a5fb0>] ? mem_cgroup_shrink_node_zone+0x1c0/0x1c0
-[25192.597613]  [<ffffffff810a0808>] kthread+0xd8/0xf0
-[25192.599495]  [<ffffffff810a0730>] ? kthread_create_on_node+0x1e0/0x1e0
-[25192.601335]  [<ffffffff8182e34f>] ret_from_fork+0x3f/0x70
-[25192.603193]  [<ffffffff810a0730>] ? kthread_create_on_node+0x1e0/0x1e0
-```
-
-There is a bug in the kernel. A work around appears to be turning off `splice`. Add `no_splice_write,no_splice_move,no_splice_read` to mergerfs' options. Should be placed after `defaults` if it is used since it will turn them on.
-
-# FAQ
-
-#### Why use mergerfs over mhddfs?
-
-mhddfs is no longer maintained and has some known stability and security issues (see below). MergerFS provides a superset of mhddfs' features and should offer the same or maybe better performance.
-
-#### Why use mergerfs over aufs?
-
-While aufs can offer better peak performance mergerfs offers more configurability and is generally easier to use. mergerfs however doesn't offer the same overlay features (which tends to result in whiteout files being left around the underlying filesystems.)
-
-#### Why use mergerfs over LVM/ZFS/BTRFS/RAID0 drive concatenation / striping?
-
-With simple JBOD / drive concatenation / stripping / RAID0 a single drive failure will lead to full pool failure. mergerfs performs a similar behavior without the catastrophic failure and general lack of recovery. Drives can fail and all other data will continue to be accessable.
-
-When combined with something like [SnapRaid](http://www.snapraid.it) and/or an offsite full backup solution you can have the flexibilty of JBOD without the single point of failure.
-
-#### Can drives be written to directly? Outside of mergerfs while pooled?
-
-Yes. It will be represented immediately in the pool as the policies would describe.
-
-#### Why do I get an "out of space" error even though the system says there's lots of space left?
-
-Please reread the sections above about policies, path preserving, and the **moveonenospc** option. If the policy is path preserving and a drive is almost full and the drive the policy would pick then the writing of the file may fill the drive and receive ENOSPC errors. That is expected with those settings. If you don't want that: enable **moveonenospc** and don't use a path preserving policy.
-
-
-#### It's mentioned that there are some security issues with mhddfs. What are they? How does mergerfs address them?
-
-[mhddfs](https://github.com/trapexit/mhddfs) tries to handle being run as **root** by calling [getuid()](https://github.com/trapexit/mhddfs/blob/cae96e6251dd91e2bdc24800b4a18a74044f6672/src/main.c#L319) and if it returns **0** then it will [chown](http://linux.die.net/man/1/chown) the file. Not only is that a race condition but it doesn't handle many other situations. Rather than attempting to simulate POSIX ACL behaviors the proper behavior is to use [seteuid](http://linux.die.net/man/2/seteuid) and [setegid](http://linux.die.net/man/2/setegid), become the user making the original call and perform the action as them. This is how [mergerfs](https://github.com/trapexit/mergerfs) handles things.
-
-If you are familiar with POSIX standards you'll know that this behavior poses a problem. **seteuid** and **setegid** affect the whole process and **libfuse** is multithreaded by default. We'd need to lock access to **seteuid** and **setegid** with a mutex so that the several threads aren't stepping on one anofther and files end up with weird permissions and ownership. This however wouldn't scale well. With lots of calls the contention on that mutex would be extremely high. Thankfully on Linux and OSX we have a better solution.
-
-OSX has a [non-portable pthread extension](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html) for per-thread user and group impersonation.
-
-Linux does not support [pthread_setugid_np](https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man2/pthread_setugid_np.2.html) but user and group IDs are a per-thread attribute though documentation on that fact or how to manipulate them is not well distributed. From the **4.00** release of the Linux man-pages project for [setuid](http://man7.org/linux/man-pages/man2/setuid.2.html).
-
-> At the kernel level, user IDs and group IDs are a per-thread attribute.  However, POSIX requires that all threads in a process share the same credentials.  The NPTL threading implementation handles the POSIX requirements by providing wrapper functions for the various system calls that change process UIDs and GIDs.  These wrapper functions (including the one for setuid()) employ a signal-based technique to ensure that when one thread changes credentials, all of the other threads in the process also change their credentials.  For details, see nptl(7).
-
-Turns out the setreuid syscalls apply only to the thread. GLIBC hides this away using RT signals to inform all threads to change credentials. Taking after **Samba** mergerfs uses **syscall(SYS_setreuid,...)** to set the callers credentials for that thread only. Jumping back to **root** as necessary should escalated privileges be needed (for instance: to clone paths).
-
-For non-Linux systems mergerfs uses a read-write lock and changes credentials only when necessary. If multiple threads are to be user X then only the first one will need to change the processes credentials. So long as the other threads need to be user X they will take a readlock allow multiple threads to share the credentials. Once a request comes in to run as user Y that thread will attempt a write lock and change to Y's credentials when it can. If the ability to give writers priority is supported then that flag will be used so threads trying to change credentials don't starve. This isn't the best solution but should work reasonably well. As new platforms are supported if they offer per thread credentials those APIs will be adopted.
-
-# SUPPORT
-
-#### Issues with the software
-* github.com: https://github.com/trapexit/mergerfs/issues
-* email: trapexit@spawn.link
-
-#### Support development
-* Gratipay: https://gratipay.com/~trapexit
-* BitCoin: 12CdMhEPQVmjz3SSynkAEuD5q9JmhTDCZA
-
-# LINKS
-
-* http://github.com/trapexit/mergerfs
-* http://github.com/trapexit/mergerfs-tools
-* http://github.com/trapexit/scorch
-* http://github.com/trapexit/backup-and-recovery-howtos
+If you are using mergerfs commercially please consider sponsoring the
+project to ensure it continues to be maintained and receive
+updates. If custom features are needed feel free to [contact me
+directly](mailto:support@spawn.link).

buildtools/build-mergerfs

@@ -0,0 +1,49 @@
+#!/bin/sh
+
+BRANCH="${1:-master}"
+SRCDIR="/tmp/mergerfs"
+
+git clone https://github.com/trapexit/mergerfs "${SRCDIR}" -b "${BRANCH}"
+
+cd "${SRCDIR}"
+
+git log HEAD^1..
+
+mkdir /build
+if [ -e /usr/bin/apt-get ]; then
+    make deb
+    if [ $? -ne 0 ]; then
+        . /etc/lsb-release
+        cp -v /etc/lsb-release "/build/${DISTRIB_ID}.${DISTRIB_CODENAME}.${DISTRIB_RELEASE}.$(arch).FAILED"
+    fi
+    find /tmp/ \
+         -type f \
+         -name "*.deb" \
+         -not -name "*dbgsym*" \
+         -exec cp -v {} /build/ \;
+elif [ -e /usr/bin/dnf ]; then
+    make rpm
+    if [ $? -ne 0 ]; then
+        . /etc/lsb-release
+        cp -v /etc/lsb-release "/build/${DISTRIB_ID}.${DISTRIB_CODENAME}.${DISTRIB_RELEASE}.$(arch).FAILED"
+    fi
+    find /tmp/ \
+         -type f \
+         -name "*.rpm" \
+         -not -name "*sym*" \
+         -not -name "*src.rpm" \
+         -exec cp -v {} /build/ \;
+elif [ -e /usr/bin/yum ]; then
+    . /opt/rh/devtoolset-9/enable
+    make rpm
+    find /tmp/ \
+         -type f \
+         -name "*.rpm" \
+         -not -name "*sym*" \
+         -not -name "*src.rpm" \
+         -exec cp -v {} /build/ \;
+elif [ -e /sbin/apk ]; then
+    echo "NOT YET SUPPORTED"
+elif [ -e /usr/sbin/pkg ]; then
+    echo "NOT YET SUPPORTED"
+fi

buildtools/build-release

@@ -0,0 +1,111 @@
+#!/usr/bin/env python3
+
+import subprocess
+import sys
+import os
+import argparse
+import time
+
+
+def build(containerfile,
+          pkgdirpath,
+          branch):
+    timestamp = time.time_ns()
+    args = ['podman',
+            'build',
+            '--pull=always',
+            '--force-rm',
+            '-o',pkgdirpath,
+            '-f',containerfile,
+            f'--build-arg=BRANCH={branch}',
+            f'--build-arg=BUILD_TIMESTAMP={timestamp}',
+            'buildtools/']
+    print(args)
+    subprocess.run(args)
+
+
+def setup():
+    args = ['sudo',
+            'apt-get',
+            'install',
+            '-fy',
+            'qemu-user-static',
+            'qemu-user-binfmt']
+    print(args)
+    subprocess.run(args)
+
+
+def podman_cleanup():
+    args = ['podman',
+            'system',
+            'prune',
+            '-af']
+    print(args)
+    subprocess.run(args)
+
+
+def parse_args():
+    p = argparse.ArgumentParser()
+    p.add_argument('--target',
+                   default='debian.12.amd64')
+    p.add_argument('--pkgdirpath',
+                   default='build/pkgs/')
+    p.add_argument('--branch',
+                   default='master')
+    p.add_argument('--setup',
+                   required=False,
+                   action='store_true')
+    p.add_argument('--cleanup',
+                   required=False,
+                   action='store_true')
+
+    return p.parse_args()
+
+
+def should_skip(filename):
+    if filename.endswith('~'):
+        return True
+    return False
+
+
+def main():
+    args = parse_args()
+    print(args)
+
+    if args.setup:
+        setup()
+        sys.exit(0)
+
+    containerfiles = []
+    basepath = 'buildtools/containerfiles'
+    if os.path.exists(f'{basepath}/{args.target}'):
+        containerfiles.append(f'{basepath}/{args.target}')
+    elif args.target == 'all':
+        for root,dirnames,filenames in os.walk(basepath):
+            for filename in filenames:
+                if should_skip(filename):
+                    continue                
+                containerfile = f'buildtools/containerfiles/{filename}'
+                containerfiles.append(containerfile)
+    else:
+        for root,dirnames,filenames in os.walk(basepath):
+            for filename in filenames:
+                if args.target not in filename:
+                    continue
+                if should_skip(filename):
+                    continue                
+                containerfile = f'buildtools/containerfiles/{filename}'
+                containerfiles.append(containerfile)
+
+    for containerfile in containerfiles:
+        if args.cleanup:
+            podman_cleanup()
+        build(containerfile,
+              args.pkgdirpath,
+              args.branch)
+
+    sys.exit(0)
+
+
+if __name__ == '__main__':
+    main()

buildtools/containerfiles/centos.10.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 quay.io/centos/centos:10 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/centos.10.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 quay.io/centos/centos:10 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.10.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 debian:10 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.10.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 debian:10 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.10.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf debian:10 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.10.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 debian:10 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.11.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 debian:11 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.11.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 debian:11 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.11.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf debian:11 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.11.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 debian:11 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.12.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 debian:12 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.12.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 debian:12 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.12.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf debian:12 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/debian.12.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 debian:12 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.37.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 fedora:37 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.37.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 fedora:37 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.37.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf fedora:37 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.37.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 fedora:37 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.38.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 fedora:38 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.38.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 fedora:38 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.38.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf fedora:38 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.38.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 fedora:38 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.39.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 fedora:39 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.40.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 fedora:40 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.41.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 fedora:41 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/fedora.42.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 fedora:42 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.8.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 rockylinux:8 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.8.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 rockylinux:8 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.8.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf rockylinux:8 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.8.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 rockylinux:8 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.9.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 rockylinux:9 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.9.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 rockylinux:9 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.9.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf rockylinux:9 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/rockylinux.9.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 rockylinux:9 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/static.amd64

@@ -0,0 +1,13 @@
+ARG BUILD_TIMESTAMP=0
+FROM --platform=linux/amd64 alpine:latest as build
+COPY install-build-pkgs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BRANCH=master
+RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
+WORKDIR /tmp/mergerfs
+RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
+RUN mkdir /build
+RUN tar cvfz /build/mergerfs-static-linux_amd64.tar.gz --directory=/tmp usr sbin
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/static.arm64

@@ -0,0 +1,13 @@
+ARG BUILD_TIMESTAMP=0
+FROM --platform=linux/arm64 alpine:latest as build
+COPY install-build-pkgs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BRANCH=master
+RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
+WORKDIR /tmp/mergerfs
+RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
+RUN mkdir /build
+RUN tar cvfz /build/mergerfs-static-linux_arm64.tar.gz --directory=/tmp usr sbin
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/static.armhf

@@ -0,0 +1,13 @@
+ARG BUILD_TIMESTAMP=0
+FROM --platform=linux/armhf alpine:latest as build
+COPY install-build-pkgs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BRANCH=master
+RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
+WORKDIR /tmp/mergerfs
+RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
+RUN mkdir /build
+RUN tar cvfz /build/mergerfs-static-linux_armhf.tar.gz --directory=/tmp usr sbin
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/static.i386

@@ -0,0 +1,13 @@
+ARG BUILD_TIMESTAMP=0
+FROM --platform=linux/i386 alpine:latest as build
+COPY install-build-pkgs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BRANCH=master
+RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
+WORKDIR /tmp/mergerfs
+RUN make NDEBUG=1 LTO=1 STATIC=1 DESTDIR=/tmp -j$(nproc) install
+RUN mkdir /build
+RUN tar cvfz /build/mergerfs-static-linux_i386.tar.gz --directory=/tmp usr sbin
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/static.installer

@@ -0,0 +1,10 @@
+ARG BUILD_TIMESTAMP=0
+FROM --platform=linux/amd64 ubuntu:latest as build
+RUN apt-get update && apt-get install -y makeself
+RUN mkdir -p /tmp/mergerfs/
+RUN --mount=type=bind,src=pkgs,dst=/pkgs ls -lhd /pkgs
+RUN --mount=type=bind,src=pkgs,dst=/pkgs cp -v /pkg/*static*.gz /tmp/mergerfs/
+RUN makeself /tmp/mergerfs/ /build/mergerfs-installer.run "mergerfs" echo "foo"
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/tarball

@@ -0,0 +1,13 @@
+FROM debian:buster as tarball
+COPY install-build-pkgs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN git clone https://github.com/trapexit/mergerfs /tmp/mergerfs -b "${BRANCH}"
+RUN cd /tmp/mergerfs && make version tarball
+RUN mkdir /build
+RUN cp -v /tmp/mergerfs/*.tar.gz /build/
+
+
+FROM scratch
+COPY --from=tarball /build/ /

buildtools/containerfiles/ubuntu.20.04.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 ubuntu:20.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.20.04.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 ubuntu:20.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.20.04.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf ubuntu:20.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.20.04.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 ubuntu:20.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.22.04.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 ubuntu:22.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.22.04.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 ubuntu:22.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.22.04.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf ubuntu:22.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.22.04.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 ubuntu:22.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.24.04.amd64

@@ -0,0 +1,9 @@
+FROM --platform=linux/amd64 ubuntu:24.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.24.04.arm64

@@ -0,0 +1,9 @@
+FROM --platform=linux/arm64 ubuntu:24.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.24.04.armhf

@@ -0,0 +1,9 @@
+FROM --platform=linux/armhf ubuntu:24.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/containerfiles/ubuntu.24.04.i386

@@ -0,0 +1,9 @@
+FROM --platform=linux/i386 ubuntu:24.04 as build
+COPY install-build-pkgs build-mergerfs /tmp/
+RUN /tmp/install-build-pkgs
+ARG BUILD_TIMESTAMP=0
+ARG BRANCH=master
+RUN /tmp/build-mergerfs $BRANCH
+
+FROM scratch
+COPY --from=build /build/ /

buildtools/create-branches

@@ -0,0 +1,14 @@
+#!/bin/sh
+set -x
+
+BASEPATH="/tmp"
+
+for x in $(seq -w 2)
+do
+    FILEPATH="${BASEPATH}/mergerfs-${x}.img"
+    MOUNTPOINT="${BASEPATH}/mergerfs-${x}"
+    truncate -s 1G "${FILEPATH}"
+    mkdir -p "${MOUNTPOINT}"
+    mkfs.ext4 -m0 -L "mergerfs${x}" "${FILEPATH}"
+    sudo mount "${FILEPATH}" "${MOUNTPOINT}"
+done    

buildtools/git2debcl

@@ -1,4 +1,4 @@
-#!/usr/bin/python
+#!/usr/bin/env python3
 
 # Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
 
@@ -18,9 +18,12 @@ import sys
 import subprocess
 import argparse
 
+def call(args):
+    return subprocess.Popen(args,stdout=subprocess.PIPE).communicate()[0].decode()
+
 def git_tags():
     args = ["git", "tag", '-l']
-    tags = subprocess.check_output(args)
+    tags = call(args)
     tags = [[int(X) for X in tag.split(".")] for tag in tags.split()]
     tags.sort()
     tags.reverse()
@@ -29,20 +32,20 @@ def git_tags():
 
 def git_log(fromtag,totag):
     args = ['git','log','--no-merges','--oneline',fromtag+'...'+totag]
-    return subprocess.check_output(args).strip().split('\n')
+    return call(args).strip().split('\n')
 
 def git_author_and_time(tag):
     args = ['git','log','-1','--format=-- %an <%ae>  %cD',tag]
-    return subprocess.check_output(args).strip()
+    return call(args).strip()
 
 def git_version():
     args = ['git','describe','--always','--tags','--dirty']
-    return subprocess.check_output(args).strip()
+    return call(args).strip()
 
 def guess_distro():
     try:
         args = ['lsb_release','-i','-s']
-        return subprocess.check_output(args).strip().lower()
+        return call(args).strip().lower()
     except:
         return 'unknown'
 
@@ -50,38 +53,12 @@ def guess_distro():
 def guess_codename():
     try:
         args = ['lsb_release','-c','-s']
-        return subprocess.check_output(args).strip().lower()
+        return call(args).strip().lower()
     except:
         return 'unknown'
 
 
-def patch_subprocess():
-    if "check_output"  not in dir( subprocess ): # duck punch it in!
-        def check_output(*popenargs, **kwargs):
-            r"""Run command with arguments and return its output as a byte string.
-
-            Backported from Python 2.7 as it's implemented as pure python on stdlib.
-
-            >>> check_output(['/usr/bin/python', '--version'])
-            Python 2.6.2
-            """
-            process = subprocess.Popen(stdout=subprocess.PIPE, *popenargs, **kwargs)
-            output, unused_err = process.communicate()
-            retcode = process.poll()
-            if retcode:
-                cmd = kwargs.get("args")
-                if cmd is None:
-                    cmd = popenargs[0]
-                error = subprocess.CalledProcessError(retcode, cmd)
-                error.output = output
-                raise error
-            return output
-
-        subprocess.check_output = check_output
-
 def main():
-    patch_subprocess()
-
     parser = argparse.ArgumentParser(description='Generated debian/changelog from git log')
     parser.add_argument('--name',type=str,help='Name of package',required=True)
     parser.add_argument('--version',type=str,help='Place in git history to include upto',default='::guess::')
@@ -103,16 +80,15 @@ def main():
         args.version = git_version()
 
     tags = git_tags()
-
     if args.version in tags:
         idx = tags.index(args.version)
         tags = tags[idx:]
-        tags = zip(tags,tags)
+        tags = list(zip(tags,tags))
     else:
-        tags = zip(tags,tags)
+        tags = list(zip(tags,tags))
         tags.insert(0,(args.version,'HEAD'))
 
-    for i in xrange(0,len(tags)):
+    for i in range(0,len(tags)):
         tags[i] = (tags[i][0] + versuffix,tags[i][1])
 
     tag = tags[0]
@@ -122,13 +98,13 @@ def main():
             tag = prev
             continue
 
-        print('%s (%s) %s; urgency=%s\n' % (args.name,tag[0],args.codename,args.urgency))
+        print('{0} ({1}) {2}; urgency={3}\n'.format(args.name,tag[0],args.codename,args.urgency))
 
         for line in lines:
-            print "  * " + line
+            print("  * " + line)
 
         authorandtime = git_author_and_time(tag[1])
-        print(' %s\n' % authorandtime)
+        print(' {0}\n'.format(authorandtime))
 
         tag = prev
 

buildtools/install-build-pkgs

@@ -0,0 +1,49 @@
+#!/bin/sh
+
+if [ -e /usr/bin/apt-get ]; then
+    export DEBIAN_FRONTEND=noninteractive
+    apt-get -qy update
+    apt-get -qy --force-yes --no-install-suggests --no-install-recommends \
+	    install \
+            ca-certificates \
+            build-essential \
+            dpkg-dev \
+            git \
+            g++ \
+            debhelper \
+            lsb-release \
+            fakeroot
+    apt-get -qy --force-yes --no-install-suggests --no-install-recommends install python
+    apt-get -qy --force-yes --no-install-suggests --no-install-recommends install python3
+elif [ -e /usr/bin/dnf ]; then
+    dnf -y update
+    dnf -y install \
+        git rpm-build gcc-c++ make which python3
+elif [ -e /usr/bin/yum ]; then
+    yum -y update
+    yum -y install \
+        git rpm-build gcc-c++ make which \
+        python python-argparse
+    yum -y install centos-release-scl
+    yum -y install devtoolset-9-gcc\*
+elif [ -e /usr/bin/zypper ]; then
+    zypper update -y
+    zypper install -y \
+        git rpm-build gcc-c++ make which \
+        python
+elif [ -e /sbin/apk ]; then
+    apk add \
+        abuild git gcc g++ make \
+        linux-headers
+elif [ -e /usr/sbin/pkg ]; then
+    pkg install \
+        git gmake gcc
+fi
+
+if [ ! -e /usr/bin/python ]; then
+    if [ -e /usr/bin/python3 ]; then
+        ln -s /usr/bin/python3 /usr/bin/python
+    elif [ -e /usr/bin/python2 ]; then
+        ln -s /usr/bin/python2 /usr/bin/python
+    fi
+fi

buildtools/update-version

@@ -0,0 +1,18 @@
+#!/bin/sh
+
+VERSION=$(git describe --always --tags --dirty)
+if [ $? -ne 0 ]; then
+    VERSION=$(cat VERSION)
+fi
+
+if [ "${VERSION}" = "" ]; then
+    VERSION="unknown"
+fi
+
+echo -n "${VERSION}" > VERSION
+grep -q \"${VERSION}\" src/version.hpp
+RV=$?
+if [ $RV -ne 0 ]; then
+    echo "#pragma once" > src/version.hpp
+    echo "static const char MERGERFS_VERSION[] = \"${VERSION}\";" >> src/version.hpp
+fi

debian/compat

@@ -1 +0,0 @@
-9

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-compat (= 10)
 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/mergerfs.postinst

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

debian/rules

@@ -1,11 +1,13 @@
 #!/usr/bin/make -f
 # -*- makefile -*-
 
-# Uncomment this to turn on verbose mode.
-#export DH_VERBOSE=1
+export DH_VERBOSE=1
 
 %:
-	dh $@
+	dh $@ --parallel --max-parallel=6
+
+override_dh_strip:
+	dh_strip --no-automatic-dbgsym
 
 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,148 @@
+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 ($(NDEBUG),1)
+OPT_FLAGS := -O2 -DNDEBUG
+else
+OPT_FLAGS := -O0 -DDEBUG -g
+endif
+
+ifeq ($(LTO),1)
+LTO_FLAGS := -flto
+else
+LTO_FLAGS :=
+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_C = \
+	lib/buffer.c \
+	lib/crc32b.c \
+	lib/debug.c \
+	lib/fuse_dirents.c \
+	lib/fuse_lowlevel.c \
+	lib/fuse_opt.c \
+	lib/fuse_session.c \
+	lib/fuse_signals.c \
+	lib/helper.c \
+	lib/mount.c
+SRC_CPP = \
+	lib/fuse.cpp \
+	lib/cpu.cpp \
+	lib/fuse_config.cpp \
+	lib/fuse_loop.cpp \
+	lib/fuse_msgbuf.cpp \
+	lib/pin_threads.cpp \
+	lib/format.cpp \
+	lib/node.cpp \
+	lib/maintenance_thread.cpp
+
+OBJS_C   = $(SRC_C:lib/%.c=build/%.o)
+OBJS_CPP = $(SRC_CPP:lib/%.cpp=build/%.o)
+DEPS_C   = $(SRC_C:lib/%.c=build/%.d)
+DEPS_CPP = $(SRC_CPP:lib/%.cpp=build/%.d)
+CFLAGS ?= \
+	$(OPT_FLAGS)
+CFLAGS := \
+	${CFLAGS} \
+	$(LTO_FLAGS) \
+	-std=gnu99 \
+	-Wall \
+	-pipe \
+	-MMD
+CXXFLAGS ?= \
+	$(OPT_FLAGS)
+CXXFLAGS := \
+	${CXXFLAGS} \
+	$(LTO_FLAGS) \
+	-std=c++17 \
+	-Wall \
+	-pipe \
+	-MMD
+FUSERMOUNT_DIR = $(BINDIR)
+FUSE_FLAGS = \
+	-Iinclude \
+	-Ibuild \
+	-D_REENTRANT \
+	-D_FILE_OFFSET_BITS=64 \
+	-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_C) $(OBJS_CPP)
+
+build/libfuse.a: objects
+	${AR} rcs build/libfuse.a $(OBJS_C) $(OBJS_CPP)
+
+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:root "$(INSTALLBINDIR)/mergerfs-fusermount"
+	chmod u+s "$(INSTALLBINDIR)/mergerfs-fusermount"
+
+install: $(INSTALLUTILS)
+
+.PHONY: objects strip utils install install-utils
+
+-include $(DEPS_C) $(DEPS_CPP)

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_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/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/fmt/args.h

@@ -0,0 +1,220 @@
+// Formatting library for C++ - dynamic argument lists
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#ifndef FMT_MODULE
+#  include <functional>  // std::reference_wrapper
+#  include <memory>      // std::unique_ptr
+#  include <vector>
+#endif
+
+#include "format.h"  // std_string_view
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <typename T> auto unwrap(const T& v) -> const T& { return v; }
+template <typename T>
+auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
+  return static_cast<const T&>(v);
+}
+
+// node is defined outside dynamic_arg_list to workaround a C2504 bug in MSVC
+// 2022 (v17.10.0).
+//
+// Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+// templates it doesn't complain about inability to deduce single translation
+// unit for placing vtable. So node is made a fake template.
+template <typename = void> struct node {
+  virtual ~node() = default;
+  std::unique_ptr<node<>> next;
+};
+
+class dynamic_arg_list {
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
+    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = new_node->value;
+    new_node->next = std::move(head_);
+    head_ = std::move(new_node);
+    return value;
+  }
+};
+}  // namespace detail
+
+/**
+ * A dynamic list of formatting arguments with storage.
+ *
+ * It can be implicitly converted into `fmt::basic_format_args` for passing
+ * into type-erased formatting functions such as `fmt::vformat`.
+ */
+template <typename Context> class dynamic_format_arg_store {
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr detail::type mapped_type =
+        detail::mapped_type_constant<T, char_type>::value;
+
+    enum {
+      value = !(detail::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, detail::std_string_view<char_type>>::value ||
+                (mapped_type != detail::type::cstring_type &&
+                 mapped_type != detail::type::string_type &&
+                 mapped_type != detail::type::custom_type))
+    };
+  };
+
+  template <typename T>
+  using stored_t = conditional_t<
+      std::is_convertible<T, std::basic_string<char_type>>::value &&
+          !detail::is_reference_wrapper<T>::value,
+      std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+  std::vector<detail::named_arg_info<char_type>> named_info_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  detail::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  auto data() const -> const basic_format_arg<Context>* {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(arg);
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty())
+      data_.insert(data_.begin(), basic_format_arg<Context>(nullptr, 0));
+    data_.emplace_back(detail::unwrap(arg.value));
+    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
+      data->pop_back();
+    };
+    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
+        guard{&data_, pop_one};
+    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+    data_[0] = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  constexpr dynamic_format_arg_store() = default;
+
+  operator basic_format_args<Context>() const {
+    return basic_format_args<Context>(data(), static_cast<int>(data_.size()),
+                                      !named_info_.empty());
+  }
+
+  /**
+   * Adds an argument into the dynamic store for later passing to a formatting
+   * function.
+   *
+   * Note that custom types and string types (but not string views) are copied
+   * into the store dynamically allocating memory if necessary.
+   *
+   * **Example**:
+   *
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     store.push_back(42);
+   *     store.push_back("abc");
+   *     store.push_back(1.5f);
+   *     std::string result = fmt::vformat("{} and {} and {}", store);
+   */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_t<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+   * Adds a reference to the argument into the dynamic store for later passing
+   * to a formatting function.
+   *
+   * **Example**:
+   *
+   *     fmt::dynamic_format_arg_store<fmt::format_context> store;
+   *     char band[] = "Rolling Stones";
+   *     store.push_back(std::cref(band));
+   *     band[9] = 'c'; // Changing str affects the output.
+   *     std::string result = fmt::vformat("{}", store);
+   *     // result == "Rolling Scones"
+   */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+
+  /**
+   * Adds named argument into the dynamic store for later passing to a
+   * formatting function. `std::reference_wrapper` is supported to avoid
+   * copying of the argument. The name is always copied into the store.
+   */
+  template <typename T>
+  void push_back(const detail::named_arg<char_type, T>& arg) {
+    const char_type* arg_name =
+        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+    if (detail::const_check(need_copy<T>::value)) {
+      emplace_arg(
+          fmt::arg(arg_name, dynamic_args_.push<stored_t<T>>(arg.value)));
+    } else {
+      emplace_arg(fmt::arg(arg_name, arg.value));
+    }
+  }
+
+  /// Erase all elements from the store.
+  void clear() {
+    data_.clear();
+    named_info_.clear();
+    dynamic_args_ = {};
+  }
+
+  /// Reserves space to store at least `new_cap` arguments including
+  /// `new_cap_named` named arguments.
+  void reserve(size_t new_cap, size_t new_cap_named) {
+    FMT_ASSERT(new_cap >= new_cap_named,
+               "set of arguments includes set of named arguments");
+    data_.reserve(new_cap);
+    named_info_.reserve(new_cap_named);
+  }
+
+  /// Returns the number of elements in the store.
+  size_t size() const noexcept { return data_.size(); }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_

libfuse/include/fmt/color.h

@@ -0,0 +1,637 @@
+// Formatting library for C++ - color support
+//
+// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COLOR_H_
+#define FMT_COLOR_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+FMT_BEGIN_EXPORT
+
+enum class color : uint32_t {
+  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
+  antique_white = 0xFAEBD7,            // rgb(250,235,215)
+  aqua = 0x00FFFF,                     // rgb(0,255,255)
+  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
+  azure = 0xF0FFFF,                    // rgb(240,255,255)
+  beige = 0xF5F5DC,                    // rgb(245,245,220)
+  bisque = 0xFFE4C4,                   // rgb(255,228,196)
+  black = 0x000000,                    // rgb(0,0,0)
+  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
+  blue = 0x0000FF,                     // rgb(0,0,255)
+  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
+  brown = 0xA52A2A,                    // rgb(165,42,42)
+  burly_wood = 0xDEB887,               // rgb(222,184,135)
+  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
+  chartreuse = 0x7FFF00,               // rgb(127,255,0)
+  chocolate = 0xD2691E,                // rgb(210,105,30)
+  coral = 0xFF7F50,                    // rgb(255,127,80)
+  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
+  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
+  crimson = 0xDC143C,                  // rgb(220,20,60)
+  cyan = 0x00FFFF,                     // rgb(0,255,255)
+  dark_blue = 0x00008B,                // rgb(0,0,139)
+  dark_cyan = 0x008B8B,                // rgb(0,139,139)
+  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
+  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
+  dark_green = 0x006400,               // rgb(0,100,0)
+  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
+  dark_magenta = 0x8B008B,             // rgb(139,0,139)
+  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
+  dark_orange = 0xFF8C00,              // rgb(255,140,0)
+  dark_orchid = 0x9932CC,              // rgb(153,50,204)
+  dark_red = 0x8B0000,                 // rgb(139,0,0)
+  dark_salmon = 0xE9967A,              // rgb(233,150,122)
+  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
+  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
+  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
+  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
+  dark_violet = 0x9400D3,              // rgb(148,0,211)
+  deep_pink = 0xFF1493,                // rgb(255,20,147)
+  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
+  dim_gray = 0x696969,                 // rgb(105,105,105)
+  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
+  fire_brick = 0xB22222,               // rgb(178,34,34)
+  floral_white = 0xFFFAF0,             // rgb(255,250,240)
+  forest_green = 0x228B22,             // rgb(34,139,34)
+  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
+  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
+  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
+  gold = 0xFFD700,                     // rgb(255,215,0)
+  golden_rod = 0xDAA520,               // rgb(218,165,32)
+  gray = 0x808080,                     // rgb(128,128,128)
+  green = 0x008000,                    // rgb(0,128,0)
+  green_yellow = 0xADFF2F,             // rgb(173,255,47)
+  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
+  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
+  indian_red = 0xCD5C5C,               // rgb(205,92,92)
+  indigo = 0x4B0082,                   // rgb(75,0,130)
+  ivory = 0xFFFFF0,                    // rgb(255,255,240)
+  khaki = 0xF0E68C,                    // rgb(240,230,140)
+  lavender = 0xE6E6FA,                 // rgb(230,230,250)
+  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
+  lawn_green = 0x7CFC00,               // rgb(124,252,0)
+  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
+  light_blue = 0xADD8E6,               // rgb(173,216,230)
+  light_coral = 0xF08080,              // rgb(240,128,128)
+  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
+  light_gray = 0xD3D3D3,               // rgb(211,211,211)
+  light_green = 0x90EE90,              // rgb(144,238,144)
+  light_pink = 0xFFB6C1,               // rgb(255,182,193)
+  light_salmon = 0xFFA07A,             // rgb(255,160,122)
+  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
+  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
+  light_slate_gray = 0x778899,         // rgb(119,136,153)
+  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
+  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
+  lime = 0x00FF00,                     // rgb(0,255,0)
+  lime_green = 0x32CD32,               // rgb(50,205,50)
+  linen = 0xFAF0E6,                    // rgb(250,240,230)
+  magenta = 0xFF00FF,                  // rgb(255,0,255)
+  maroon = 0x800000,                   // rgb(128,0,0)
+  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
+  medium_blue = 0x0000CD,              // rgb(0,0,205)
+  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
+  medium_purple = 0x9370DB,            // rgb(147,112,219)
+  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
+  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
+  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
+  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
+  medium_violet_red = 0xC71585,        // rgb(199,21,133)
+  midnight_blue = 0x191970,            // rgb(25,25,112)
+  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
+  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
+  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
+  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
+  navy = 0x000080,                     // rgb(0,0,128)
+  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
+  olive = 0x808000,                    // rgb(128,128,0)
+  olive_drab = 0x6B8E23,               // rgb(107,142,35)
+  orange = 0xFFA500,                   // rgb(255,165,0)
+  orange_red = 0xFF4500,               // rgb(255,69,0)
+  orchid = 0xDA70D6,                   // rgb(218,112,214)
+  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
+  pale_green = 0x98FB98,               // rgb(152,251,152)
+  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
+  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
+  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
+  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
+  peru = 0xCD853F,                     // rgb(205,133,63)
+  pink = 0xFFC0CB,                     // rgb(255,192,203)
+  plum = 0xDDA0DD,                     // rgb(221,160,221)
+  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
+  purple = 0x800080,                   // rgb(128,0,128)
+  rebecca_purple = 0x663399,           // rgb(102,51,153)
+  red = 0xFF0000,                      // rgb(255,0,0)
+  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
+  royal_blue = 0x4169E1,               // rgb(65,105,225)
+  saddle_brown = 0x8B4513,             // rgb(139,69,19)
+  salmon = 0xFA8072,                   // rgb(250,128,114)
+  sandy_brown = 0xF4A460,              // rgb(244,164,96)
+  sea_green = 0x2E8B57,                // rgb(46,139,87)
+  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
+  sienna = 0xA0522D,                   // rgb(160,82,45)
+  silver = 0xC0C0C0,                   // rgb(192,192,192)
+  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
+  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
+  slate_gray = 0x708090,               // rgb(112,128,144)
+  snow = 0xFFFAFA,                     // rgb(255,250,250)
+  spring_green = 0x00FF7F,             // rgb(0,255,127)
+  steel_blue = 0x4682B4,               // rgb(70,130,180)
+  tan = 0xD2B48C,                      // rgb(210,180,140)
+  teal = 0x008080,                     // rgb(0,128,128)
+  thistle = 0xD8BFD8,                  // rgb(216,191,216)
+  tomato = 0xFF6347,                   // rgb(255,99,71)
+  turquoise = 0x40E0D0,                // rgb(64,224,208)
+  violet = 0xEE82EE,                   // rgb(238,130,238)
+  wheat = 0xF5DEB3,                    // rgb(245,222,179)
+  white = 0xFFFFFF,                    // rgb(255,255,255)
+  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
+  yellow = 0xFFFF00,                   // rgb(255,255,0)
+  yellow_green = 0x9ACD32              // rgb(154,205,50)
+};                                     // enum class color
+
+enum class terminal_color : uint8_t {
+  black = 30,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  bright_black = 90,
+  bright_red,
+  bright_green,
+  bright_yellow,
+  bright_blue,
+  bright_magenta,
+  bright_cyan,
+  bright_white
+};
+
+enum class emphasis : uint8_t {
+  bold = 1,
+  faint = 1 << 1,
+  italic = 1 << 2,
+  underline = 1 << 3,
+  blink = 1 << 4,
+  reverse = 1 << 5,
+  conceal = 1 << 6,
+  strikethrough = 1 << 7,
+};
+
+// rgb is a struct for red, green and blue colors.
+// Using the name "rgb" makes some editors show the color in a tooltip.
+struct rgb {
+  constexpr rgb() : r(0), g(0), b(0) {}
+  constexpr rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  constexpr rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  constexpr rgb(color hex)
+      : r((uint32_t(hex) >> 16) & 0xFF),
+        g((uint32_t(hex) >> 8) & 0xFF),
+        b(uint32_t(hex) & 0xFF) {}
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+namespace detail {
+
+// A bit-packed variant of an RGB color, a terminal color, or unset color.
+// see text_style for the bit-packing scheme.
+struct color_type {
+  constexpr color_type() noexcept = default;
+  constexpr color_type(color rgb_color) noexcept
+      : value_(static_cast<uint32_t>(rgb_color) | (1 << 24)) {}
+  constexpr color_type(rgb rgb_color) noexcept
+      : color_type(static_cast<color>(
+            (static_cast<uint32_t>(rgb_color.r) << 16) |
+            (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b)) {}
+  constexpr color_type(terminal_color term_color) noexcept
+      : value_(static_cast<uint32_t>(term_color) | (3 << 24)) {}
+
+  constexpr auto is_terminal_color() const noexcept -> bool {
+    return (value_ & (1 << 25)) != 0;
+  }
+
+  constexpr auto value() const noexcept -> uint32_t {
+    return value_ & 0xFFFFFF;
+  }
+
+  constexpr color_type(uint32_t value) noexcept : value_(value) {}
+
+  uint32_t value_ = 0;
+};
+}  // namespace detail
+
+/// A text style consisting of foreground and background colors and emphasis.
+class text_style {
+  // The information is packed as follows:
+  // ┌──┐
+  // │ 0│─┐
+  // │..│ ├── foreground color value
+  // │23│─┘
+  // ├──┤
+  // │24│─┬── discriminator for the above value. 00 if unset, 01 if it's
+  // │25│─┘   an RGB color, or 11 if it's a terminal color (10 is unused)
+  // ├──┤
+  // │26│──── overflow bit, always zero (see below)
+  // ├──┤
+  // │27│─┐
+  // │..│ │
+  // │50│ │
+  // ├──┤ │
+  // │51│ ├── background color (same format as the foreground color)
+  // │52│ │
+  // ├──┤ │
+  // │53│─┘
+  // ├──┤
+  // │54│─┐
+  // │..│ ├── emphases
+  // │61│─┘
+  // ├──┤
+  // │62│─┬── unused
+  // │63│─┘
+  // └──┘
+  // The overflow bits are there to make operator|= efficient.
+  // When ORing, we must throw if, for either the foreground or background,
+  // one style specifies a terminal color and the other specifies any color
+  // (terminal or RGB); in other words, if one discriminator is 11 and the
+  // other is 11 or 01.
+  //
+  // We do that check by adding the styles. Consider what adding does to each
+  // possible pair of discriminators:
+  //    00 + 00 = 000
+  //    01 + 00 = 001
+  //    11 + 00 = 011
+  //    01 + 01 = 010
+  //    11 + 01 = 100 (!!)
+  //    11 + 11 = 110 (!!)
+  // In the last two cases, the ones we want to catch, the third bit——the
+  // overflow bit——is set. Bingo.
+  //
+  // We must take into account the possible carry bit from the bits
+  // before the discriminator. The only potentially problematic case is
+  // 11 + 00 = 011 (a carry bit would make it 100, not good!), but a carry
+  // bit is impossible in that case, because 00 (unset color) means the
+  // 24 bits that precede the discriminator are all zero.
+  //
+  // This test can be applied to both colors simultaneously.
+
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
+      : style_(static_cast<uint64_t>(em) << 54) {}
+
+  FMT_CONSTEXPR auto operator|=(text_style rhs) -> text_style& {
+    if (((style_ + rhs.style_) & ((1ULL << 26) | (1ULL << 53))) != 0)
+      report_error("can't OR a terminal color");
+    style_ |= rhs.style_;
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR auto operator|(text_style lhs, text_style rhs)
+      -> text_style {
+    return lhs |= rhs;
+  }
+
+  FMT_CONSTEXPR auto operator==(text_style rhs) const noexcept -> bool {
+    return style_ == rhs.style_;
+  }
+
+  FMT_CONSTEXPR auto operator!=(text_style rhs) const noexcept -> bool {
+    return !(*this == rhs);
+  }
+
+  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
+    return (style_ & (1 << 24)) != 0;
+  }
+  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
+    return (style_ & (1ULL << 51)) != 0;
+  }
+  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
+    return (style_ >> 54) != 0;
+  }
+  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return style_ & 0x3FFFFFF;
+  }
+  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return (style_ >> 27) & 0x3FFFFFF;
+  }
+  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return static_cast<emphasis>(style_ >> 54);
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(uint64_t style) noexcept : style_(style) {}
+
+  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
+      -> text_style;
+
+  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
+      -> text_style;
+
+  uint64_t style_ = 0;
+};
+
+/// Creates a text style from the foreground (text) color.
+FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
+    -> text_style {
+  return foreground.value_;
+}
+
+/// Creates a text style from the background color.
+FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
+    -> text_style {
+  return static_cast<uint64_t>(background.value_) << 27;
+}
+
+FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
+    -> text_style {
+  return text_style(lhs) | rhs;
+}
+
+namespace detail {
+
+template <typename Char> struct ansi_color_escape {
+  FMT_CONSTEXPR ansi_color_escape(color_type text_color,
+                                  const char* esc) noexcept {
+    // If we have a terminal color, we need to output another escape code
+    // sequence.
+    if (text_color.is_terminal_color()) {
+      bool is_background = esc == string_view("\x1b[48;2;");
+      uint32_t value = text_color.value();
+      // Background ASCII codes are the same as the foreground ones but with
+      // 10 more.
+      if (is_background) value += 10u;
+
+      size_t index = 0;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+
+      if (value >= 100u) {
+        buffer[index++] = static_cast<Char>('1');
+        value %= 100u;
+      }
+      buffer[index++] = static_cast<Char>('0' + value / 10u);
+      buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+      buffer[index++] = static_cast<Char>('m');
+      buffer[index++] = static_cast<Char>('\0');
+      return;
+    }
+
+    for (int i = 0; i < 7; i++) {
+      buffer[i] = static_cast<Char>(esc[i]);
+    }
+    rgb color(text_color.value());
+    to_esc(color.r, buffer + 7, ';');
+    to_esc(color.g, buffer + 11, ';');
+    to_esc(color.b, buffer + 15, 'm');
+    buffer[19] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) noexcept {
+    uint8_t em_codes[num_emphases] = {};
+    if (has_emphasis(em, emphasis::bold)) em_codes[0] = 1;
+    if (has_emphasis(em, emphasis::faint)) em_codes[1] = 2;
+    if (has_emphasis(em, emphasis::italic)) em_codes[2] = 3;
+    if (has_emphasis(em, emphasis::underline)) em_codes[3] = 4;
+    if (has_emphasis(em, emphasis::blink)) em_codes[4] = 5;
+    if (has_emphasis(em, emphasis::reverse)) em_codes[5] = 7;
+    if (has_emphasis(em, emphasis::conceal)) em_codes[6] = 8;
+    if (has_emphasis(em, emphasis::strikethrough)) em_codes[7] = 9;
+
+    size_t index = 0;
+    for (size_t i = 0; i < num_emphases; ++i) {
+      if (!em_codes[i]) continue;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+      buffer[index++] = static_cast<Char>('m');
+    }
+    buffer[index++] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR operator const Char*() const noexcept { return buffer; }
+
+  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
+  FMT_CONSTEXPR20 auto end() const noexcept -> const Char* {
+    return buffer + basic_string_view<Char>(buffer).size();
+  }
+
+ private:
+  static constexpr size_t num_emphases = 8;
+  Char buffer[7u + 3u * num_emphases + 1u];
+
+  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
+                                   char delimiter) noexcept {
+    out[0] = static_cast<Char>('0' + c / 100);
+    out[1] = static_cast<Char>('0' + c / 10 % 10);
+    out[2] = static_cast<Char>('0' + c % 10);
+    out[3] = static_cast<Char>(delimiter);
+  }
+  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
+      -> bool {
+    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
+  }
+};
+
+template <typename Char>
+FMT_CONSTEXPR auto make_foreground_color(color_type foreground) noexcept
+    -> ansi_color_escape<Char> {
+  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto make_background_color(color_type background) noexcept
+    -> ansi_color_escape<Char> {
+  return ansi_color_escape<Char>(background, "\x1b[48;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
+    -> ansi_color_escape<Char> {
+  return ansi_color_escape<Char>(em);
+}
+
+template <typename Char> inline void reset_color(buffer<Char>& buffer) {
+  auto reset_color = string_view("\x1b[0m");
+  buffer.append(reset_color.begin(), reset_color.end());
+}
+
+template <typename T> struct styled_arg : view {
+  const T& value;
+  text_style style;
+  styled_arg(const T& v, text_style s) : value(v), style(s) {}
+};
+
+template <typename Char>
+void vformat_to(buffer<Char>& buf, text_style ts, basic_string_view<Char> fmt,
+                basic_format_args<buffered_context<Char>> args) {
+  if (ts.has_emphasis()) {
+    auto emphasis = make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    auto foreground = make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    auto background = make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  vformat_to(buf, fmt, args);
+  if (ts != text_style()) reset_color<Char>(buf);
+}
+}  // namespace detail
+
+inline void vprint(FILE* f, text_style ts, string_view fmt, format_args args) {
+  auto buf = memory_buffer();
+  detail::vformat_to(buf, ts, fmt, args);
+  print(f, FMT_STRING("{}"), string_view(buf.begin(), buf.size()));
+}
+
+/**
+ * Formats a string and prints it to the specified file stream using ANSI
+ * escape sequences to specify text formatting.
+ *
+ * **Example**:
+ *
+ *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+ *                "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename... T>
+void print(FILE* f, text_style ts, format_string<T...> fmt, T&&... args) {
+  vprint(f, ts, fmt.str, vargs<T...>{{args...}});
+}
+
+/**
+ * Formats a string and prints it to stdout using ANSI escape sequences to
+ * specify text formatting.
+ *
+ * **Example**:
+ *
+ *     fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+ *                "Elapsed time: {0:.2f} seconds", 1.23);
+ */
+template <typename... T>
+void print(text_style ts, format_string<T...> fmt, T&&... args) {
+  return print(stdout, ts, fmt, std::forward<T>(args)...);
+}
+
+inline auto vformat(text_style ts, string_view fmt, format_args args)
+    -> std::string {
+  auto buf = memory_buffer();
+  detail::vformat_to(buf, ts, fmt, args);
+  return fmt::to_string(buf);
+}
+
+/**
+ * Formats arguments and returns the result as a string using ANSI escape
+ * sequences to specify text formatting.
+ *
+ * **Example**:
+ *
+ * ```
+ * #include <fmt/color.h>
+ * std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+ *                                   "The answer is {}", 42);
+ * ```
+ */
+template <typename... T>
+inline auto format(text_style ts, format_string<T...> fmt, T&&... args)
+    -> std::string {
+  return fmt::vformat(ts, fmt.str, vargs<T...>{{args...}});
+}
+
+/// Formats a string with the given text_style and writes the output to `out`.
+template <typename OutputIt,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+auto vformat_to(OutputIt out, text_style ts, string_view fmt, format_args args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<char>(out);
+  detail::vformat_to(buf, ts, fmt, args);
+  return detail::get_iterator(buf, out);
+}
+
+/**
+ * Formats arguments with the given text style, writes the result to the output
+ * iterator `out` and returns the iterator past the end of the output range.
+ *
+ * **Example**:
+ *
+ *     std::vector<char> out;
+ *     fmt::format_to(std::back_inserter(out),
+ *                    fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+ */
+template <typename OutputIt, typename... T,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, char>::value)>
+inline auto format_to(OutputIt out, text_style ts, format_string<T...> fmt,
+                      T&&... args) -> OutputIt {
+  return vformat_to(out, ts, fmt.str, vargs<T...>{{args...}});
+}
+
+template <typename T, typename Char>
+struct formatter<detail::styled_arg<T>, Char> : formatter<T, Char> {
+  template <typename FormatContext>
+  auto format(const detail::styled_arg<T>& arg, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    const auto& ts = arg.style;
+    auto out = ctx.out();
+
+    bool has_style = false;
+    if (ts.has_emphasis()) {
+      has_style = true;
+      auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+      out = detail::copy<Char>(emphasis.begin(), emphasis.end(), out);
+    }
+    if (ts.has_foreground()) {
+      has_style = true;
+      auto foreground =
+          detail::make_foreground_color<Char>(ts.get_foreground());
+      out = detail::copy<Char>(foreground.begin(), foreground.end(), out);
+    }
+    if (ts.has_background()) {
+      has_style = true;
+      auto background =
+          detail::make_background_color<Char>(ts.get_background());
+      out = detail::copy<Char>(background.begin(), background.end(), out);
+    }
+    out = formatter<T, Char>::format(arg.value, ctx);
+    if (has_style) {
+      auto reset_color = string_view("\x1b[0m");
+      out = detail::copy<Char>(reset_color.begin(), reset_color.end(), out);
+    }
+    return out;
+  }
+};
+
+/**
+ * Returns an argument that will be formatted using ANSI escape sequences,
+ * to be used in a formatting function.
+ *
+ * **Example**:
+ *
+ *     fmt::print("Elapsed time: {0:.2f} seconds",
+ *                fmt::styled(1.23, fmt::fg(fmt::color::green) |
+ *                                  fmt::bg(fmt::color::blue)));
+ */
+template <typename T>
+FMT_CONSTEXPR auto styled(const T& value, text_style ts)
+    -> detail::styled_arg<remove_cvref_t<T>> {
+  return detail::styled_arg<remove_cvref_t<T>>{value, ts};
+}
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_COLOR_H_

libfuse/include/fmt/compile.h

@@ -0,0 +1,539 @@
+// Formatting library for C++ - experimental format string compilation
+//
+// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COMPILE_H_
+#define FMT_COMPILE_H_
+
+#ifndef FMT_MODULE
+#  include <iterator>  // std::back_inserter
+#endif
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+// A compile-time string which is compiled into fast formatting code.
+FMT_EXPORT class compiled_string {};
+
+template <typename S>
+struct is_compiled_string : std::is_base_of<compiled_string, S> {};
+
+namespace detail {
+
+/**
+ * Converts a string literal `s` into a format string that will be parsed at
+ * compile time and converted into efficient formatting code. Requires C++17
+ * `constexpr if` compiler support.
+ *
+ * **Example**:
+ *
+ *     // Converts 42 into std::string using the most efficient method and no
+ *     // runtime format string processing.
+ *     std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+ */
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+#  define FMT_COMPILE(s) FMT_STRING_IMPL(s, fmt::compiled_string)
+#else
+#  define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+template <typename T, typename... Tail>
+auto first(const T& value, const Tail&...) -> const T& {
+  return value;
+}
+
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+template <typename... Args> struct type_list {};
+
+// Returns a reference to the argument at index N from [first, rest...].
+template <int N, typename T, typename... Args>
+constexpr const auto& get([[maybe_unused]] const T& first,
+                          [[maybe_unused]] const Args&... rest) {
+  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+  if constexpr (N == 0)
+    return first;
+  else
+    return detail::get<N - 1>(rest...);
+}
+
+#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <int N, typename T, typename... Args, typename Char>
+constexpr auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+  if constexpr (is_static_named_arg<T>()) {
+    if (name == T::name) return N;
+  }
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<N + 1, Args...>(name);
+  (void)name;  // Workaround an MSVC bug about "unused" parameter.
+  return -1;
+}
+#  endif
+
+template <typename... Args, typename Char>
+FMT_CONSTEXPR auto get_arg_index_by_name(basic_string_view<Char> name) -> int {
+#  if FMT_USE_NONTYPE_TEMPLATE_ARGS
+  if constexpr (sizeof...(Args) > 0)
+    return get_arg_index_by_name<0, Args...>(name);
+#  endif
+  (void)name;
+  return -1;
+}
+
+template <typename Char, typename... Args>
+constexpr int get_arg_index_by_name(basic_string_view<Char> name,
+                                    type_list<Args...>) {
+  return get_arg_index_by_name<Args...>(name);
+}
+
+template <int N, typename> struct get_type_impl;
+
+template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
+  using type =
+      remove_cvref_t<decltype(detail::get<N>(std::declval<Args>()...))>;
+};
+
+template <int N, typename T>
+using get_type = typename get_type_impl<N, T>::type;
+
+template <typename T> struct is_compiled_format : std::false_type {};
+
+template <typename Char> struct text {
+  basic_string_view<Char> data;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    return write<Char>(out, data);
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<text<Char>> : std::true_type {};
+
+template <typename Char>
+constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
+                               size_t size) {
+  return {{&s[pos], size}};
+}
+
+template <typename Char> struct code_unit {
+  Char value;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    *out++ = value;
+    return out;
+  }
+};
+
+// This ensures that the argument type is convertible to `const T&`.
+template <typename T, int N, typename... Args>
+constexpr const T& get_arg_checked(const Args&... args) {
+  const auto& arg = detail::get<N>(args...);
+  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
+    return arg.value;
+  } else {
+    return arg;
+  }
+}
+
+template <typename Char>
+struct is_compiled_format<code_unit<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N.
+template <typename Char, typename T, int N> struct field {
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    const T& arg = get_arg_checked<T, N>(args...);
+    if constexpr (std::is_convertible<T, basic_string_view<Char>>::value) {
+      auto s = basic_string_view<Char>(arg);
+      return copy<Char>(s.begin(), s.end(), out);
+    } else {
+      return write<Char>(out, arg);
+    }
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<field<Char, T, N>> : std::true_type {};
+
+// A replacement field that refers to argument with name.
+template <typename Char> struct runtime_named_field {
+  using char_type = Char;
+  basic_string_view<Char> name;
+
+  template <typename OutputIt, typename T>
+  constexpr static bool try_format_argument(
+      OutputIt& out,
+      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
+      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
+    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
+      if (arg_name == arg.name) {
+        out = write<Char>(out, arg.value);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    bool found = (try_format_argument(out, name, args) || ...);
+    if (!found) {
+      FMT_THROW(format_error("argument with specified name is not found"));
+    }
+    return out;
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N and has format specifiers.
+template <typename Char, typename T, int N> struct spec_field {
+  using char_type = Char;
+  formatter<T, Char> fmt;
+
+  template <typename OutputIt, typename... Args>
+  constexpr FMT_INLINE OutputIt format(OutputIt out,
+                                       const Args&... args) const {
+    const auto& vargs =
+        fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
+    basic_format_context<OutputIt, Char> ctx(out, vargs);
+    return fmt.format(get_arg_checked<T, N>(args...), ctx);
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};
+
+template <typename L, typename R> struct concat {
+  L lhs;
+  R rhs;
+  using char_type = typename L::char_type;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    out = lhs.format(out, args...);
+    return rhs.format(out, args...);
+  }
+};
+
+template <typename L, typename R>
+struct is_compiled_format<concat<L, R>> : std::true_type {};
+
+template <typename L, typename R>
+constexpr concat<L, R> make_concat(L lhs, R rhs) {
+  return {lhs, rhs};
+}
+
+struct unknown_format {};
+
+template <typename Char>
+constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
+  for (size_t size = str.size(); pos != size; ++pos) {
+    if (str[pos] == '{' || str[pos] == '}') break;
+  }
+  return pos;
+}
+
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S fmt);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S fmt) {
+  if constexpr (POS != basic_string_view<typename S::char_type>(fmt).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(fmt);
+    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
+                               unknown_format>())
+      return tail;
+    else
+      return make_concat(head, tail);
+  } else {
+    return head;
+  }
+}
+
+template <typename T, typename Char> struct parse_specs_result {
+  formatter<T, Char> fmt;
+  size_t end;
+  int next_arg_id;
+};
+
+enum { manual_indexing_id = -1 };
+
+template <typename T, typename Char>
+constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
+                                                  size_t pos, int next_arg_id) {
+  str.remove_prefix(pos);
+  auto ctx =
+      compile_parse_context<Char>(str, max_value<int>(), nullptr, next_arg_id);
+  auto f = formatter<T, Char>();
+  auto end = f.parse(ctx);
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()),
+          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
+}
+
+template <typename Char> struct arg_id_handler {
+  arg_id_kind kind;
+  arg_ref<Char> arg_id;
+
+  constexpr int on_auto() {
+    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
+    return 0;
+  }
+  constexpr int on_index(int id) {
+    kind = arg_id_kind::index;
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+  constexpr int on_name(basic_string_view<Char> id) {
+    kind = arg_id_kind::name;
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+};
+
+template <typename Char> struct parse_arg_id_result {
+  arg_id_kind kind;
+  arg_ref<Char> arg_id;
+  const Char* arg_id_end;
+};
+
+template <int ID, typename Char>
+constexpr auto parse_arg_id(const Char* begin, const Char* end) {
+  auto handler = arg_id_handler<Char>{arg_id_kind::none, arg_ref<Char>{}};
+  auto arg_id_end = parse_arg_id(begin, end, handler);
+  return parse_arg_id_result<Char>{handler.kind, handler.arg_id, arg_id_end};
+}
+
+template <typename T, typename Enable = void> struct field_type {
+  using type = remove_cvref_t<T>;
+};
+
+template <typename T>
+struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
+  using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
+          typename S>
+constexpr auto parse_replacement_field_then_tail(S fmt) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(fmt);
+  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
+  if constexpr (c == '}') {
+    return parse_tail<Args, END_POS + 1, NEXT_ID>(
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(), fmt);
+  } else if constexpr (c != ':') {
+    FMT_THROW(format_error("expected ':'"));
+  } else {
+    constexpr auto result = parse_specs<typename field_type<T>::type>(
+        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
+    if constexpr (result.end >= str.size() || str[result.end] != '}') {
+      FMT_THROW(format_error("expected '}'"));
+      return 0;
+    } else {
+      return parse_tail<Args, result.end + 1, result.next_arg_id>(
+          spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+              result.fmt},
+          fmt);
+    }
+  }
+}
+
+// Compiles a non-empty format string and returns the compiled representation
+// or unknown_format() on unrecognized input.
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S fmt) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(fmt);
+  if constexpr (str[POS] == '{') {
+    if constexpr (POS + 1 == str.size())
+      FMT_THROW(format_error("unmatched '{' in format string"));
+    if constexpr (str[POS + 1] == '{') {
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
+      static_assert(ID != manual_indexing_id,
+                    "cannot switch from manual to automatic argument indexing");
+      constexpr auto next_id =
+          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
+                                               POS + 1, ID, next_id>(fmt);
+    } else {
+      constexpr auto arg_id_result =
+          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
+      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
+      constexpr char_type c =
+          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
+      static_assert(c == '}' || c == ':', "missing '}' in format string");
+      if constexpr (arg_id_result.kind == arg_id_kind::index) {
+        static_assert(
+            ID == manual_indexing_id || ID == 0,
+            "cannot switch from automatic to manual argument indexing");
+        constexpr auto arg_index = arg_id_result.arg_id.index;
+        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
+                                                 Args, arg_id_end_pos,
+                                                 arg_index, manual_indexing_id>(
+            fmt);
+      } else if constexpr (arg_id_result.kind == arg_id_kind::name) {
+        constexpr auto arg_index =
+            get_arg_index_by_name(arg_id_result.arg_id.name, Args{});
+        if constexpr (arg_index >= 0) {
+          constexpr auto next_id =
+              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+          return parse_replacement_field_then_tail<
+              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
+              arg_index, next_id>(fmt);
+        } else if constexpr (c == '}') {
+          return parse_tail<Args, arg_id_end_pos + 1, ID>(
+              runtime_named_field<char_type>{arg_id_result.arg_id.name}, fmt);
+        } else if constexpr (c == ':') {
+          return unknown_format();  // no type info for specs parsing
+        }
+      }
+    }
+  } else if constexpr (str[POS] == '}') {
+    if constexpr (POS + 1 == str.size())
+      FMT_THROW(format_error("unmatched '}' in format string"));
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), fmt);
+  } else {
+    constexpr auto end = parse_text(str, POS + 1);
+    if constexpr (end - POS > 1) {
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS), fmt);
+    } else {
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]}, fmt);
+    }
+  }
+}
+
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+constexpr auto compile(S fmt) {
+  constexpr auto str = basic_string_view<typename S::char_type>(fmt);
+  if constexpr (str.size() == 0) {
+    return detail::make_text(str, 0, 0);
+  } else {
+    constexpr auto result =
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(fmt);
+    return result;
+  }
+}
+#endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
+
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
+                                          const Args&... args) {
+  auto s = std::basic_string<Char>();
+  cf.format(std::back_inserter(s), args...);
+  return s;
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                                        const Args&... args) {
+  return cf.format(out, args...);
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
+                                                           Args&&... args) {
+  if constexpr (std::is_same<typename S::char_type, char>::value) {
+    constexpr auto str = basic_string_view<typename S::char_type>(S());
+    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
+      const auto& first = detail::first(args...);
+      if constexpr (detail::is_named_arg<
+                        remove_cvref_t<decltype(first)>>::value) {
+        return fmt::to_string(first.value);
+      } else {
+        return fmt::to_string(first);
+      }
+    }
+  }
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return fmt::format(
+        static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
+  } else {
+    return fmt::format(compiled, std::forward<Args>(args)...);
+  }
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return fmt::format_to(
+        out, static_cast<basic_string_view<typename S::char_type>>(S()),
+        std::forward<Args>(args)...);
+  } else {
+    return fmt::format_to(out, compiled, std::forward<Args>(args)...);
+  }
+}
+#endif
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+auto format_to_n(OutputIt out, size_t n, const S& fmt, Args&&... args)
+    -> format_to_n_result<OutputIt> {
+  using traits = detail::fixed_buffer_traits;
+  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
+  fmt::format_to(std::back_inserter(buf), fmt, std::forward<Args>(args)...);
+  return {buf.out(), buf.count()};
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+FMT_CONSTEXPR20 auto formatted_size(const S& fmt, const Args&... args)
+    -> size_t {
+  auto buf = detail::counting_buffer<>();
+  fmt::format_to(appender(buf), fmt, args...);
+  return buf.count();
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& fmt, const Args&... args) {
+  auto buf = memory_buffer();
+  fmt::format_to(appender(buf), fmt, args...);
+  detail::print(f, {buf.data(), buf.size()});
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(is_compiled_string<S>::value)>
+void print(const S& fmt, const Args&... args) {
+  print(stdout, fmt, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+inline namespace literals {
+template <detail::fixed_string Str> constexpr auto operator""_cf() {
+  return FMT_COMPILE(Str.data);
+}
+}  // namespace literals
+#endif
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_

libfuse/include/fmt/core.h

@@ -0,0 +1,5 @@
+// This file is only provided for compatibility and may be removed in future
+// versions. Use fmt/base.h if you don't need fmt::format and fmt/format.h
+// otherwise.
+
+#include "format.h"

libfuse/include/fmt/os.h

@@ -0,0 +1,427 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OS_H_
+#define FMT_OS_H_
+
+#include "format.h"
+
+#ifndef FMT_MODULE
+#  include <cerrno>
+#  include <cstddef>
+#  include <cstdio>
+#  include <system_error>  // std::system_error
+
+#  if FMT_HAS_INCLUDE(<xlocale.h>)
+#    include <xlocale.h>  // LC_NUMERIC_MASK on macOS
+#  endif
+#endif  // FMT_MODULE
+
+#ifndef FMT_USE_FCNTL
+// UWP doesn't provide _pipe.
+#  if FMT_HAS_INCLUDE("winapifamily.h")
+#    include <winapifamily.h>
+#  endif
+#  if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
+       defined(__linux__)) &&                              \
+      (!defined(WINAPI_FAMILY) ||                          \
+       (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#    include <fcntl.h>  // for O_RDONLY
+#    define FMT_USE_FCNTL 1
+#  else
+#    define FMT_USE_FCNTL 0
+#  endif
+#endif
+
+#ifndef FMT_POSIX
+#  if defined(_WIN32) && !defined(__MINGW32__)
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX(call) _##call
+#  else
+#    define FMT_POSIX(call) call
+#  endif
+#endif
+
+// Calls to system functions are wrapped in FMT_SYSTEM for testability.
+#ifdef FMT_SYSTEM
+#  define FMT_HAS_SYSTEM
+#  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
+#else
+#  define FMT_SYSTEM(call) ::call
+#  ifdef _WIN32
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX_CALL(call) ::_##call
+#  else
+#    define FMT_POSIX_CALL(call) ::call
+#  endif
+#endif
+
+// Retries the expression while it evaluates to error_result and errno
+// equals to EINTR.
+#ifndef _WIN32
+#  define FMT_RETRY_VAL(result, expression, error_result) \
+    do {                                                  \
+      (result) = (expression);                            \
+    } while ((result) == (error_result) && errno == EINTR)
+#else
+#  define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
+#endif
+
+#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
+
+FMT_BEGIN_NAMESPACE
+FMT_BEGIN_EXPORT
+
+/**
+ * A reference to a null-terminated string. It can be constructed from a C
+ * string or `std::string`.
+ *
+ * You can use one of the following type aliases for common character types:
+ *
+ * +---------------+-----------------------------+
+ * | Type          | Definition                  |
+ * +===============+=============================+
+ * | cstring_view  | basic_cstring_view<char>    |
+ * +---------------+-----------------------------+
+ * | wcstring_view | basic_cstring_view<wchar_t> |
+ * +---------------+-----------------------------+
+ *
+ * This class is most useful as a parameter type for functions that wrap C APIs.
+ */
+template <typename Char> class basic_cstring_view {
+ private:
+  const Char* data_;
+
+ public:
+  /// Constructs a string reference object from a C string.
+  basic_cstring_view(const Char* s) : data_(s) {}
+
+  /// Constructs a string reference from an `std::string` object.
+  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
+
+  /// Returns the pointer to a C string.
+  auto c_str() const -> const Char* { return data_; }
+};
+
+using cstring_view = basic_cstring_view<char>;
+using wcstring_view = basic_cstring_view<wchar_t>;
+
+#ifdef _WIN32
+FMT_API const std::error_category& system_category() noexcept;
+
+namespace detail {
+FMT_API void format_windows_error(buffer<char>& out, int error_code,
+                                  const char* message) noexcept;
+}
+
+FMT_API std::system_error vwindows_error(int error_code, string_view fmt,
+                                         format_args args);
+
+/**
+ * Constructs a `std::system_error` object with the description of the form
+ *
+ *     <message>: <system-message>
+ *
+ * where `<message>` is the formatted message and `<system-message>` is the
+ * system message corresponding to the error code.
+ * `error_code` is a Windows error code as given by `GetLastError`.
+ * If `error_code` is not a valid error code such as -1, the system message
+ * will look like "error -1".
+ *
+ * **Example**:
+ *
+ *     // This throws a system_error with the description
+ *     //   cannot open file 'madeup': The system cannot find the file
+ * specified.
+ *     // or similar (system message may vary).
+ *     const char *filename = "madeup";
+ *     LPOFSTRUCT of = LPOFSTRUCT();
+ *     HFILE file = OpenFile(filename, &of, OF_READ);
+ *     if (file == HFILE_ERROR) {
+ *       throw fmt::windows_error(GetLastError(),
+ *                                "cannot open file '{}'", filename);
+ *     }
+ */
+template <typename... T>
+auto windows_error(int error_code, string_view message, const T&... args)
+    -> std::system_error {
+  return vwindows_error(error_code, message, vargs<T...>{{args...}});
+}
+
+// Reports a Windows error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_windows_error(int error_code, const char* message) noexcept;
+#else
+inline auto system_category() noexcept -> const std::error_category& {
+  return std::system_category();
+}
+#endif  // _WIN32
+
+// std::system is not available on some platforms such as iOS (#2248).
+#ifdef __OSX__
+template <typename S, typename... Args, typename Char = char_t<S>>
+void say(const S& fmt, Args&&... args) {
+  std::system(format("say \"{}\"", format(fmt, args...)).c_str());
+}
+#endif
+
+// A buffered file.
+class buffered_file {
+ private:
+  FILE* file_;
+
+  friend class file;
+
+  inline explicit buffered_file(FILE* f) : file_(f) {}
+
+ public:
+  buffered_file(const buffered_file&) = delete;
+  void operator=(const buffered_file&) = delete;
+
+  // Constructs a buffered_file object which doesn't represent any file.
+  inline buffered_file() noexcept : file_(nullptr) {}
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() noexcept;
+
+ public:
+  inline buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
+    other.file_ = nullptr;
+  }
+
+  inline auto operator=(buffered_file&& other) -> buffered_file& {
+    close();
+    file_ = other.file_;
+    other.file_ = nullptr;
+    return *this;
+  }
+
+  // Opens a file.
+  FMT_API buffered_file(cstring_view filename, cstring_view mode);
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the pointer to a FILE object representing this file.
+  inline auto get() const noexcept -> FILE* { return file_; }
+
+  FMT_API auto descriptor() const -> int;
+
+  template <typename... T>
+  inline void print(string_view fmt, const T&... args) {
+    fmt::vargs<T...> vargs = {{args...}};
+    detail::is_locking<T...>() ? fmt::vprint_buffered(file_, fmt, vargs)
+                               : fmt::vprint(file_, fmt, vargs);
+  }
+};
+
+#if FMT_USE_FCNTL
+
+// A file. Closed file is represented by a file object with descriptor -1.
+// Methods that are not declared with noexcept may throw
+// fmt::system_error in case of failure. Note that some errors such as
+// closing the file multiple times will cause a crash on Windows rather
+// than an exception. You can get standard behavior by overriding the
+// invalid parameter handler with _set_invalid_parameter_handler.
+class FMT_API file {
+ private:
+  int fd_;  // File descriptor.
+
+  // Constructs a file object with a given descriptor.
+  explicit file(int fd) : fd_(fd) {}
+
+  friend struct pipe;
+
+ public:
+  // Possible values for the oflag argument to the constructor.
+  enum {
+    RDONLY = FMT_POSIX(O_RDONLY),  // Open for reading only.
+    WRONLY = FMT_POSIX(O_WRONLY),  // Open for writing only.
+    RDWR = FMT_POSIX(O_RDWR),      // Open for reading and writing.
+    CREATE = FMT_POSIX(O_CREAT),   // Create if the file doesn't exist.
+    APPEND = FMT_POSIX(O_APPEND),  // Open in append mode.
+    TRUNC = FMT_POSIX(O_TRUNC)     // Truncate the content of the file.
+  };
+
+  // Constructs a file object which doesn't represent any file.
+  inline file() noexcept : fd_(-1) {}
+
+  // Opens a file and constructs a file object representing this file.
+  file(cstring_view path, int oflag);
+
+ public:
+  file(const file&) = delete;
+  void operator=(const file&) = delete;
+
+  inline file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+
+  // Move assignment is not noexcept because close may throw.
+  inline auto operator=(file&& other) -> file& {
+    close();
+    fd_ = other.fd_;
+    other.fd_ = -1;
+    return *this;
+  }
+
+  // Destroys the object closing the file it represents if any.
+  ~file() noexcept;
+
+  // Returns the file descriptor.
+  inline auto descriptor() const noexcept -> int { return fd_; }
+
+  // Closes the file.
+  void close();
+
+  // Returns the file size. The size has signed type for consistency with
+  // stat::st_size.
+  auto size() const -> long long;
+
+  // Attempts to read count bytes from the file into the specified buffer.
+  auto read(void* buffer, size_t count) -> size_t;
+
+  // Attempts to write count bytes from the specified buffer to the file.
+  auto write(const void* buffer, size_t count) -> size_t;
+
+  // Duplicates a file descriptor with the dup function and returns
+  // the duplicate as a file object.
+  static auto dup(int fd) -> file;
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  void dup2(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  void dup2(int fd, std::error_code& ec) noexcept;
+
+  // Creates a buffered_file object associated with this file and detaches
+  // this file object from the file.
+  auto fdopen(const char* mode) -> buffered_file;
+
+#  if defined(_WIN32) && !defined(__MINGW32__)
+  // Opens a file and constructs a file object representing this file by
+  // wcstring_view filename. Windows only.
+  static file open_windows_file(wcstring_view path, int oflag);
+#  endif
+};
+
+struct FMT_API pipe {
+  file read_end;
+  file write_end;
+
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  pipe();
+};
+
+// Returns the memory page size.
+auto getpagesize() -> long;
+
+namespace detail {
+
+struct buffer_size {
+  constexpr buffer_size() = default;
+  size_t value = 0;
+  FMT_CONSTEXPR auto operator=(size_t val) const -> buffer_size {
+    auto bs = buffer_size();
+    bs.value = val;
+    return bs;
+  }
+};
+
+struct ostream_params {
+  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
+  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
+
+  constexpr ostream_params() {}
+
+  template <typename... T>
+  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
+    oflag = new_oflag;
+  }
+
+  template <typename... T>
+  ostream_params(T... params, detail::buffer_size bs)
+      : ostream_params(params...) {
+    this->buffer_size = bs.value;
+  }
+
+// Intel has a bug that results in failure to deduce a constructor
+// for empty parameter packs.
+#  if defined(__INTEL_COMPILER) && __INTEL_COMPILER < 2000
+  ostream_params(int new_oflag) : oflag(new_oflag) {}
+  ostream_params(detail::buffer_size bs) : buffer_size(bs.value) {}
+#  endif
+};
+
+}  // namespace detail
+
+FMT_INLINE_VARIABLE constexpr auto buffer_size = detail::buffer_size();
+
+/// A fast buffered output stream for writing from a single thread. Writing from
+/// multiple threads without external synchronization may result in a data race.
+class FMT_API ostream : private detail::buffer<char> {
+ private:
+  file file_;
+
+  ostream(cstring_view path, const detail::ostream_params& params);
+
+  static void grow(buffer<char>& buf, size_t);
+
+ public:
+  ostream(ostream&& other) noexcept;
+  ~ostream();
+
+  operator writer() {
+    detail::buffer<char>& buf = *this;
+    return buf;
+  }
+
+  inline void flush() {
+    if (size() == 0) return;
+    file_.write(data(), size() * sizeof(data()[0]));
+    clear();
+  }
+
+  template <typename... T>
+  friend auto output_file(cstring_view path, T... params) -> ostream;
+
+  inline void close() {
+    flush();
+    file_.close();
+  }
+
+  /// Formats `args` according to specifications in `fmt` and writes the
+  /// output to the file.
+  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
+    vformat_to(appender(*this), fmt.str, vargs<T...>{{args...}});
+  }
+};
+
+/**
+ * Opens a file for writing. Supported parameters passed in `params`:
+ *
+ * - `<integer>`: Flags passed to [open](
+ *   https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html)
+ *   (`file::WRONLY | file::CREATE | file::TRUNC` by default)
+ * - `buffer_size=<integer>`: Output buffer size
+ *
+ * **Example**:
+ *
+ *     auto out = fmt::output_file("guide.txt");
+ *     out.print("Don't {}", "Panic");
+ */
+template <typename... T>
+inline auto output_file(cstring_view path, T... params) -> ostream {
+  return {path, detail::ostream_params(params...)};
+}
+#endif  // FMT_USE_FCNTL
+
+FMT_END_EXPORT
+FMT_END_NAMESPACE
+
+#endif  // FMT_OS_H_

libfuse/include/fmt/ostream.h

@@ -0,0 +1,167 @@
+// Formatting library for C++ - std::ostream support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OSTREAM_H_
+#define FMT_OSTREAM_H_
+
+#ifndef FMT_MODULE
+#  include <fstream>  // std::filebuf
+#endif
+
+#ifdef _WIN32
+#  ifdef __GLIBCXX__
+#    include <ext/stdio_filebuf.h>
+#    include <ext/stdio_sync_filebuf.h>
+#  endif
+#  include <io.h>
+#endif
+
+#include "chrono.h"  // formatbuf
+
+#ifdef _MSVC_STL_UPDATE
+#  define FMT_MSVC_STL_UPDATE _MSVC_STL_UPDATE
+#elif defined(_MSC_VER) && _MSC_VER < 1912  // VS 15.5
+#  define FMT_MSVC_STL_UPDATE _MSVC_LANG
+#else
+#  define FMT_MSVC_STL_UPDATE 0
+#endif
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+// Generate a unique explicit instantion in every translation unit using a tag
+// type in an anonymous namespace.
+namespace {
+struct file_access_tag {};
+}  // namespace
+template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
+class file_access {
+  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
+};
+
+#if FMT_MSVC_STL_UPDATE
+template class file_access<file_access_tag, std::filebuf,
+                           &std::filebuf::_Myfile>;
+auto get_file(std::filebuf&) -> FILE*;
+#endif
+
+// Write the content of buf to os.
+// It is a separate function rather than a part of vprint to simplify testing.
+template <typename Char>
+void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
+  const Char* buf_data = buf.data();
+  using unsigned_streamsize = make_unsigned_t<std::streamsize>;
+  unsigned_streamsize size = buf.size();
+  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+  do {
+    unsigned_streamsize n = size <= max_size ? size : max_size;
+    os.write(buf_data, static_cast<std::streamsize>(n));
+    buf_data += n;
+    size -= n;
+  } while (size != 0);
+}
+
+template <typename T> struct streamed_view {
+  const T& value;
+};
+}  // namespace detail
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename Char>
+struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
+  void set_debug_format() = delete;
+
+  template <typename T, typename Context>
+  auto format(const T& value, Context& ctx) const -> decltype(ctx.out()) {
+    auto buffer = basic_memory_buffer<Char>();
+    auto&& formatbuf = detail::formatbuf<std::basic_streambuf<Char>>(buffer);
+    auto&& output = std::basic_ostream<Char>(&formatbuf);
+    output.imbue(std::locale::classic());  // The default is always unlocalized.
+    output << value;
+    output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+    return formatter<basic_string_view<Char>, Char>::format(
+        {buffer.data(), buffer.size()}, ctx);
+  }
+};
+
+using ostream_formatter = basic_ostream_formatter<char>;
+
+template <typename T, typename Char>
+struct formatter<detail::streamed_view<T>, Char>
+    : basic_ostream_formatter<Char> {
+  template <typename Context>
+  auto format(detail::streamed_view<T> view, Context& ctx) const
+      -> decltype(ctx.out()) {
+    return basic_ostream_formatter<Char>::format(view.value, ctx);
+  }
+};
+
+/**
+ * Returns a view that formats `value` via an ostream `operator<<`.
+ *
+ * **Example**:
+ *
+ *     fmt::print("Current thread id: {}\n",
+ *                fmt::streamed(std::this_thread::get_id()));
+ */
+template <typename T>
+constexpr auto streamed(const T& value) -> detail::streamed_view<T> {
+  return {value};
+}
+
+inline void vprint(std::ostream& os, string_view fmt, format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
+  FILE* f = nullptr;
+#if FMT_MSVC_STL_UPDATE && FMT_USE_RTTI
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    f = detail::get_file(*buf);
+#elif defined(_WIN32) && defined(__GLIBCXX__) && FMT_USE_RTTI
+  auto* rdbuf = os.rdbuf();
+  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    f = sfbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    f = fbuf->file();
+#endif
+#ifdef _WIN32
+  if (f) {
+    int fd = _fileno(f);
+    if (_isatty(fd)) {
+      os.flush();
+      if (detail::write_console(fd, {buffer.data(), buffer.size()})) return;
+    }
+  }
+#endif
+  detail::ignore_unused(f);
+  detail::write_buffer(os, buffer);
+}
+
+/**
+ * Prints formatted data to the stream `os`.
+ *
+ * **Example**:
+ *
+ *     fmt::print(cerr, "Don't {}!", "panic");
+ */
+FMT_EXPORT template <typename... T>
+void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  fmt::vargs<T...> vargs = {{args...}};
+  if (detail::const_check(detail::use_utf8)) return vprint(os, fmt.str, vargs);
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt.str, vargs);
+  detail::write_buffer(os, buffer);
+}
+
+FMT_EXPORT template <typename... T>
+void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  fmt::print(os, FMT_STRING("{}\n"),
+             fmt::format(fmt, std::forward<T>(args)...));
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_