Merge pull request #1321 from trapexit/allowmmap

Add support for 'direct-io-allow-mmap' if supported by kernel
2024-04-21 12:31:43 +00:00 · 2024-03-21 21:54:04 -04:00 · 2024-03-21 20:48:42 -05:00 · 2024-03-21 21:36:27 -04:00 · 2024-03-17 00:47:33 -05:00 · 2024-02-29 15:41:22 -05:00
490 changed files with 77878 additions and 17340 deletions
@@ -1,3 +1,13 @@
+freebsd_task:
+  name: "freebsd:11.4"
+  freebsd_instance:
+    image_family: freebsd-11-4
+  env:
+    ASSUME_ALWAYS_YES: yes
+  script:
+    - buildtools/install-build-pkgs
+    - gmake -j4
+
 freebsd_task:
  name: "freebsd:12.1"
  freebsd_instance:
@@ -5,14 +15,35 @@ freebsd_task:
  env:
    ASSUME_ALWAYS_YES: yes
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - gmake -j4

+freebsd_task:
+  name: "freebsd:12.2"
+  freebsd_instance:
+    image_family: freebsd-12-2
+  env:
+    ASSUME_ALWAYS_YES: yes
+  script:
+    - buildtools/install-build-pkgs
+    - gmake -j4
+
+freebsd_task:
+  name: "freebsd:13.0"
+  freebsd_instance:
+    image_family: freebsd-13-0
+  env:
+    ASSUME_ALWAYS_YES: yes
+  script:
+    - buildtools/install-build-pkgs
+    - gmake -j4
+
+
 #macos_task:
 #  osx_instance:
 #    image: catalina-base
 #  script:
-#    - tools/install-build-pkgs
+#    - buildtools/install-build-pkgs
 #    - gmake -j4

 linux_task:
@@ -20,45 +51,121 @@ linux_task:
  container:
    image: alpine:3.11
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - make STATIC=1 LTO=1

 linux_task:
-  name: "centos:6"
+  name: "alpine:3.12"
  container:
-    image: centos:6
+    image: alpine:3.12
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
-    - make
-    - make rpm
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.13"
+  container:
+    image: alpine:3.13
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.14"
+  container:
+    image: alpine:3.14
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.15"
+  container:
+    image: alpine:3.15
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.16"
+  container:
+    image: alpine:3.16
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+linux_task:
+  name: "alpine:3.17"
+  container:
+    image: alpine:3.17
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make STATIC=1 LTO=1
+
+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: "centos:7"
  container:
    image: centos:7
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - make
    - make rpm

 linux_task:
-  name: "centos:8"
+  name: "rocky:8"
  container:
-    image: centos:8
+    image: rocky:8
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - make
    - make rpm

@@ -67,10 +174,10 @@ linux_task:
  container:
    image: fedora:30
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - make
    - make rpm

@@ -79,10 +186,10 @@ linux_task:
  container:
    image: fedora:31
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - make
    - make rpm

@@ -91,10 +198,106 @@ linux_task:
  container:
    image: fedora:32
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:33"
+  container:
+    image: fedora:33
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:34"
+  container:
+    image: fedora:34
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:35"
+  container:
+    image: fedora:35
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:36"
+  container:
+    image: fedora:36
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:37"
+  container:
+    image: fedora:37
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:38"
+  container:
+    image: fedora:38
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora:latest"
+  container:
+    image: fedora:latest
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
+    - make
+    - make rpm
+
+linux_task:
+  name: "fedora-arm:latest"
+  arm_container:
+    image: fedora:latest
+    cpu: 4
+    memory: 4G
+  timeout_in: 15m
+  script:
+    - buildtools/install-build-pkgs
    - make
    - make rpm

@@ -103,10 +306,10 @@ linux_task:
  container:
    image: ubuntu:14.04
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -118,10 +321,10 @@ linux_task:
  container:
    image: ubuntu:16.04
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -133,25 +336,10 @@ linux_task:
  container:
    image: ubuntu:18.04
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
-    - git fetch
-    - make deb
-    - apt-get -y install fuse
-    - dpkg -i ../*.deb
-    - mergerfs -v || true
-
-linux_task:
-  name: "ubuntu:19.10"
-  container:
-    image: ubuntu:19.10
-    cpu: 4
-    memory: 2G
-  timeout_in: 10m
-  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -163,10 +351,55 @@ linux_task:
  container:
    image: ubuntu:20.04
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+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: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
@@ -178,10 +411,10 @@ linux_task:
  container:
    image: debian:8
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -193,10 +426,10 @@ linux_task:
  container:
    image: debian:8
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -208,10 +441,10 @@ linux_task:
  container:
    image: debian:9
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
    - git fetch
    - make deb
    - apt-get -y install fuse
@@ -223,10 +456,70 @@ linux_task:
  container:
    image: debian:10
    cpu: 4
-    memory: 2G
-  timeout_in: 10m
+    memory: 4G
+  timeout_in: 15m
  script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
+    - git fetch
+    - make deb
+    - apt-get -y install fuse
+    - dpkg -i ../*.deb
+    - mergerfs -v || true
+
+linux_task:
+  name: "debian:11"
+  container:
+    image: debian:11
+    cpu: 4
+    memory: 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
@@ -2,6 +2,6 @@

 github: [trapexit]
 patreon: trapexit
-open_collective: trapexit
+custom: ['https://paypal.me/trapexit','https://buymeacoff.ee/trapexit']
 ko_fi: trapexit
-custom: ['https://paypal.me/trapexit','https://www.subscribestar.com/trapexit']
+open_collective: trapexit
@@ -8,27 +8,42 @@ assignees: ''
 ---

 **Describe the bug**
-A clear and concise description of what the bug is. Please do not file bugs for unreleased versions unless you're a tester or sure it's not a work in progress. The master branch is **not** to be considered in a production state.
+
+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. 
+Please simplify the reproduction as much as possible.
 - Unless it is dependenat on multiple branches, use a single branch
- - Use basic tooling if possible (touch,truncate,rm,rmdir,ln,etc.)
+ - 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 what you expected to happen.
+
+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`
- - A strace of the application having a problem: `strace -f -o /tmp/app.strace.txt <cmd>` or `strace -f -p <appPID> -o /tmp/app.strace.txt`
- - strace of mergerfs while app tried to do it's thing: `strace -f -p <mergerfsPID> -o /tmp/mergerfs.strace.txt`
+ - 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.
@@ -1,10 +1,10 @@
 ---
 name: Question
-about: When you're looking for information
+about: When you're looking for information or general support
 title: ''
 labels: investigating, question
 assignees: ''

 ---

-You can also ask questions on Discord for realtime help: https://discord.gg/MpAr69V
+For general questions and support please use [GitHub Discussions](https://github.com/trapexit/mergerfs/discussions) or [Discord](https://discord.gg/MpAr69V).
@@ -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 }}"
@@ -1,44 +0,0 @@
-language: cpp
-
-matrix:
-  include:
-    - os: linux
-      dist: precise
-      compiler: gcc
-      sudo: required
-    - os: linux
-      dist: precise
-      compiler: clang
-      sudo: required
-    - os: linux
-      dist: trusty
-      compiler: gcc
-      sudo: required
-    - os: linux
-      dist: trusty
-      compiler: clang
-      sudo: required
-    - os: linux
-      dist: xenial
-      compiler: gcc
-      sudo: required
-    - os: linux
-      dist: xenial
-      compiler: clang
-      sudo: required
-    - os: linux
-      dist: bionic
-      compiler: gcc
-      sudo: required
-    - os: linux
-      dist: bionic
-      compiler: clang
-      sudo: required
-
-script:
-  - sudo -E apt-get install fakeroot
-  - sudo -E make install-build-pkgs
-  - make -j$(($(nproc) + 1))
-  - make deb
-  - sudo -E dpkg -i ../*.deb
-  - mergerfs -v || true
@@ -0,0 +1,11 @@
+## Libraries
+
+### included in repo
+
+* libfuse: https://github.com/libfuse/libfuse (heavily modified fork of v2.x)
+* wyhash: https://github.com/wangyi-fudan/wyhash
+* ghc::filesystem: https://github.com/gulrak/filesystem
+* nonstd::optional: https://github.com/martinmoene/optional-lite
+* fmt: https://github.com/fmtlib/fmt
+* concurrentqueue: https://github.com/cameron314/concurrentqueue
+* scope_guard: https://github.com/Neargye/scope_guard
@@ -1,7 +1,7 @@
 /*
  ISC License

-  Copyright (c) 2020, 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
@@ -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
@@ -26,7 +26,7 @@ STRIP     = strip
 PANDOC    = pandoc
 SED       = sed
 RPMBUILD  = rpmbuild
-GIT2DEBCL = ./tools/git2debcl
+GIT2DEBCL = ./buildtools/git2debcl
 PKGCONFIG = pkg-config

 GIT_REPO = 0
@@ -40,9 +40,9 @@ USE_XATTR = 1
 UGID_USE_RWLOCK = 0

 ifeq ($(DEBUG),1)
-OPT_FLAGS := -O0 -g
+OPT_FLAGS := -O0 -g -fsanitize=undefined
 else
-OPT_FLAGS := -O2
+OPT_FLAGS := -O2 -DNDEBUG
 endif

 ifeq ($(STATIC),1)
@@ -58,13 +58,24 @@ LTO_FLAGS :=
 endif

 SRC	    = $(wildcard src/*.cpp)
-OBJS        = $(SRC:src/%.cpp=build/%.o)
-DEPS        = $(SRC:src/%.cpp=build/%.d)
+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++0x \
+              -std=c++11 \
              $(STATIC_FLAGS) \
              $(LTO_FLAGS) \
              -Wall \
@@ -72,17 +83,20 @@ CXXFLAGS    := \
              -MMD
 FUSE_FLAGS = \
              -Ilibfuse/include \
-              -D_FILE_OFFSET_BITS=64 \
-              -DFUSE_USE_VERSION=29
+              -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

+# https://www.gnu.org/prep/standards/html_node/Directory-Variables.html
 DESTDIR       =
 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
@@ -90,11 +104,13 @@ 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)

 .PHONY: all
@@ -110,11 +126,19 @@ help:
 objects: version build/stamp
 	$(MAKE) $(OBJS)

+tests-objects:
+	$(MAKE) $(TESTS_OBJS)
+
 build/mergerfs: libfuse objects
 	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)

+build/tests: build/mergerfs tests-objects
+	$(CXX) $(CXXFLAGS) $(TESTS_FLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(TESTS_OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)
+
 mergerfs: build/mergerfs

+tests: build/tests
+
 changelog:
 ifeq ($(GIT_REPO),1)
 	$(GIT2DEBCL) --name mergerfs > ChangeLog
@@ -124,15 +148,23 @@ endif

 .PHONY: version
 version:
-	tools/update-version
+	./buildtools/update-version

 build/stamp:
-	$(MKDIR) -p build
+	$(MKDIR) -p build/.src build/.tests
 	$(TOUCH) $@

-build/%.o: src/%.cpp
+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 build
@@ -145,7 +177,7 @@ ifeq ($(GIT_REPO),1)
 endif

 .PHONY: install
-install: install-base install-mount-tools install-man
+install: install-base install-mount-tools install-preload install-man

 install-base: build/mergerfs
 	$(MKDIR) -p "$(INSTALLBINDIR)"
@@ -159,6 +191,10 @@ install-man: $(MANPAGE)
 	$(MKDIR) -p "$(INSTALLMAN1DIR)"
 	$(INSTALL) -v -m 0644 "man/$(MANPAGE)" "$(INSTALLMAN1DIR)/$(MANPAGE)"

+install-preload: preload
+	$(MKDIR) -p "$(INSTALLLIBDIR)"
+	$(INSTALL) -v -m 444 "build/preload.so" "$(INSTALLLIBDIR)/preload.so"
+
 install-strip: install-base
 	$(STRIP) "$(INSTALLBINDIR)/mergerfs"

@@ -204,13 +240,13 @@ endif
 signed-deb:
 	$(MAKE) distclean
 	$(MAKE) debian-changelog
-	dpkg-source -b .
+#	dpkg-source -b .
 	dpkg-buildpackage -nc

 deb:
 	$(MAKE) distclean
 	$(MAKE) debian-changelog
-	dpkg-source -b .
+#	dpkg-source -b .
 	dpkg-buildpackage -nc -uc -us

 .PHONY: rpm-clean
@@ -229,7 +265,7 @@ rpm: tarball

 .PHONY: install-build-pkgs
 install-build-pkgs:
-	tools/install-build-pkgs
+	./buildtools/install-build-pkgs

 .PHONY: libfuse
 libfuse:
@@ -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    
@@ -3,7 +3,7 @@
 if [ -e /usr/bin/apt-get ]; then
    export DEBIAN_FRONTEND=noninteractive
    apt-get -qy update
-    apt-get -qy --no-install-suggests --no-install-recommends \
+    apt-get -qy --force-yes --no-install-suggests --no-install-recommends \
 	    install \
            ca-certificates \
            build-essential \
@@ -10,11 +10,17 @@ INSTALLUTILS :=
 endif

 ifeq ($(DEBUG),1)
-OPT_FLAGS := -O0 -g
+OPT_FLAGS := -O0 -g -fsanitize=undefined
 else
 OPT_FLAGS := -O2
 endif

+ifeq ($(LTO),1)
+LTO_FLAGS := -flto
+else
+LTO_FLAGS :=
+endif
+
 DESTDIR       =
 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
@@ -31,25 +37,44 @@ INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)

 AR ?= ar

-SRC   = \
+SRC_C = \
 	lib/buffer.c \
-	lib/fuse_dirents.c \
+	lib/crc32b.c \
+	lib/debug.c \
 	lib/fuse.c \
-	lib/fuse_kern_chan.c \
-	lib/fuse_loop_mt.c \
+	lib/fuse_dirents.c \
 	lib/fuse_lowlevel.c \
-	lib/fuse_mt.c \
+	lib/node.c \
+	lib/fuse_node.c \
 	lib/fuse_opt.c \
 	lib/fuse_session.c \
 	lib/fuse_signals.c \
 	lib/helper.c \
 	lib/mount.c
-OBJS = $(SRC:lib/%.c=build/%.o)
-DEPS = $(SRC:lib/%.c=build/%.d)
+SRC_CPP = \
+	lib/format.cpp \
+	lib/os.cpp \
+	lib/cpu.cpp \
+	lib/fuse_config.cpp \
+	lib/fuse_loop.cpp \
+	lib/fuse_msgbuf.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} \
+	${CFLAGS} \
+	$(LTO_FLAGS) \
+	-std=gnu99 \
+	-Wall \
+	-pipe \
+	-MMD
+CXXFLAGS := \
+	${CXXFLAGS} \
+	$(LTO_FLAGS) \
+	-std=c++11 \
 	-Wall \
 	-pipe \
 	-MMD
@@ -59,7 +84,6 @@ FUSE_FLAGS = \
 	-Ibuild \
 	-D_REENTRANT \
 	-D_FILE_OFFSET_BITS=64 \
-	-DFUSE_USE_VERSION=29 \
 	-DPACKAGE_VERSION=\"$(VERSION)\" \
 	-DFUSERMOUNT_DIR=\"$(FUSERMOUNT_DIR)\"
 LDFLAGS := \
@@ -77,10 +101,10 @@ build/stamp:
 	touch $@

 objects: build/config.h
-	$(MAKE) $(OBJS)
+	$(MAKE) $(OBJS_C) $(OBJS_CPP)

 build/libfuse.a: objects
-	${AR} rcs build/libfuse.a $(OBJS)
+	${AR} rcs build/libfuse.a $(OBJS_C) $(OBJS_CPP)

 utils: mergerfs-fusermount mount.mergerfs

@@ -97,6 +121,9 @@ 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

@@ -116,4 +143,4 @@ install: $(INSTALLUTILS)

 .PHONY: objects strip utils install install-utils

-include $(DEPS)
+-include $(DEPS_C) $(DEPS_CPP)
@@ -0,0 +1,7 @@
+#include <malloc.h>
+
+int
+main()
+{
+  malloc_trim(0);
+}
@@ -1,11 +0,0 @@
-#define _GNU_SOURCE
-#include <fcntl.h>
-
-int
-main(int   argc,
-     char *argv[])
-{
-  (void)splice;
-
-  return 0;
-}
@@ -1,12 +0,0 @@
-#define _GNU_SOURCE
-#include <fcntl.h>
-#include <sys/uio.h>
-
-int
-main(int   argc,
-     char *argv[])
-{
-  (void)vmsplice;
-
-  return 0;
-}
@@ -9,23 +9,8 @@
 #ifndef _FUSE_H_
 #define _FUSE_H_

-/** @file
- *
- * This file defines the library interface of FUSE
- *
- * IMPORTANT: you should define FUSE_USE_VERSION before including this
- * header.  To use the newest API define it to 26 (recommended for any
- * new application), to use the old API define it to 21 (default) 22
- * or 25, to use the even older 1.X API define it to 11.
- */
-
-#ifndef FUSE_USE_VERSION
-#define FUSE_USE_VERSION 21
-#endif
-
 #include "extern_c.h"
 #include "fuse_common.h"
-#include "fuse_dirents.h"

 #include <fcntl.h>
 #include <time.h>
@@ -47,6 +32,9 @@ struct fuse;
 /** Structure containing a raw command */
 struct fuse_cmd;

+struct fuse_dirents_t;
+typedef struct fuse_dirents_t fuse_dirents_t;
+
 /**
 * The file system operations:
 *
@@ -121,31 +109,25 @@ struct fuse_operations
  int (*rmdir) (const char *);

  /** Create a symbolic link */
-  int (*symlink) (const char *, const char *);
+  int (*symlink) (const char *, const char *, struct stat *, fuse_timeouts_t *);

  /** Rename a file */
  int (*rename) (const char *, const char *);

  /** Create a hard link to a file */
-  int (*link) (const char *, const char *);
+  int (*link) (const char *, const char *, struct stat *, fuse_timeouts_t *);

  /** Change the permission bits of a file */
  int (*chmod) (const char *, mode_t);
-  int (*fchmod)(const struct fuse_file_info *, const mode_t);
+  int (*fchmod)(const fuse_file_info_t *, const mode_t);

  /** Change the owner and group of a file */
  int (*chown) (const char *, uid_t, gid_t);
-  int (*fchown)(const struct fuse_file_info *, const uid_t, const gid_t);
+  int (*fchown)(const fuse_file_info_t *, const uid_t, const gid_t);

  /** Change the size of a file */
  int (*truncate) (const char *, off_t);

-  /** Change the access and/or modification times of a file
-   *
-   * Deprecated, use utimens() instead.
-   */
-  int (*utime) (const char *, struct utimbuf *);
-
  /** File open operation
   *
   * No creation (O_CREAT, O_EXCL) and by default also no
@@ -163,32 +145,7 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*open) (const char *, struct fuse_file_info *);
-
-  /** Read data from an open file
-   *
-   * Read should return exactly the number of bytes requested except
-   * on EOF or error, otherwise the rest of the data will be
-   * substituted with zeroes.	 An exception to this is when the
-   * 'direct_io' mount option is specified, in which case the return
-   * value of the read system call will reflect the return value of
-   * this operation.
-   *
-   * Changed in version 2.2
-   */
-  int (*read) (char *, size_t, off_t,
-               struct fuse_file_info *);
-
-  /** Write data to an open file
-   *
-   * Write should return exactly the number of bytes requested
-   * except on error.	 An exception to this is when the 'direct_io'
-   * mount option is specified (see read operation).
-   *
-   * Changed in version 2.2
-   */
-  int (*write) (const char *, size_t, off_t,
-                struct fuse_file_info *);
+  int (*open) (const char *, fuse_file_info_t *);

  /** Get file system statistics
   *
@@ -222,7 +179,7 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*flush) (struct fuse_file_info *);
+  int (*flush) (const fuse_file_info_t *);

  /** Release an open file
   *
@@ -238,7 +195,7 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*release) (struct fuse_file_info *);
+  int (*release) (const fuse_file_info_t *);

  /** Synchronize file contents
   *
@@ -247,7 +204,7 @@ struct fuse_operations
   *
   * Changed in version 2.2
   */
-  int (*fsync) (int, struct fuse_file_info *);
+  int (*fsync) (const fuse_file_info_t *, int);

  /** Set extended attributes */
  int (*setxattr) (const char *, const char *, const char *, size_t, int);
@@ -271,7 +228,8 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*opendir) (const char *, struct fuse_file_info *);
+  int (*opendir) (const char *,
+                  fuse_file_info_t *);

  /** Read directory
   *
@@ -294,10 +252,10 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*readdir)(struct fuse_file_info *,
+  int (*readdir)(const fuse_file_info_t *,
                 fuse_dirents_t *);

-  int (*readdir_plus)(struct fuse_file_info *,
+  int (*readdir_plus)(const fuse_file_info_t *,
                      fuse_dirents_t *);


@@ -305,7 +263,7 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*releasedir) (struct fuse_file_info *);
+  int (*releasedir) (const fuse_file_info_t *);

  /** Synchronize directory contents
   *
@@ -314,7 +272,7 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  int (*fsyncdir) (int, struct fuse_file_info *);
+  int (*fsyncdir) (const fuse_file_info_t *, int);

  /**
   * Initialize filesystem
@@ -335,7 +293,7 @@ struct fuse_operations
   *
   * Introduced in version 2.3
   */
-  void (*destroy) (void *);
+  void (*destroy) (void);

  /**
   * Check file access permissions
@@ -362,7 +320,7 @@ struct fuse_operations
   *
   * Introduced in version 2.5
   */
-  int (*create) (const char *, mode_t, struct fuse_file_info *);
+  int (*create) (const char *, mode_t, fuse_file_info_t *);

  /**
   * Change the size of an open file
@@ -376,7 +334,7 @@ struct fuse_operations
   *
   * Introduced in version 2.5
   */
-  int (*ftruncate) (off_t, struct fuse_file_info *);
+  int (*ftruncate) (const fuse_file_info_t *, off_t);

  /**
   * Get attributes from an open file
@@ -390,7 +348,7 @@ struct fuse_operations
   *
   * Introduced in version 2.5
   */
-  int (*fgetattr) (struct stat *, struct fuse_file_info *, fuse_timeouts_t *);
+  int (*fgetattr) (const fuse_file_info_t *, struct stat *, fuse_timeouts_t *);

  /**
   * Perform POSIX file locking operation
@@ -424,7 +382,8 @@ struct fuse_operations
   *
   * Introduced in version 2.6
   */
-  int (*lock) (struct fuse_file_info *, int cmd,
+  int (*lock) (const fuse_file_info_t *,
+               int cmd,
               struct flock *);

  /**
@@ -439,7 +398,7 @@ struct fuse_operations
   * Introduced in version 2.6
   */
  int (*utimens)(const char *, const struct timespec tv[2]);
-  int (*futimens)(const struct fuse_file_info *ffi_, const struct timespec tv_[2]);
+  int (*futimens)(const fuse_file_info_t *ffi_, const struct timespec tv_[2]);

  /**
   * Map block index within file to block index within device
@@ -466,12 +425,12 @@ struct fuse_operations
   *
   * Introduced in version 2.8
   */
-  int (*ioctl) (unsigned long cmd,
-                void *arg,
-                struct fuse_file_info *ffi,
-                unsigned int flags,
-                void *data,
-                uint32_t *out_bufsz);
+  int (*ioctl) (const fuse_file_info_t *ffi,
+                unsigned long           cmd,
+                void                   *arg,
+                unsigned int            flags,
+                void                   *data,
+                uint32_t               *out_bufsz);

  /**
   * Poll for IO readiness events
@@ -490,8 +449,9 @@ struct fuse_operations
   *
   * Introduced in version 2.8
   */
-  int (*poll) (struct fuse_file_info *,
-               struct fuse_pollhandle *ph, unsigned *reventsp);
+  int (*poll) (const fuse_file_info_t *ffi,
+               fuse_pollhandle_t      *ph,
+               unsigned               *reventsp);

  /** Write contents of buffer to an open file
   *
@@ -501,8 +461,10 @@ struct fuse_operations
   *
   * Introduced in version 2.9
   */
-  int (*write_buf) (struct fuse_bufvec *buf, off_t off,
-                    struct fuse_file_info *);
+  int (*write) (const fuse_file_info_t *ffi,
+                const char             *data,
+                size_t                  size,
+                off_t                   off);

  /** Store data from an open file in a buffer
   *
@@ -520,8 +482,10 @@ struct fuse_operations
   *
   * Introduced in version 2.9
   */
-  int (*read_buf) (struct fuse_bufvec **bufp,
-                   size_t size, off_t off, struct fuse_file_info *);
+  int (*read)(const fuse_file_info_t *ffi,
+              char                   *buf,
+              size_t                  size,
+              off_t                   off);
  /**
   * Perform BSD file locking operation
   *
@@ -542,7 +506,7 @@ struct fuse_operations
   *
   * Introduced in version 2.9
   */
-  int (*flock) (struct fuse_file_info *, int op);
+  int (*flock) (const fuse_file_info_t *, int op);

  /**
   * Allocates space for an open file
@@ -554,7 +518,7 @@ struct fuse_operations
   *
   * Introduced in version 2.9.1
   */
-  int (*fallocate) (int, off_t, off_t,struct fuse_file_info *);
+  int (*fallocate) (const fuse_file_info_t *, int, off_t, off_t);

  /**
   * Copy a range of data from one file to another
@@ -569,12 +533,22 @@ struct fuse_operations
   * destination. Effectively doing an inefficient copy of the
   * data.
   */
-  ssize_t (*copy_file_range)(struct fuse_file_info *fi_in,
-                             off_t                  offset_in,
-                             struct fuse_file_info *fi_out,
-                             off_t                  offset_out,
-                             size_t                 size,
-                             int                    flags);
+  ssize_t (*copy_file_range)(const fuse_file_info_t *fi_in,
+                             off_t                   offset_in,
+                             const fuse_file_info_t *fi_out,
+                             off_t                   offset_out,
+                             size_t                  size,
+                             int                     flags);
+
+  ssize_t (*setupmapping)(uint64_t *fh_,
+                          uint64_t  foffset_,
+                          uint64_t  len_,
+                          uint64_t  flags_,
+                          uint64_t  moffset_);
+
+  int (*removemapping)();
+  int (*syncfs)();
+  int (*tmpfile)(const char *, mode_t, fuse_file_info_t *);
 };

 /** Extra context that may be needed by some filesystems
@@ -596,9 +570,6 @@ struct fuse_context
  /** Thread ID of the calling process */
  pid_t pid;

-  /** Private filesystem data */
-  void *private_data;
-
  /** Umask of the calling process (introduced in version 2.8) */
  mode_t umask;
 };
@@ -623,15 +594,13 @@ struct fuse_context
 * @param argc the argument counter passed to the main() function
 * @param argv the argument vector passed to the main() function
 * @param op the file system operation
- * @param user_data user data supplied in the context during the init() method
 * @return 0 on success, nonzero on failure
 */
 /*
-  int fuse_main(int argc, char *argv[], const struct fuse_operations *op,
-  void *user_data);
+  int fuse_main(int argc, char *argv[], const struct fuse_operations *op);
 */
-#define fuse_main(argc, argv, op, user_data)                    \
-  fuse_main_real(argc, argv, op, sizeof(*(op)), user_data)
+#define fuse_main(argc, argv, op)                    \
+  fuse_main_real(argc, argv, op, sizeof(*(op)))

 /* ----------------------------------------------------------- *
 * More detailed API					       *
@@ -644,12 +613,10 @@ struct fuse_context
 * @param args argument vector
 * @param op the filesystem operations
 * @param op_size the size of the fuse_operations structure
- * @param user_data user data supplied in the context during the init() method
 * @return the created FUSE handle
 */
 struct fuse *fuse_new(struct fuse_chan *ch, struct fuse_args *args,
-                      const struct fuse_operations *op, size_t op_size,
-                      void *user_data);
+                      const struct fuse_operations *op, size_t op_size);

 /**
 * Destroy the FUSE handle.
@@ -670,7 +637,10 @@ void fuse_destroy(struct fuse *f);
 */
 void fuse_exit(struct fuse *f);

-int fuse_config_num_threads(const struct fuse *fuse_);
+int fuse_config_read_thread_count(const struct fuse *f);
+int fuse_config_process_thread_count(const struct fuse *f);
+int fuse_config_process_thread_queue_depth(const struct fuse *f);
+const char* fuse_config_pin_threads(const struct fuse *f);

 /**
 * FUSE event loop with multiple threads
@@ -719,25 +689,14 @@ int fuse_is_lib_option(const char *opt);
 *
 * Do not call this directly, use fuse_main()
 */
-int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
-                   size_t op_size, void *user_data);
+int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op, size_t op_size);

-/**
- * Start the cleanup thread when using option "remember".
- *
- * This is done automatically by fuse_loop_mt()
- * @param fuse struct fuse pointer for fuse instance
- * @return 0 on success and -1 on error
- */
-int fuse_start_cleanup_thread(struct fuse *fuse);
+int  fuse_start_maintenance_thread(struct fuse *fuse);
+void fuse_stop_maintenance_thread(struct fuse *fuse);
+
+int  fuse_log_metrics_get(void);
+void fuse_log_metrics_set(int enabled);

-/**
- * Stop the cleanup thread when using option "remember".
- *
- * This is done automatically by fuse_loop_mt()
- * @param fuse struct fuse pointer for fuse instance
- */
-void fuse_stop_cleanup_thread(struct fuse *fuse);

 /**
 * Iterate over cache removing stale entries
@@ -770,99 +729,7 @@ struct fuse_fs;
 * fuse_fs_releasedir and fuse_fs_statfs, which return 0.
 */

-int fuse_fs_getattr(struct fuse_fs  *fs,
-                    const char      *path,
-                    struct stat     *buf,
-                    fuse_timeouts_t *timeout);
-
-int fuse_fs_fgetattr(struct fuse_fs        *fs,
-                     struct stat           *buf,
-                     struct fuse_file_info *fi,
-                     fuse_timeouts_t       *timeout);
-
-int fuse_fs_rename(struct fuse_fs *fs, const char *oldpath,
-                   const char *newpath);
-int fuse_fs_unlink(struct fuse_fs *fs, const char *path);
-int fuse_fs_rmdir(struct fuse_fs *fs, const char *path);
-int fuse_fs_symlink(struct fuse_fs *fs, const char *linkname,
-                    const char *path);
-int fuse_fs_link(struct fuse_fs *fs, const char *oldpath, const char *newpath);
-int fuse_fs_release(struct fuse_fs *fs,
-                    struct fuse_file_info *fi);
-int fuse_fs_open(struct fuse_fs *fs, const char *path,
-                 struct fuse_file_info *fi);
-int fuse_fs_read(struct fuse_fs *fs, char *buf, size_t size,
-                 off_t off, struct fuse_file_info *fi);
-int fuse_fs_read_buf(struct fuse_fs *fs,
-                     struct fuse_bufvec **bufp, size_t size, off_t off,
-                     struct fuse_file_info *fi);
-int fuse_fs_write(struct fuse_fs *fs, const char *buf,
-                  size_t size, off_t off, struct fuse_file_info *fi);
-int fuse_fs_write_buf(struct fuse_fs *fs,
-                      struct fuse_bufvec *buf, off_t off,
-                      struct fuse_file_info *fi);
-int fuse_fs_fsync(struct fuse_fs *fs, int datasync,
-                  struct fuse_file_info *fi);
-int fuse_fs_flush(struct fuse_fs *fs,
-                  struct fuse_file_info *fi);
-int fuse_fs_statfs(struct fuse_fs *fs, const char *path, struct statvfs *buf);
-int fuse_fs_opendir(struct fuse_fs *fs, const char *path,
-                    struct fuse_file_info *fi);
-int fuse_fs_readdir(struct fuse_fs        *fs,
-                    struct fuse_file_info *fi,
-                    fuse_dirents_t        *buf);
-int fuse_fs_fsyncdir(struct fuse_fs *fs, int datasync,
-                     struct fuse_file_info *fi);
-int fuse_fs_releasedir(struct fuse_fs *fs,
-                       struct fuse_file_info *fi);
-int fuse_fs_create(struct fuse_fs *fs, const char *path, mode_t mode,
-                   struct fuse_file_info *fi);
-int fuse_fs_lock(struct fuse_fs *fs,
-                 struct fuse_file_info *fi, int cmd, struct flock *lock);
-int fuse_fs_flock(struct fuse_fs *fs,
-                  struct fuse_file_info *fi, int op);
-int fuse_fs_chmod(struct fuse_fs *fs, const char *path, mode_t mode);
-int fuse_fs_chown(struct fuse_fs *fs, const char *path, uid_t uid, gid_t gid);
-int fuse_fs_truncate(struct fuse_fs *fs, const char *path, off_t size);
-int fuse_fs_ftruncate(struct fuse_fs *fs, off_t size,
-                      struct fuse_file_info *fi);
-int fuse_fs_utimens(struct fuse_fs *fs, const char *path,
-                    const struct timespec tv[2]);
-int fuse_fs_access(struct fuse_fs *fs, const char *path, int mask);
-int fuse_fs_readlink(struct fuse_fs *fs, const char *path, char *buf,
-                     size_t len);
-int fuse_fs_mknod(struct fuse_fs *fs, const char *path, mode_t mode,
-                  dev_t rdev);
-int fuse_fs_mkdir(struct fuse_fs *fs, const char *path, mode_t mode);
-int fuse_fs_setxattr(struct fuse_fs *fs, const char *path, const char *name,
-                     const char *value, size_t size, int flags);
-int fuse_fs_getxattr(struct fuse_fs *fs, const char *path, const char *name,
-                     char *value, size_t size);
-int fuse_fs_listxattr(struct fuse_fs *fs, const char *path, char *list,
-                      size_t size);
-int fuse_fs_removexattr(struct fuse_fs *fs, const char *path,
-                        const char *name);
-int fuse_fs_bmap(struct fuse_fs *fs, const char *path, size_t blocksize,
-                 uint64_t *idx);
-int fuse_fs_ioctl(struct fuse_fs *fs, unsigned long cmd, void *arg,
-                  struct fuse_file_info *fi, unsigned int flags,
-                  void *data, uint32_t *out_bufsz);
-int fuse_fs_poll(struct fuse_fs *fs,
-                 struct fuse_file_info *fi, struct fuse_pollhandle *ph,
-                 unsigned *reventsp);
-int fuse_fs_fallocate(struct fuse_fs *fs, int mode,
-                      off_t offset, off_t length, struct fuse_file_info *fi);
-void fuse_fs_init(struct fuse_fs *fs, struct fuse_conn_info *conn);
-void fuse_fs_destroy(struct fuse_fs *fs);
-
-int fuse_fs_prepare_hide(struct fuse_fs *fs, const char *path, uint64_t *fh);
-int fuse_fs_free_hide(struct fuse_fs *fs, uint64_t fh);
-ssize_t fuse_fs_copy_file_range(struct fuse_fs *fs,
-                                struct fuse_file_info *fi_in, off_t off_in,
-                                struct fuse_file_info *fi_out, off_t off_out,
-                                size_t len, int flags);
-
-int fuse_notify_poll(struct fuse_pollhandle *ph);
+int fuse_notify_poll(fuse_pollhandle_t *ph);

 /**
 * Create a new fuse filesystem object
@@ -872,11 +739,9 @@ int fuse_notify_poll(struct fuse_pollhandle *ph);
 *
 * @param op the filesystem operations
 * @param op_size the size of the fuse_operations structure
- * @param user_data user data supplied in the context during the init() method
 * @return a new filesystem object
 */
-struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size,
-                            void *user_data);
+struct fuse_fs *fuse_fs_new(const struct fuse_operations *op, size_t op_size);

 /* ----------------------------------------------------------- *
 * Advanced API for event handling, don't worry about this...  *
@@ -891,18 +756,11 @@ typedef void (*fuse_processor_t)(struct fuse *, struct fuse_cmd *, void *);
 /** This is the part of fuse_main() before the event loop */
 struct fuse *fuse_setup(int argc, char *argv[],
                        const struct fuse_operations *op, size_t op_size,
-                        char **mountpoint,
-                        void *user_data);
+                        char **mountpoint);

 /** This is the part of fuse_main() after the event loop */
 void fuse_teardown(struct fuse *fuse, char *mountpoint);

-/** Read a single command.  If none are read, return NULL */
-struct fuse_cmd *fuse_read_cmd(struct fuse *f);
-
-/** Process a single command */
-void fuse_process_cmd(struct fuse *f, struct fuse_cmd *cmd);
-
 /** Multi threaded event loop, which calls the custom command
    processor function */
 int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data);
@@ -917,6 +775,10 @@ void fuse_set_getcontext_func(struct fuse_context *(*func)(void));
 /** Get session from fuse object */
 struct fuse_session *fuse_get_session(struct fuse *f);

+void fuse_gc1();
+void fuse_gc();
+void fuse_invalidate_all_nodes();
+
 EXTERN_C_END

 #endif /* _FUSE_H_ */
@@ -46,8 +46,8 @@ EXTERN_C_BEGIN
 *
 * Changed in version 2.5
 */
-struct
-fuse_file_info
+typedef struct fuse_file_info_t fuse_file_info_t;
+struct fuse_file_info_t
 {
  /** Open flags. Available in open() and release() */
  int flags;
@@ -84,6 +84,10 @@ fuse_file_info

  uint32_t auto_cache : 1;

+  uint32_t parallel_direct_writes:1;
+
+  uint32_t noflush:1;
+
  /** File handle.  May be filled in by filesystem in open().
      Available in all other file operations */
  uint64_t fh;
@@ -101,31 +105,29 @@ fuse_file_info
 * FUSE_CAP_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
 * FUSE_CAP_BIG_WRITES: filesystem can handle write size larger than 4kB
 * FUSE_CAP_DONT_MASK: don't apply umask to file mode on create operations
- * FUSE_CAP_SPLICE_WRITE: ability to use splice() to write to the fuse device
- * FUSE_CAP_SPLICE_MOVE: ability to move data to the fuse device with splice()
- * FUSE_CAP_SPLICE_READ: ability to use splice() to read from the fuse device
 * FUSE_CAP_IOCTL_DIR: ioctl support on directories
 * FUSE_CAP_CACHE_SYMLINKS: cache READLINK responses
 */
-#define FUSE_CAP_ASYNC_READ        (1 << 0)
-#define FUSE_CAP_POSIX_LOCKS       (1 << 1)
-#define FUSE_CAP_ATOMIC_O_TRUNC    (1 << 3)
-#define FUSE_CAP_EXPORT_SUPPORT    (1 << 4)
-#define FUSE_CAP_BIG_WRITES        (1 << 5)
-#define FUSE_CAP_DONT_MASK         (1 << 6)
-#define FUSE_CAP_SPLICE_WRITE      (1 << 7)
-#define FUSE_CAP_SPLICE_MOVE       (1 << 8)
-#define FUSE_CAP_SPLICE_READ       (1 << 9)
-#define FUSE_CAP_FLOCK_LOCKS       (1 << 10)
-#define FUSE_CAP_IOCTL_DIR         (1 << 11)
-#define FUSE_CAP_READDIR_PLUS      (1 << 13)
-#define FUSE_CAP_READDIR_PLUS_AUTO (1 << 14)
-#define FUSE_CAP_ASYNC_DIO         (1 << 15)
-#define FUSE_CAP_WRITEBACK_CACHE   (1 << 16)
-#define FUSE_CAP_PARALLEL_DIROPS   (1 << 18)
-#define FUSE_CAP_POSIX_ACL         (1 << 19)
-#define FUSE_CAP_CACHE_SYMLINKS    (1 << 20)
-#define FUSE_CAP_MAX_PAGES         (1 << 21)
+#define FUSE_CAP_ASYNC_READ           (1ULL << 0)
+#define FUSE_CAP_POSIX_LOCKS          (1ULL << 1)
+#define FUSE_CAP_ATOMIC_O_TRUNC       (1ULL << 3)
+#define FUSE_CAP_EXPORT_SUPPORT       (1ULL << 4)
+#define FUSE_CAP_BIG_WRITES           (1ULL << 5)
+#define FUSE_CAP_DONT_MASK            (1ULL << 6)
+#define FUSE_CAP_FLOCK_LOCKS          (1ULL << 10)
+#define FUSE_CAP_IOCTL_DIR            (1ULL << 11)
+#define FUSE_CAP_READDIR_PLUS         (1ULL << 13)
+#define FUSE_CAP_READDIR_PLUS_AUTO    (1ULL << 14)
+#define FUSE_CAP_ASYNC_DIO            (1ULL << 15)
+#define FUSE_CAP_WRITEBACK_CACHE      (1ULL << 16)
+#define FUSE_CAP_PARALLEL_DIROPS      (1ULL << 18)
+#define FUSE_CAP_POSIX_ACL            (1ULL << 19)
+#define FUSE_CAP_CACHE_SYMLINKS       (1ULL << 20)
+#define FUSE_CAP_MAX_PAGES            (1ULL << 21)
+#define FUSE_CAP_SETXATTR_EXT         (1ULL << 22)
+#define FUSE_CAP_DIRECT_IO_ALLOW_MMAP (1ULL << 23)
+#define FUSE_CAP_CREATE_SUPP_GROUP    (1ULL << 24)
+

 /**
 * Ioctl flags
@@ -151,61 +153,23 @@ fuse_file_info
 * indicate the value requested by the filesystem.  The requested
 * value must usually be smaller than the indicated value.
 */
-struct fuse_conn_info {
-  /**
-   * Major version of the protocol (read-only)
-   */
+struct fuse_conn_info
+{
  unsigned proto_major;
-
-  /**
-   * Minor version of the protocol (read-only)
-   */
  unsigned proto_minor;
-
-  /**
-   * Maximum size of the write buffer
-   */
  unsigned max_write;
-
-  /**
-   * Maximum readahead
-   */
  unsigned max_readahead;
-
-  /**
-   * Capability flags, that the kernel supports
-   */
-  unsigned capable;
-
-  /**
-   * Capability flags, that the filesystem wants to enable
-   */
-  unsigned want;
-
-  /**
-   * Maximum number of backgrounded requests
-   */
+  uint64_t capable;
+  uint64_t want;
  unsigned max_background;
-
-  /**
-   * Kernel congestion threshold parameter
-   */
  unsigned congestion_threshold;
-
-  /**
-   * Max pages
-   */
  uint16_t max_pages;
-
-  /**
-   * For future use.
-   */
-  unsigned reserved[22];
 };

 struct fuse_session;
 struct fuse_chan;
-struct fuse_pollhandle;
+struct fuse_pollhandle_t;
+typedef struct fuse_pollhandle_t fuse_pollhandle_t;

 /**
 * Create a FUSE mountpoint
@@ -271,7 +235,7 @@ int fuse_version(void);
 *
 * @param ph the poll handle
 */
-void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
+void fuse_pollhandle_destroy(fuse_pollhandle_t *ph);

 /* ----------------------------------------------------------- *
 * Data buffer						       *
@@ -0,0 +1,31 @@
+/*
+  ISC License
+
+  Copyright (c) 2023, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include <string>
+
+int         fuse_config_get_read_thread_count();
+int         fuse_config_get_process_thread_count();
+int         fuse_config_get_process_thread_queue_depth();
+std::string fuse_config_get_pin_threads();
+
+void        fuse_config_set_read_thread_count(int const);
+void        fuse_config_set_process_thread_count(int const);
+void        fuse_config_set_process_thread_queue_depth(int const);
+void        fuse_config_set_pin_threads(std::string const);
@@ -43,14 +43,12 @@ enum fuse_dirents_type_e
 };
 typedef enum fuse_dirents_type_e fuse_dirents_type_t;

-typedef struct fuse_dirents_s fuse_dirents_t;
-struct fuse_dirents_s
+typedef struct fuse_dirents_t fuse_dirents_t;
+struct fuse_dirents_t
 {
-  char                *buf;
-  uint64_t             buf_len;
-  uint64_t             data_len;
-  kvec_t(uint32_t)     offs;
-  fuse_dirents_type_t  type;
+  kvec_t(char)        data;
+  kvec_t(uint32_t)    offs;
+  fuse_dirents_type_t type;
 };

 int  fuse_dirents_init(fuse_dirents_t *d);
@@ -65,14 +63,14 @@ int  fuse_dirents_add_plus(fuse_dirents_t      *d,
                           const uint64_t       namelen,
                           const fuse_entry_t  *entry,
                           const struct stat   *st);
-int  fuse_dirents_add_linux(fuse_dirents_t              *d,
-                            const struct linux_dirent64 *de,
-                            const uint64_t               namelen);
-int  fuse_dirents_add_linux_plus(fuse_dirents_t              *d,
-                                 const struct linux_dirent64 *de,
-                                 const uint64_t               namelen,
-                                 const fuse_entry_t          *entry,
-                                 const struct stat           *st);
+int  fuse_dirents_add_linux(fuse_dirents_t         *d,
+                            const linux_dirent64_t *de,
+                            const uint64_t          namelen);
+int  fuse_dirents_add_linux_plus(fuse_dirents_t         *d,
+                                 const linux_dirent64_t *de,
+                                 const uint64_t          namelen,
+                                 const fuse_entry_t     *entry,
+                                 const struct stat      *st);

 void *fuse_dirents_find(fuse_dirents_t *d,
                        const uint64_t  ino);
@@ -172,6 +172,45 @@
 *  - add FUSE_WRITE_KILL_PRIV flag
 *  - add FUSE_SETUPMAPPING and FUSE_REMOVEMAPPING
 *  - add map_alignment to fuse_init_out, add FUSE_MAP_ALIGNMENT flag
+ *
+ *  7.32
+ *  - add flags to fuse_attr, add FUSE_ATTR_SUBMOUNT, add FUSE_SUBMOUNTS
+ *
+ *  7.33
+ *  - add FUSE_HANDLE_KILLPRIV_V2, FUSE_WRITE_KILL_SUIDGID, FATTR_KILL_SUIDGID
+ *  - add FUSE_OPEN_KILL_SUIDGID
+ *  - extend fuse_setxattr_in, add FUSE_SETXATTR_EXT
+ *  - add FUSE_SETXATTR_ACL_KILL_SGID
+ *
+ *  7.34
+ *  - add FUSE_SYNCFS
+ *
+ *  7.35
+ *  - add FOPEN_NOFLUSH
+ *
+ *  7.36
+ *  - extend fuse_init_in with reserved fields, add FUSE_INIT_EXT init flag
+ *  - add flags2 to fuse_init_in and fuse_init_out
+ *  - add FUSE_SECURITY_CTX init flag
+ *  - add security context to create, mkdir, symlink, and mknod requests
+ *  - add FUSE_HAS_INODE_DAX, FUSE_ATTR_DAX
+ *
+ *  7.37
+ *  - add FUSE_TMPFILE
+ *
+ *  7.38
+ *  - add FUSE_EXPIRE_ONLY flag to fuse_notify_inval_entry
+ *  - add FOPEN_PARALLEL_DIRECT_WRITES
+ *  - add total_extlen to fuse_in_header
+ *  - add FUSE_MAX_NR_SECCTX
+ *  - add extension header
+ *  - add FUSE_EXT_GROUPS
+ *  - add FUSE_CREATE_SUPP_GROUP
+ *  - add FUSE_HAS_EXPIRE_ONLY
+ *
+ *  7.39
+ *  - add FUSE_DIRECT_IO_ALLOW_MMAP
+ *  - add FUSE_STATX and related structures
 */

 #ifndef _LINUX_FUSE_H
@@ -207,7 +246,7 @@
 #define FUSE_KERNEL_VERSION 7

 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 31
+#define FUSE_KERNEL_MINOR_VERSION 39

 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -231,7 +270,41 @@ struct fuse_attr {
 	uint32_t	gid;
 	uint32_t	rdev;
 	uint32_t	blksize;
-	uint32_t	padding;
+	uint32_t	flags;
+};
+
+/*
+ * The following structures are bit-for-bit compatible with the statx(2) ABI in
+ * Linux.
+ */
+struct fuse_sx_time {
+	int64_t		tv_sec;
+	uint32_t	tv_nsec;
+	int32_t		__reserved;
+};
+
+struct fuse_statx {
+	uint32_t	mask;
+	uint32_t	blksize;
+	uint64_t	attributes;
+	uint32_t	nlink;
+	uint32_t	uid;
+	uint32_t	gid;
+	uint16_t	mode;
+	uint16_t	__spare0[1];
+	uint64_t	ino;
+	uint64_t	size;
+	uint64_t	blocks;
+	uint64_t	attributes_mask;
+	struct fuse_sx_time	atime;
+	struct fuse_sx_time	btime;
+	struct fuse_sx_time	ctime;
+	struct fuse_sx_time	mtime;
+	uint32_t	rdev_major;
+	uint32_t	rdev_minor;
+	uint32_t	dev_major;
+	uint32_t	dev_minor;
+	uint64_t	__spare2[14];
 };

 struct fuse_kstatfs {
@@ -268,6 +341,7 @@ struct fuse_file_lock {
 #define FATTR_MTIME_NOW	(1 << 8)
 #define FATTR_LOCKOWNER	(1 << 9)
 #define FATTR_CTIME	(1 << 10)
+#define FATTR_KILL_SUIDGID	(1 << 11)

 /**
 * Flags returned by the OPEN request
@@ -277,12 +351,16 @@ struct fuse_file_lock {
 * FOPEN_NONSEEKABLE: the file is not seekable
 * FOPEN_CACHE_DIR: allow caching this directory
 * FOPEN_STREAM: the file is stream-like (no file position at all)
+ * FOPEN_NOFLUSH: don't flush data cache on close (unless FUSE_WRITEBACK_CACHE)
+ * FOPEN_PARALLEL_DIRECT_WRITES: Allow concurrent direct writes on the same inode
 */
 #define FOPEN_DIRECT_IO		(1 << 0)
 #define FOPEN_KEEP_CACHE	(1 << 1)
 #define FOPEN_NONSEEKABLE	(1 << 2)
 #define FOPEN_CACHE_DIR		(1 << 3)
 #define FOPEN_STREAM		(1 << 4)
+#define FOPEN_NOFLUSH		(1 << 5)
+#define FOPEN_PARALLEL_DIRECT_WRITES	(1 << 6)

 /**
 * INIT request/reply flags
@@ -313,7 +391,25 @@ struct fuse_file_lock {
 * FUSE_CACHE_SYMLINKS: cache READLINK responses
 * FUSE_NO_OPENDIR_SUPPORT: kernel supports zero-message opendir
 * FUSE_EXPLICIT_INVAL_DATA: only invalidate cached pages on explicit request
- * FUSE_MAP_ALIGNMENT: map_alignment field is valid
+ * FUSE_MAP_ALIGNMENT: init_out.map_alignment contains log2(byte alignment) for
+ *		       foffset and moffset fields in struct
+ *		       fuse_setupmapping_out and fuse_removemapping_one.
+ * FUSE_SUBMOUNTS: kernel supports auto-mounting directory submounts
+ * FUSE_HANDLE_KILLPRIV_V2: fs kills suid/sgid/cap on write/chown/trunc.
+ *			Upon write/truncate suid/sgid is only killed if caller
+ *			does not have CAP_FSETID. Additionally upon
+ *			write/truncate sgid is killed only if file has group
+ *			execute permission. (Same as Linux VFS behavior).
+ * FUSE_SETXATTR_EXT:	Server supports extended struct fuse_setxattr_in
+ * FUSE_INIT_EXT: extended fuse_init_in request
+ * FUSE_INIT_RESERVED: reserved, do not use
+ * FUSE_SECURITY_CTX:	add security context to create, mkdir, symlink, and
+ *			mknod
+ * FUSE_HAS_INODE_DAX:  use per inode DAX
+ * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir,
+ *			symlink and mknod (single group that matches parent)
+ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation
+ * FUSE_DIRECT_IO_ALLOW_MMAP: allow shared mmap in FOPEN_DIRECT_IO mode.
 */
 #define FUSE_ASYNC_READ		(1 << 0)
 #define FUSE_POSIX_LOCKS	(1 << 1)
@@ -342,6 +438,20 @@ struct fuse_file_lock {
 #define FUSE_NO_OPENDIR_SUPPORT (1 << 24)
 #define FUSE_EXPLICIT_INVAL_DATA (1 << 25)
 #define FUSE_MAP_ALIGNMENT	(1 << 26)
+#define FUSE_SUBMOUNTS		(1 << 27)
+#define FUSE_HANDLE_KILLPRIV_V2	(1 << 28)
+#define FUSE_SETXATTR_EXT	(1 << 29)
+#define FUSE_INIT_EXT		(1 << 30)
+#define FUSE_INIT_RESERVED	(1 << 31)
+/* bits 32..63 get shifted down 32 bits into the flags2 field */
+#define FUSE_SECURITY_CTX	(1ULL << 32)
+#define FUSE_HAS_INODE_DAX	(1ULL << 33)
+#define FUSE_CREATE_SUPP_GROUP	(1ULL << 34)
+#define FUSE_HAS_EXPIRE_ONLY	(1ULL << 35)
+#define FUSE_DIRECT_IO_ALLOW_MMAP (1ULL << 36)
+
+/* Obsolete alias for FUSE_DIRECT_IO_ALLOW_MMAP */
+#define FUSE_DIRECT_IO_RELAX	FUSE_DIRECT_IO_ALLOW_MMAP

 /**
 * CUSE INIT request/reply flags
@@ -371,11 +481,14 @@ struct fuse_file_lock {
 *
 * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
 * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
- * FUSE_WRITE_KILL_PRIV: kill suid and sgid bits
+ * FUSE_WRITE_KILL_SUIDGID: kill suid and sgid bits
 */
 #define FUSE_WRITE_CACHE	(1 << 0)
 #define FUSE_WRITE_LOCKOWNER	(1 << 1)
-#define FUSE_WRITE_KILL_PRIV	(1 << 2)
+#define FUSE_WRITE_KILL_SUIDGID (1 << 2)
+
+/* Obsolete alias; this flag implies killing suid/sgid only. */
+#define FUSE_WRITE_KILL_PRIV	FUSE_WRITE_KILL_SUIDGID

 /**
 * Read flags
@@ -417,6 +530,44 @@ struct fuse_file_lock {
 */
 #define FUSE_FSYNC_FDATASYNC	(1 << 0)

+/**
+ * fuse_attr flags
+ *
+ * FUSE_ATTR_SUBMOUNT: Object is a submount root
+ * FUSE_ATTR_DAX: Enable DAX for this file in per inode DAX mode
+ */
+#define FUSE_ATTR_SUBMOUNT      (1 << 0)
+#define FUSE_ATTR_DAX		(1 << 1)
+
+/**
+ * Open flags
+ * FUSE_OPEN_KILL_SUIDGID: Kill suid and sgid if executable
+ */
+#define FUSE_OPEN_KILL_SUIDGID	(1 << 0)
+
+/**
+ * setxattr flags
+ * FUSE_SETXATTR_ACL_KILL_SGID: Clear SGID when system.posix_acl_access is set
+ */
+#define FUSE_SETXATTR_ACL_KILL_SGID	(1 << 0)
+
+/**
+ * notify_inval_entry flags
+ * FUSE_EXPIRE_ONLY
+ */
+#define FUSE_EXPIRE_ONLY		(1 << 0)
+
+/**
+ * extension type
+ * FUSE_MAX_NR_SECCTX: maximum value of &fuse_secctx_header.nr_secctx
+ * FUSE_EXT_GROUPS: &fuse_supp_groups extension
+ */
+enum fuse_ext_type {
+	/* Types 0..31 are reserved for fuse_secctx_header */
+	FUSE_MAX_NR_SECCTX	= 31,
+	FUSE_EXT_GROUPS		= 32,
+};
+
 enum fuse_opcode {
 	FUSE_LOOKUP		= 1,
 	FUSE_FORGET		= 2,  /* no reply */
@@ -465,6 +616,9 @@ enum fuse_opcode {
 	FUSE_COPY_FILE_RANGE	= 47,
 	FUSE_SETUPMAPPING	= 48,
 	FUSE_REMOVEMAPPING	= 49,
+	FUSE_SYNCFS		= 50,
+	FUSE_TMPFILE		= 51,
+	FUSE_STATX		= 52,

 	/* CUSE specific operations */
 	CUSE_INIT		= 4096,
@@ -529,6 +683,22 @@ struct fuse_attr_out {
 	struct fuse_attr attr;
 };

+struct fuse_statx_in {
+	uint32_t	getattr_flags;
+	uint32_t	reserved;
+	uint64_t	fh;
+	uint32_t	sx_flags;
+	uint32_t	sx_mask;
+};
+
+struct fuse_statx_out {
+	uint64_t	attr_valid;	/* Cache timeout for the attributes */
+	uint32_t	attr_valid_nsec;
+	uint32_t	flags;
+	uint64_t	spare[2];
+	struct fuse_statx stat;
+};
+
 #define FUSE_COMPAT_MKNOD_IN_SIZE 8

 struct fuse_mknod_in {
@@ -578,14 +748,14 @@ struct fuse_setattr_in {

 struct fuse_open_in {
 	uint32_t	flags;
-	uint32_t	unused;
+	uint32_t	open_flags;	/* FUSE_OPEN_... */
 };

 struct fuse_create_in {
 	uint32_t	flags;
 	uint32_t	mode;
 	uint32_t	umask;
-	uint32_t	padding;
+	uint32_t	open_flags;	/* FUSE_OPEN_... */
 };

 struct fuse_open_out {
@@ -647,9 +817,13 @@ struct fuse_fsync_in {
 	uint32_t	padding;
 };

+#define FUSE_COMPAT_SETXATTR_IN_SIZE 8
+
 struct fuse_setxattr_in {
 	uint32_t	size;
 	uint32_t	flags;
+	uint32_t	setxattr_flags;
+	uint32_t	padding;
 };

 struct fuse_getxattr_in {
@@ -684,6 +858,8 @@ struct fuse_init_in {
 	uint32_t	minor;
 	uint32_t	max_readahead;
 	uint32_t	flags;
+	uint32_t	flags2;
+	uint32_t	unused[11];
 };

 #define FUSE_COMPAT_INIT_OUT_SIZE 8
@@ -700,7 +876,8 @@ struct fuse_init_out {
 	uint32_t	time_gran;
 	uint16_t	max_pages;
 	uint16_t	map_alignment;
-	uint32_t	unused[8];
+	uint32_t	flags2;
+	uint32_t	unused[7];
 };

 #define CUSE_INIT_INFO_MAX 4096
@@ -791,7 +968,8 @@ struct fuse_in_header {
 	uint32_t	uid;
 	uint32_t	gid;
 	uint32_t	pid;
-	uint32_t	padding;
+	uint16_t	total_extlen; /* length of extensions in 8byte units */
+	uint16_t	padding;
 };

 struct fuse_out_header {
@@ -808,9 +986,12 @@ struct fuse_dirent {
 	char name[];
 };

-#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
-#define FUSE_DIRENT_ALIGN(x) \
+/* Align variable length records to 64bit boundary */
+#define FUSE_REC_ALIGN(x) \
 	(((x) + sizeof(uint64_t) - 1) & ~(sizeof(uint64_t) - 1))
+
+#define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
+#define FUSE_DIRENT_ALIGN(x) FUSE_REC_ALIGN(x)
 #define FUSE_DIRENT_SIZE(d) \
 	FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)

@@ -833,7 +1014,7 @@ struct fuse_notify_inval_inode_out {
 struct fuse_notify_inval_entry_out {
 	uint64_t	parent;
 	uint32_t	namelen;
-	uint32_t	padding;
+	uint32_t	flags;
 };

 struct fuse_notify_delete_out {
@@ -869,7 +1050,8 @@ struct fuse_notify_retrieve_in {
 };

 /* Device ioctls: */
-#define FUSE_DEV_IOC_CLONE	_IOR(229, 0, uint32_t)
+#define FUSE_DEV_IOC_MAGIC		229
+#define FUSE_DEV_IOC_CLONE		_IOR(FUSE_DEV_IOC_MAGIC, 0, uint32_t)

 struct fuse_lseek_in {
 	uint64_t	fh;
@@ -892,4 +1074,83 @@ struct fuse_copy_file_range_in {
 	uint64_t	flags;
 };

+#define FUSE_SETUPMAPPING_FLAG_WRITE (1ull << 0)
+#define FUSE_SETUPMAPPING_FLAG_READ (1ull << 1)
+struct fuse_setupmapping_in {
+	/* An already open handle */
+	uint64_t	fh;
+	/* Offset into the file to start the mapping */
+	uint64_t	foffset;
+	/* Length of mapping required */
+	uint64_t	len;
+	/* Flags, FUSE_SETUPMAPPING_FLAG_* */
+	uint64_t	flags;
+	/* Offset in Memory Window */
+	uint64_t	moffset;
+};
+
+struct fuse_removemapping_in {
+	/* number of fuse_removemapping_one follows */
+	uint32_t        count;
+};
+
+struct fuse_removemapping_one {
+	/* Offset into the dax window start the unmapping */
+	uint64_t        moffset;
+	/* Length of mapping required */
+	uint64_t	len;
+};
+
+#define FUSE_REMOVEMAPPING_MAX_ENTRY   \
+		(PAGE_SIZE / sizeof(struct fuse_removemapping_one))
+
+struct fuse_syncfs_in {
+	uint64_t	padding;
+};
+
+/*
+ * For each security context, send fuse_secctx with size of security context
+ * fuse_secctx will be followed by security context name and this in turn
+ * will be followed by actual context label.
+ * fuse_secctx, name, context
+ */
+struct fuse_secctx {
+	uint32_t	size;
+	uint32_t	padding;
+};
+
+/*
+ * Contains the information about how many fuse_secctx structures are being
+ * sent and what's the total size of all security contexts (including
+ * size of fuse_secctx_header).
+ *
+ */
+struct fuse_secctx_header {
+	uint32_t	size;
+	uint32_t	nr_secctx;
+};
+
+/**
+ * struct fuse_ext_header - extension header
+ * @size: total size of this extension including this header
+ * @type: type of extension
+ *
+ * This is made compatible with fuse_secctx_header by using type values >
+ * FUSE_MAX_NR_SECCTX
+ */
+struct fuse_ext_header {
+	uint32_t	size;
+	uint32_t	type;
+};
+
+/**
+ * struct fuse_supp_groups - Supplementary group extension
+ * @nr_groups: number of supplementary groups
+ * @groups: flexible array of group IDs
+ */
+struct fuse_supp_groups {
+	uint32_t	nr_groups;
+	uint32_t	groups[];
+};
+
 #endif /* _LINUX_FUSE_H */
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef struct fuse_msgbuf_t fuse_msgbuf_t;
+struct fuse_msgbuf_t
+{
+  uint32_t  size;
+  char     *mem;
+};
@@ -0,0 +1,14 @@
+#pragma once
+
+#include <stdint.h>
+
+struct fuse_chan;
+struct fuse_ll;
+
+typedef struct fuse_pollhandle_t fuse_pollhandle_t;
+struct fuse_pollhandle_t
+{
+  uint64_t kh;
+  struct fuse_chan *ch;
+  struct fuse_ll *f;
+};
@@ -59,6 +59,10 @@
 #define kv_pop(v) ((v).a[--(v).n])
 #define kv_size(v) ((v).n)
 #define kv_max(v) ((v).m)
+#define kv_first(v) (kv_A(v,0))
+#define kv_last(v) (kv_A(v,kv_size(v)-1))
+#define kv_end(v) (kv_A(v,kv_size(v)))
+#define kv_delete(v,i) (kv_A(v,i) = kv_pop(v))

 #define kv_resize(type, v, s)  ((v).m = (s), (v).a = (type*)realloc((v).a, sizeof(type) * (v).m))

@@ -1,8 +1,12 @@
 #pragma once

 #include <stdint.h>
+#include <string.h>

-struct linux_dirent64
+#define DIRENT_NAMELEN(X) (strlen((X)->name))
+
+typedef struct linux_dirent64_t linux_dirent64_t;
+struct linux_dirent64_t
 {
  uint64_t ino;
  int64_t  off;
@@ -0,0 +1,582 @@
+// Provides an efficient blocking version of moodycamel::ConcurrentQueue.
+// ©2015-2020 Cameron Desrochers. Distributed under the terms of the simplified
+// BSD license, available at the top of concurrentqueue.h.
+// Also dual-licensed under the Boost Software License (see LICENSE.md)
+// Uses Jeff Preshing's semaphore implementation (under the terms of its
+// separate zlib license, see lightweightsemaphore.h).
+
+#pragma once
+
+#include "concurrentqueue.h"
+#include "lightweightsemaphore.h"
+
+#include <type_traits>
+#include <cerrno>
+#include <memory>
+#include <chrono>
+#include <ctime>
+
+namespace moodycamel
+{
+// This is a blocking version of the queue. It has an almost identical interface to
+// the normal non-blocking version, with the addition of various wait_dequeue() methods
+// and the removal of producer-specific dequeue methods.
+template<typename T, typename Traits = ConcurrentQueueDefaultTraits>
+class BlockingConcurrentQueue
+{
+private:
+	typedef ::moodycamel::ConcurrentQueue<T, Traits> ConcurrentQueue;
+	typedef ::moodycamel::LightweightSemaphore LightweightSemaphore;
+
+public:
+	typedef typename ConcurrentQueue::producer_token_t producer_token_t;
+	typedef typename ConcurrentQueue::consumer_token_t consumer_token_t;
+	
+	typedef typename ConcurrentQueue::index_t index_t;
+	typedef typename ConcurrentQueue::size_t size_t;
+	typedef typename std::make_signed<size_t>::type ssize_t;
+	
+	static const size_t BLOCK_SIZE = ConcurrentQueue::BLOCK_SIZE;
+	static const size_t EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD = ConcurrentQueue::EXPLICIT_BLOCK_EMPTY_COUNTER_THRESHOLD;
+	static const size_t EXPLICIT_INITIAL_INDEX_SIZE = ConcurrentQueue::EXPLICIT_INITIAL_INDEX_SIZE;
+	static const size_t IMPLICIT_INITIAL_INDEX_SIZE = ConcurrentQueue::IMPLICIT_INITIAL_INDEX_SIZE;
+	static const size_t INITIAL_IMPLICIT_PRODUCER_HASH_SIZE = ConcurrentQueue::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE;
+	static const std::uint32_t EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE = ConcurrentQueue::EXPLICIT_CONSUMER_CONSUMPTION_QUOTA_BEFORE_ROTATE;
+	static const size_t MAX_SUBQUEUE_SIZE = ConcurrentQueue::MAX_SUBQUEUE_SIZE;
+	
+public:
+	// Creates a queue with at least `capacity` element slots; note that the
+	// actual number of elements that can be inserted without additional memory
+	// allocation depends on the number of producers and the block size (e.g. if
+	// the block size is equal to `capacity`, only a single block will be allocated
+	// up-front, which means only a single producer will be able to enqueue elements
+	// without an extra allocation -- blocks aren't shared between producers).
+	// This method is not thread safe -- it is up to the user to ensure that the
+	// queue is fully constructed before it starts being used by other threads (this
+	// includes making the memory effects of construction visible, possibly with a
+	// memory barrier).
+	explicit BlockingConcurrentQueue(size_t capacity = 6 * BLOCK_SIZE)
+		: inner(capacity), sema(create<LightweightSemaphore, ssize_t, int>(0, (int)Traits::MAX_SEMA_SPINS), &BlockingConcurrentQueue::template destroy<LightweightSemaphore>)
+	{
+		assert(reinterpret_cast<ConcurrentQueue*>((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member");
+		if (!sema) {
+			MOODYCAMEL_THROW(std::bad_alloc());
+		}
+	}
+	
+	BlockingConcurrentQueue(size_t minCapacity, size_t maxExplicitProducers, size_t maxImplicitProducers)
+		: inner(minCapacity, maxExplicitProducers, maxImplicitProducers), sema(create<LightweightSemaphore, ssize_t, int>(0, (int)Traits::MAX_SEMA_SPINS), &BlockingConcurrentQueue::template destroy<LightweightSemaphore>)
+	{
+		assert(reinterpret_cast<ConcurrentQueue*>((BlockingConcurrentQueue*)1) == &((BlockingConcurrentQueue*)1)->inner && "BlockingConcurrentQueue must have ConcurrentQueue as its first member");
+		if (!sema) {
+			MOODYCAMEL_THROW(std::bad_alloc());
+		}
+	}
+	
+	// Disable copying and copy assignment
+	BlockingConcurrentQueue(BlockingConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
+	BlockingConcurrentQueue& operator=(BlockingConcurrentQueue const&) MOODYCAMEL_DELETE_FUNCTION;
+	
+	// Moving is supported, but note that it is *not* a thread-safe operation.
+	// Nobody can use the queue while it's being moved, and the memory effects
+	// of that move must be propagated to other threads before they can use it.
+	// Note: When a queue is moved, its tokens are still valid but can only be
+	// used with the destination queue (i.e. semantically they are moved along
+	// with the queue itself).
+	BlockingConcurrentQueue(BlockingConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
+		: inner(std::move(other.inner)), sema(std::move(other.sema))
+	{ }
+	
+	inline BlockingConcurrentQueue& operator=(BlockingConcurrentQueue&& other) MOODYCAMEL_NOEXCEPT
+	{
+		return swap_internal(other);
+	}
+	
+	// Swaps this queue's state with the other's. Not thread-safe.
+	// Swapping two queues does not invalidate their tokens, however
+	// the tokens that were created for one queue must be used with
+	// only the swapped queue (i.e. the tokens are tied to the
+	// queue's movable state, not the object itself).
+	inline void swap(BlockingConcurrentQueue& other) MOODYCAMEL_NOEXCEPT
+	{
+		swap_internal(other);
+	}
+	
+private:
+	BlockingConcurrentQueue& swap_internal(BlockingConcurrentQueue& other)
+	{
+		if (this == &other) {
+			return *this;
+		}
+		
+		inner.swap(other.inner);
+		sema.swap(other.sema);
+		return *this;
+	}
+	
+public:
+	// Enqueues a single item (by copying it).
+	// Allocates memory if required. Only fails if memory allocation fails (or implicit
+	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
+	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(T const& item)
+	{
+		if ((details::likely)(inner.enqueue(item))) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues a single item (by moving it, if possible).
+	// Allocates memory if required. Only fails if memory allocation fails (or implicit
+	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
+	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(T&& item)
+	{
+		if ((details::likely)(inner.enqueue(std::move(item)))) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues a single item (by copying it) using an explicit producer token.
+	// Allocates memory if required. Only fails if memory allocation fails (or
+	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(producer_token_t const& token, T const& item)
+	{
+		if ((details::likely)(inner.enqueue(token, item))) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
+	// Allocates memory if required. Only fails if memory allocation fails (or
+	// Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	inline bool enqueue(producer_token_t const& token, T&& item)
+	{
+		if ((details::likely)(inner.enqueue(token, std::move(item)))) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues several items.
+	// Allocates memory if required. Only fails if memory allocation fails (or
+	// implicit production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
+	// is 0, or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Note: Use std::make_move_iterator if the elements should be moved instead of copied.
+	// Thread-safe.
+	template<typename It>
+	inline bool enqueue_bulk(It itemFirst, size_t count)
+	{
+		if ((details::likely)(inner.enqueue_bulk(std::forward<It>(itemFirst), count))) {
+			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues several items using an explicit producer token.
+	// Allocates memory if required. Only fails if memory allocation fails
+	// (or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Note: Use std::make_move_iterator if the elements should be moved
+	// instead of copied.
+	// Thread-safe.
+	template<typename It>
+	inline bool enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+	{
+		if ((details::likely)(inner.enqueue_bulk(token, std::forward<It>(itemFirst), count))) {
+			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues a single item (by copying it).
+	// Does not allocate memory. Fails if not enough room to enqueue (or implicit
+	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE
+	// is 0).
+	// Thread-safe.
+	inline bool try_enqueue(T const& item)
+	{
+		if (inner.try_enqueue(item)) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues a single item (by moving it, if possible).
+	// Does not allocate memory (except for one-time implicit producer).
+	// Fails if not enough room to enqueue (or implicit production is
+	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+	// Thread-safe.
+	inline bool try_enqueue(T&& item)
+	{
+		if (inner.try_enqueue(std::move(item))) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues a single item (by copying it) using an explicit producer token.
+	// Does not allocate memory. Fails if not enough room to enqueue.
+	// Thread-safe.
+	inline bool try_enqueue(producer_token_t const& token, T const& item)
+	{
+		if (inner.try_enqueue(token, item)) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues a single item (by moving it, if possible) using an explicit producer token.
+	// Does not allocate memory. Fails if not enough room to enqueue.
+	// Thread-safe.
+	inline bool try_enqueue(producer_token_t const& token, T&& item)
+	{
+		if (inner.try_enqueue(token, std::move(item))) {
+			sema->signal();
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues several items.
+	// Does not allocate memory (except for one-time implicit producer).
+	// Fails if not enough room to enqueue (or implicit production is
+	// disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0).
+	// Note: Use std::make_move_iterator if the elements should be moved
+	// instead of copied.
+	// Thread-safe.
+	template<typename It>
+	inline bool try_enqueue_bulk(It itemFirst, size_t count)
+	{
+		if (inner.try_enqueue_bulk(std::forward<It>(itemFirst), count)) {
+			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
+			return true;
+		}
+		return false;
+	}
+	
+	// Enqueues several items using an explicit producer token.
+	// Does not allocate memory. Fails if not enough room to enqueue.
+	// Note: Use std::make_move_iterator if the elements should be moved
+	// instead of copied.
+	// Thread-safe.
+	template<typename It>
+	inline bool try_enqueue_bulk(producer_token_t const& token, It itemFirst, size_t count)
+	{
+		if (inner.try_enqueue_bulk(token, std::forward<It>(itemFirst), count)) {
+			sema->signal((LightweightSemaphore::ssize_t)(ssize_t)count);
+			return true;
+		}
+		return false;
+	}
+	
+	
+	// Attempts to dequeue from the queue.
+	// Returns false if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename U>
+	inline bool try_dequeue(U& item)
+	{
+		if (sema->tryWait()) {
+			while (!inner.try_dequeue(item)) {
+				continue;
+			}
+			return true;
+		}
+		return false;
+	}
+	
+	// Attempts to dequeue from the queue using an explicit consumer token.
+	// Returns false if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename U>
+	inline bool try_dequeue(consumer_token_t& token, U& item)
+	{
+		if (sema->tryWait()) {
+			while (!inner.try_dequeue(token, item)) {
+				continue;
+			}
+			return true;
+		}
+		return false;
+	}
+	
+	// Attempts to dequeue several elements from the queue.
+	// Returns the number of items actually dequeued.
+	// Returns 0 if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename It>
+	inline size_t try_dequeue_bulk(It itemFirst, size_t max)
+	{
+		size_t count = 0;
+		max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
+		while (count != max) {
+			count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
+		}
+		return count;
+	}
+	
+	// Attempts to dequeue several elements from the queue using an explicit consumer token.
+	// Returns the number of items actually dequeued.
+	// Returns 0 if all producer streams appeared empty at the time they
+	// were checked (so, the queue is likely but not guaranteed to be empty).
+	// Never allocates. Thread-safe.
+	template<typename It>
+	inline size_t try_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
+	{
+		size_t count = 0;
+		max = (size_t)sema->tryWaitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
+		while (count != max) {
+			count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
+		}
+		return count;
+	}
+	
+	
+	
+	// Blocks the current thread until there's something to dequeue, then
+	// dequeues it.
+	// Never allocates. Thread-safe.
+	template<typename U>
+	inline void wait_dequeue(U& item)
+	{
+		while (!sema->wait()) {
+			continue;
+		}
+		while (!inner.try_dequeue(item)) {
+			continue;
+		}
+	}
+
+	// Blocks the current thread until either there's something to dequeue
+	// or the timeout (specified in microseconds) expires. Returns false
+	// without setting `item` if the timeout expires, otherwise assigns
+	// to `item` and returns true.
+	// Using a negative timeout indicates an indefinite timeout,
+	// and is thus functionally equivalent to calling wait_dequeue.
+	// Never allocates. Thread-safe.
+	template<typename U>
+	inline bool wait_dequeue_timed(U& item, std::int64_t timeout_usecs)
+	{
+		if (!sema->wait(timeout_usecs)) {
+			return false;
+		}
+		while (!inner.try_dequeue(item)) {
+			continue;
+		}
+		return true;
+	}
+    
+    // Blocks the current thread until either there's something to dequeue
+	// or the timeout expires. Returns false without setting `item` if the
+    // timeout expires, otherwise assigns to `item` and returns true.
+	// Never allocates. Thread-safe.
+	template<typename U, typename Rep, typename Period>
+	inline bool wait_dequeue_timed(U& item, std::chrono::duration<Rep, Period> const& timeout)
+    {
+        return wait_dequeue_timed(item, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
+    }
+	
+	// Blocks the current thread until there's something to dequeue, then
+	// dequeues it using an explicit consumer token.
+	// Never allocates. Thread-safe.
+	template<typename U>
+	inline void wait_dequeue(consumer_token_t& token, U& item)
+	{
+		while (!sema->wait()) {
+			continue;
+		}
+		while (!inner.try_dequeue(token, item)) {
+			continue;
+		}
+	}
+	
+	// Blocks the current thread until either there's something to dequeue
+	// or the timeout (specified in microseconds) expires. Returns false
+	// without setting `item` if the timeout expires, otherwise assigns
+	// to `item` and returns true.
+	// Using a negative timeout indicates an indefinite timeout,
+	// and is thus functionally equivalent to calling wait_dequeue.
+	// Never allocates. Thread-safe.
+	template<typename U>
+	inline bool wait_dequeue_timed(consumer_token_t& token, U& item, std::int64_t timeout_usecs)
+	{
+		if (!sema->wait(timeout_usecs)) {
+			return false;
+		}
+		while (!inner.try_dequeue(token, item)) {
+			continue;
+		}
+		return true;
+	}
+    
+    // Blocks the current thread until either there's something to dequeue
+	// or the timeout expires. Returns false without setting `item` if the
+    // timeout expires, otherwise assigns to `item` and returns true.
+	// Never allocates. Thread-safe.
+	template<typename U, typename Rep, typename Period>
+	inline bool wait_dequeue_timed(consumer_token_t& token, U& item, std::chrono::duration<Rep, Period> const& timeout)
+    {
+        return wait_dequeue_timed(token, item, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
+    }
+	
+	// Attempts to dequeue several elements from the queue.
+	// Returns the number of items actually dequeued, which will
+	// always be at least one (this method blocks until the queue
+	// is non-empty) and at most max.
+	// Never allocates. Thread-safe.
+	template<typename It>
+	inline size_t wait_dequeue_bulk(It itemFirst, size_t max)
+	{
+		size_t count = 0;
+		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
+		while (count != max) {
+			count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
+		}
+		return count;
+	}
+	
+	// Attempts to dequeue several elements from the queue.
+	// Returns the number of items actually dequeued, which can
+	// be 0 if the timeout expires while waiting for elements,
+	// and at most max.
+	// Using a negative timeout indicates an indefinite timeout,
+	// and is thus functionally equivalent to calling wait_dequeue_bulk.
+	// Never allocates. Thread-safe.
+	template<typename It>
+	inline size_t wait_dequeue_bulk_timed(It itemFirst, size_t max, std::int64_t timeout_usecs)
+	{
+		size_t count = 0;
+		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs);
+		while (count != max) {
+			count += inner.template try_dequeue_bulk<It&>(itemFirst, max - count);
+		}
+		return count;
+	}
+    
+    // Attempts to dequeue several elements from the queue.
+	// Returns the number of items actually dequeued, which can
+	// be 0 if the timeout expires while waiting for elements,
+	// and at most max.
+	// Never allocates. Thread-safe.
+	template<typename It, typename Rep, typename Period>
+	inline size_t wait_dequeue_bulk_timed(It itemFirst, size_t max, std::chrono::duration<Rep, Period> const& timeout)
+    {
+        return wait_dequeue_bulk_timed<It&>(itemFirst, max, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
+    }
+	
+	// Attempts to dequeue several elements from the queue using an explicit consumer token.
+	// Returns the number of items actually dequeued, which will
+	// always be at least one (this method blocks until the queue
+	// is non-empty) and at most max.
+	// Never allocates. Thread-safe.
+	template<typename It>
+	inline size_t wait_dequeue_bulk(consumer_token_t& token, It itemFirst, size_t max)
+	{
+		size_t count = 0;
+		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max);
+		while (count != max) {
+			count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
+		}
+		return count;
+	}
+	
+	// Attempts to dequeue several elements from the queue using an explicit consumer token.
+	// Returns the number of items actually dequeued, which can
+	// be 0 if the timeout expires while waiting for elements,
+	// and at most max.
+	// Using a negative timeout indicates an indefinite timeout,
+	// and is thus functionally equivalent to calling wait_dequeue_bulk.
+	// Never allocates. Thread-safe.
+	template<typename It>
+	inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::int64_t timeout_usecs)
+	{
+		size_t count = 0;
+		max = (size_t)sema->waitMany((LightweightSemaphore::ssize_t)(ssize_t)max, timeout_usecs);
+		while (count != max) {
+			count += inner.template try_dequeue_bulk<It&>(token, itemFirst, max - count);
+		}
+		return count;
+	}
+	
+	// Attempts to dequeue several elements from the queue using an explicit consumer token.
+	// Returns the number of items actually dequeued, which can
+	// be 0 if the timeout expires while waiting for elements,
+	// and at most max.
+	// Never allocates. Thread-safe.
+	template<typename It, typename Rep, typename Period>
+	inline size_t wait_dequeue_bulk_timed(consumer_token_t& token, It itemFirst, size_t max, std::chrono::duration<Rep, Period> const& timeout)
+    {
+        return wait_dequeue_bulk_timed<It&>(token, itemFirst, max, std::chrono::duration_cast<std::chrono::microseconds>(timeout).count());
+    }
+	
+	
+	// Returns an estimate of the total number of elements currently in the queue. This
+	// estimate is only accurate if the queue has completely stabilized before it is called
+	// (i.e. all enqueue and dequeue operations have completed and their memory effects are
+	// visible on the calling thread, and no further operations start while this method is
+	// being called).
+	// Thread-safe.
+	inline size_t size_approx() const
+	{
+		return (size_t)sema->availableApprox();
+	}
+	
+	
+	// Returns true if the underlying atomic variables used by
+	// the queue are lock-free (they should be on most platforms).
+	// Thread-safe.
+	static constexpr bool is_lock_free()
+	{
+		return ConcurrentQueue::is_lock_free();
+	}
+	
+
+private:
+	template<typename U, typename A1, typename A2>
+	static inline U* create(A1&& a1, A2&& a2)
+	{
+		void* p = (Traits::malloc)(sizeof(U));
+		return p != nullptr ? new (p) U(std::forward<A1>(a1), std::forward<A2>(a2)) : nullptr;
+	}
+	
+	template<typename U>
+	static inline void destroy(U* p)
+	{
+		if (p != nullptr) {
+			p->~U();
+		}
+		(Traits::free)(p);
+	}
+	
+private:
+	ConcurrentQueue inner;
+	std::unique_ptr<LightweightSemaphore, void (*)(LightweightSemaphore*)> sema;
+};
+
+
+template<typename T, typename Traits>
+inline void swap(BlockingConcurrentQueue<T, Traits>& a, BlockingConcurrentQueue<T, Traits>& b) MOODYCAMEL_NOEXCEPT
+{
+	a.swap(b);
+}
+
+}	// end namespace moodycamel
@@ -0,0 +1,427 @@
+// Provides an efficient implementation of a semaphore (LightweightSemaphore).
+// This is an extension of Jeff Preshing's sempahore implementation (licensed 
+// under the terms of its separate zlib license) that has been adapted and
+// extended by Cameron Desrochers.
+
+#pragma once
+
+#include <cstddef> // For std::size_t
+#include <atomic>
+#include <type_traits> // For std::make_signed<T>
+
+#if defined(_WIN32)
+// Avoid including windows.h in a header; we only need a handful of
+// items, so we'll redeclare them here (this is relatively safe since
+// the API generally has to remain stable between Windows versions).
+// I know this is an ugly hack but it still beats polluting the global
+// namespace with thousands of generic names or adding a .cpp for nothing.
+extern "C" {
+	struct _SECURITY_ATTRIBUTES;
+	__declspec(dllimport) void* __stdcall CreateSemaphoreW(_SECURITY_ATTRIBUTES* lpSemaphoreAttributes, long lInitialCount, long lMaximumCount, const wchar_t* lpName);
+	__declspec(dllimport) int __stdcall CloseHandle(void* hObject);
+	__declspec(dllimport) unsigned long __stdcall WaitForSingleObject(void* hHandle, unsigned long dwMilliseconds);
+	__declspec(dllimport) int __stdcall ReleaseSemaphore(void* hSemaphore, long lReleaseCount, long* lpPreviousCount);
+}
+#elif defined(__MACH__)
+#include <mach/mach.h>
+#elif defined(__MVS__)
+#include <zos-semaphore.h>
+#elif defined(__unix__)
+#include <semaphore.h>
+
+#if defined(__GLIBC_PREREQ) && defined(_GNU_SOURCE)
+#if __GLIBC_PREREQ(2,30)
+#define MOODYCAMEL_LIGHTWEIGHTSEMAPHORE_MONOTONIC
+#endif
+#endif
+#endif
+
+namespace moodycamel
+{
+namespace details
+{
+
+// Code in the mpmc_sema namespace below is an adaptation of Jeff Preshing's
+// portable + lightweight semaphore implementations, originally from
+// https://github.com/preshing/cpp11-on-multicore/blob/master/common/sema.h
+// LICENSE:
+// Copyright (c) 2015 Jeff Preshing
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//	claim that you wrote the original software. If you use this software
+//	in a product, an acknowledgement in the product documentation would be
+//	appreciated but is not required.
+// 2. Altered source versions must be plainly marked as such, and must not be
+//	misrepresented as being the original software.
+// 3. This notice may not be removed or altered from any source distribution.
+#if defined(_WIN32)
+class Semaphore
+{
+private:
+	void* m_hSema;
+	
+	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
+	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
+
+public:
+	Semaphore(int initialCount = 0)
+	{
+		assert(initialCount >= 0);
+		const long maxLong = 0x7fffffff;
+		m_hSema = CreateSemaphoreW(nullptr, initialCount, maxLong, nullptr);
+		assert(m_hSema);
+	}
+
+	~Semaphore()
+	{
+		CloseHandle(m_hSema);
+	}
+
+	bool wait()
+	{
+		const unsigned long infinite = 0xffffffff;
+		return WaitForSingleObject(m_hSema, infinite) == 0;
+	}
+	
+	bool try_wait()
+	{
+		return WaitForSingleObject(m_hSema, 0) == 0;
+	}
+	
+	bool timed_wait(std::uint64_t usecs)
+	{
+		return WaitForSingleObject(m_hSema, (unsigned long)(usecs / 1000)) == 0;
+	}
+
+	void signal(int count = 1)
+	{
+		while (!ReleaseSemaphore(m_hSema, count, nullptr));
+	}
+};
+#elif defined(__MACH__)
+//---------------------------------------------------------
+// Semaphore (Apple iOS and OSX)
+// Can't use POSIX semaphores due to http://lists.apple.com/archives/darwin-kernel/2009/Apr/msg00010.html
+//---------------------------------------------------------
+class Semaphore
+{
+private:
+	semaphore_t m_sema;
+
+	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
+	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
+
+public:
+	Semaphore(int initialCount = 0)
+	{
+		assert(initialCount >= 0);
+		kern_return_t rc = semaphore_create(mach_task_self(), &m_sema, SYNC_POLICY_FIFO, initialCount);
+		assert(rc == KERN_SUCCESS);
+		(void)rc;
+	}
+
+	~Semaphore()
+	{
+		semaphore_destroy(mach_task_self(), m_sema);
+	}
+
+	bool wait()
+	{
+		return semaphore_wait(m_sema) == KERN_SUCCESS;
+	}
+	
+	bool try_wait()
+	{
+		return timed_wait(0);
+	}
+	
+	bool timed_wait(std::uint64_t timeout_usecs)
+	{
+		mach_timespec_t ts;
+		ts.tv_sec = static_cast<unsigned int>(timeout_usecs / 1000000);
+		ts.tv_nsec = static_cast<int>((timeout_usecs % 1000000) * 1000);
+
+		// added in OSX 10.10: https://developer.apple.com/library/prerelease/mac/documentation/General/Reference/APIDiffsMacOSX10_10SeedDiff/modules/Darwin.html
+		kern_return_t rc = semaphore_timedwait(m_sema, ts);
+		return rc == KERN_SUCCESS;
+	}
+
+	void signal()
+	{
+		while (semaphore_signal(m_sema) != KERN_SUCCESS);
+	}
+
+	void signal(int count)
+	{
+		while (count-- > 0)
+		{
+			while (semaphore_signal(m_sema) != KERN_SUCCESS);
+		}
+	}
+};
+#elif defined(__unix__) || defined(__MVS__)
+//---------------------------------------------------------
+// Semaphore (POSIX, Linux, zOS)
+//---------------------------------------------------------
+class Semaphore
+{
+private:
+	sem_t m_sema;
+
+	Semaphore(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
+	Semaphore& operator=(const Semaphore& other) MOODYCAMEL_DELETE_FUNCTION;
+
+public:
+	Semaphore(int initialCount = 0)
+	{
+		assert(initialCount >= 0);
+		int rc = sem_init(&m_sema, 0, static_cast<unsigned int>(initialCount));
+		assert(rc == 0);
+		(void)rc;
+	}
+
+	~Semaphore()
+	{
+		sem_destroy(&m_sema);
+	}
+
+	bool wait()
+	{
+		// http://stackoverflow.com/questions/2013181/gdb-causes-sem-wait-to-fail-with-eintr-error
+		int rc;
+		do {
+			rc = sem_wait(&m_sema);
+		} while (rc == -1 && errno == EINTR);
+		return rc == 0;
+	}
+
+	bool try_wait()
+	{
+		int rc;
+		do {
+			rc = sem_trywait(&m_sema);
+		} while (rc == -1 && errno == EINTR);
+		return rc == 0;
+	}
+
+	bool timed_wait(std::uint64_t usecs)
+	{
+		struct timespec ts;
+		const int usecs_in_1_sec = 1000000;
+		const int nsecs_in_1_sec = 1000000000;
+#ifdef MOODYCAMEL_LIGHTWEIGHTSEMAPHORE_MONOTONIC
+		clock_gettime(CLOCK_MONOTONIC, &ts);
+#else
+		clock_gettime(CLOCK_REALTIME, &ts);
+#endif
+		ts.tv_sec += (time_t)(usecs / usecs_in_1_sec);
+		ts.tv_nsec += (long)(usecs % usecs_in_1_sec) * 1000;
+		// sem_timedwait bombs if you have more than 1e9 in tv_nsec
+		// so we have to clean things up before passing it in
+		if (ts.tv_nsec >= nsecs_in_1_sec) {
+			ts.tv_nsec -= nsecs_in_1_sec;
+			++ts.tv_sec;
+		}
+
+		int rc;
+		do {
+#ifdef MOODYCAMEL_LIGHTWEIGHTSEMAPHORE_MONOTONIC
+			rc = sem_clockwait(&m_sema, CLOCK_MONOTONIC, &ts);
+#else
+			rc = sem_timedwait(&m_sema, &ts);
+#endif
+		} while (rc == -1 && errno == EINTR);
+		return rc == 0;
+	}
+
+	void signal()
+	{
+		while (sem_post(&m_sema) == -1);
+	}
+
+	void signal(int count)
+	{
+		while (count-- > 0)
+		{
+			while (sem_post(&m_sema) == -1);
+		}
+	}
+};
+#else
+#error Unsupported platform! (No semaphore wrapper available)
+#endif
+
+}	// end namespace details
+
+
+//---------------------------------------------------------
+// LightweightSemaphore
+//---------------------------------------------------------
+class LightweightSemaphore
+{
+public:
+	typedef std::make_signed<std::size_t>::type ssize_t;
+
+private:
+	std::atomic<ssize_t> m_count;
+	details::Semaphore m_sema;
+	int m_maxSpins;
+
+	bool waitWithPartialSpinning(std::int64_t timeout_usecs = -1)
+	{
+		ssize_t oldCount;
+		int spin = m_maxSpins;
+		while (--spin >= 0)
+		{
+			oldCount = m_count.load(std::memory_order_relaxed);
+			if ((oldCount > 0) && m_count.compare_exchange_strong(oldCount, oldCount - 1, std::memory_order_acquire, std::memory_order_relaxed))
+				return true;
+			std::atomic_signal_fence(std::memory_order_acquire);	 // Prevent the compiler from collapsing the loop.
+		}
+		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
+		if (oldCount > 0)
+			return true;
+		if (timeout_usecs < 0)
+		{
+			if (m_sema.wait())
+				return true;
+		}
+		if (timeout_usecs > 0 && m_sema.timed_wait((std::uint64_t)timeout_usecs))
+			return true;
+		// At this point, we've timed out waiting for the semaphore, but the
+		// count is still decremented indicating we may still be waiting on
+		// it. So we have to re-adjust the count, but only if the semaphore
+		// wasn't signaled enough times for us too since then. If it was, we
+		// need to release the semaphore too.
+		while (true)
+		{
+			oldCount = m_count.load(std::memory_order_acquire);
+			if (oldCount >= 0 && m_sema.try_wait())
+				return true;
+			if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
+				return false;
+		}
+	}
+
+	ssize_t waitManyWithPartialSpinning(ssize_t max, std::int64_t timeout_usecs = -1)
+	{
+		assert(max > 0);
+		ssize_t oldCount;
+		int spin = m_maxSpins;
+		while (--spin >= 0)
+		{
+			oldCount = m_count.load(std::memory_order_relaxed);
+			if (oldCount > 0)
+			{
+				ssize_t newCount = oldCount > max ? oldCount - max : 0;
+				if (m_count.compare_exchange_strong(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
+					return oldCount - newCount;
+			}
+			std::atomic_signal_fence(std::memory_order_acquire);
+		}
+		oldCount = m_count.fetch_sub(1, std::memory_order_acquire);
+		if (oldCount <= 0)
+		{
+			if ((timeout_usecs == 0) || (timeout_usecs < 0 && !m_sema.wait()) || (timeout_usecs > 0 && !m_sema.timed_wait((std::uint64_t)timeout_usecs)))
+			{
+				while (true)
+				{
+					oldCount = m_count.load(std::memory_order_acquire);
+					if (oldCount >= 0 && m_sema.try_wait())
+						break;
+					if (oldCount < 0 && m_count.compare_exchange_strong(oldCount, oldCount + 1, std::memory_order_relaxed, std::memory_order_relaxed))
+						return 0;
+				}
+			}
+		}
+		if (max > 1)
+			return 1 + tryWaitMany(max - 1);
+		return 1;
+	}
+
+public:
+	LightweightSemaphore(ssize_t initialCount = 0, int maxSpins = 10000) : m_count(initialCount), m_maxSpins(maxSpins)
+	{
+		assert(initialCount >= 0);
+		assert(maxSpins >= 0);
+	}
+
+	bool tryWait()
+	{
+		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
+		while (oldCount > 0)
+		{
+			if (m_count.compare_exchange_weak(oldCount, oldCount - 1, std::memory_order_acquire, std::memory_order_relaxed))
+				return true;
+		}
+		return false;
+	}
+
+	bool wait()
+	{
+		return tryWait() || waitWithPartialSpinning();
+	}
+
+	bool wait(std::int64_t timeout_usecs)
+	{
+		return tryWait() || waitWithPartialSpinning(timeout_usecs);
+	}
+
+	// Acquires between 0 and (greedily) max, inclusive
+	ssize_t tryWaitMany(ssize_t max)
+	{
+		assert(max >= 0);
+		ssize_t oldCount = m_count.load(std::memory_order_relaxed);
+		while (oldCount > 0)
+		{
+			ssize_t newCount = oldCount > max ? oldCount - max : 0;
+			if (m_count.compare_exchange_weak(oldCount, newCount, std::memory_order_acquire, std::memory_order_relaxed))
+				return oldCount - newCount;
+		}
+		return 0;
+	}
+
+	// Acquires at least one, and (greedily) at most max
+	ssize_t waitMany(ssize_t max, std::int64_t timeout_usecs)
+	{
+		assert(max >= 0);
+		ssize_t result = tryWaitMany(max);
+		if (result == 0 && max > 0)
+			result = waitManyWithPartialSpinning(max, timeout_usecs);
+		return result;
+	}
+	
+	ssize_t waitMany(ssize_t max)
+	{
+		ssize_t result = waitMany(max, -1);
+		assert(result > 0);
+		return result;
+	}
+
+	void signal(ssize_t count = 1)
+	{
+		assert(count >= 0);
+		ssize_t oldCount = m_count.fetch_add(count, std::memory_order_release);
+		ssize_t toRelease = -oldCount < count ? -oldCount : count;
+		if (toRelease > 0)
+		{
+			m_sema.signal((int)toRelease);
+		}
+	}
+	
+	std::size_t availableApprox() const
+	{
+		ssize_t count = m_count.load(std::memory_order_relaxed);
+		return count > 0 ? static_cast<std::size_t>(count) : 0;
+	}
+};
+
+}   // end namespace moodycamel
@@ -0,0 +1,318 @@
+#pragma once
+
+#include "moodycamel/blockingconcurrentqueue.h"
+
+#include <algorithm>
+#include <atomic>
+#include <csignal>
+#include <cstring>
+#include <future>
+#include <memory>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include <syslog.h>
+
+
+struct ThreadPoolTraits : public moodycamel::ConcurrentQueueDefaultTraits
+{
+  static const int MAX_SEMA_SPINS = 1;
+};
+
+
+class ThreadPool
+{
+private:
+  using Func  = std::function<void(void)>;
+  using Queue = moodycamel::BlockingConcurrentQueue<Func,ThreadPoolTraits>;
+
+public:
+  explicit
+  ThreadPool(unsigned const thread_count_    = std::thread::hardware_concurrency(),
+             unsigned const max_queue_depth_ = std::thread::hardware_concurrency(),
+             std::string const name_         = {})
+    : _queue(),
+      _queue_depth(0),
+      _max_queue_depth(std::max(thread_count_,max_queue_depth_)),
+      _name(name_)
+  {
+    syslog(LOG_DEBUG,
+           "threadpool (%s): spawning %u threads w/ max queue depth %u%s",
+           _name.c_str(),
+           thread_count_,
+           _max_queue_depth,
+           ((_max_queue_depth != max_queue_depth_) ? " (adjusted)" : ""));
+
+    sigset_t oldset;
+    sigset_t newset;
+
+    sigfillset(&newset);
+    pthread_sigmask(SIG_BLOCK,&newset,&oldset);
+
+    _threads.reserve(thread_count_);
+    for(std::size_t i = 0; i < thread_count_; ++i)
+      {
+        int rv;
+        pthread_t t;
+
+        rv = pthread_create(&t,NULL,ThreadPool::start_routine,this);
+        if(rv != 0)
+          {
+            syslog(LOG_WARNING,
+                   "threadpool (%s): error spawning thread - %d (%s)",
+                   _name.c_str(),
+                   rv,
+                   strerror(rv));
+            continue;
+          }
+
+        if(!_name.empty())
+          pthread_setname_np(t,_name.c_str());
+
+        _threads.push_back(t);
+      }
+
+    pthread_sigmask(SIG_SETMASK,&oldset,NULL);
+
+    if(_threads.empty())
+      throw std::runtime_error("threadpool: failed to spawn any threads");
+  }
+
+  ~ThreadPool()
+  {
+    syslog(LOG_DEBUG,
+           "threadpool (%s): destroying %lu threads",
+           _name.c_str(),
+           _threads.size());
+
+    auto func = []() { pthread_exit(NULL); };
+    for(std::size_t i = 0; i < _threads.size(); i++)
+      _queue.enqueue(func);
+
+    for(auto t : _threads)
+      pthread_cancel(t);
+
+    for(auto t : _threads)
+      pthread_join(t,NULL);
+  }
+
+private:
+  static
+  void*
+  start_routine(void *arg_)
+  {
+    ThreadPool *btp = static_cast<ThreadPool*>(arg_);
+    ThreadPool::Func func;
+    ThreadPool::Queue &q = btp->_queue;
+    std::atomic<unsigned> &queue_depth = btp->_queue_depth;
+    moodycamel::ConsumerToken ctok(btp->_queue);
+
+    while(true)
+      {
+        q.wait_dequeue(ctok,func);
+
+        func();
+
+        queue_depth.fetch_sub(1,std::memory_order_release);
+      }
+
+    return NULL;
+  }
+
+public:
+  int
+  add_thread(std::string const name_ = {})
+  {
+    int rv;
+    pthread_t t;
+    sigset_t oldset;
+    sigset_t newset;
+    std::string name;
+
+    name = (name_.empty() ? _name : name_);
+
+    sigfillset(&newset);
+    pthread_sigmask(SIG_BLOCK,&newset,&oldset);
+    rv = pthread_create(&t,NULL,ThreadPool::start_routine,this);
+    pthread_sigmask(SIG_SETMASK,&oldset,NULL);
+
+    if(rv != 0)
+      {
+        syslog(LOG_WARNING,
+               "threadpool (%s): error spawning thread - %d (%s)",
+               _name.c_str(),
+               rv,
+               strerror(rv));
+        return -rv;
+      }
+
+    if(!name.empty())
+      pthread_setname_np(t,name.c_str());
+
+    {
+      std::lock_guard<std::mutex> lg(_threads_mutex);
+      _threads.push_back(t);
+    }
+
+    syslog(LOG_DEBUG,
+           "threadpool (%s): 1 thread added named '%s'",
+           _name.c_str(),
+           name.c_str());
+
+    return 0;
+  }
+
+  int
+  remove_thread(void)
+  {
+    {
+      std::lock_guard<std::mutex> lg(_threads_mutex);
+      if(_threads.size() <= 1)
+        return -EINVAL;
+    }
+
+    std::promise<pthread_t> promise;
+    auto func = [&]()
+    {
+      pthread_t t;
+
+      t = pthread_self();
+      promise.set_value(t);
+
+      {
+        std::lock_guard<std::mutex> lg(_threads_mutex);
+
+        for(auto i = _threads.begin(); i != _threads.end(); ++i)
+          {
+            if(*i != t)
+              continue;
+
+            _threads.erase(i);
+            break;
+          }
+      }
+
+      syslog(LOG_DEBUG,
+             "threadpool (%s): 1 thread removed",
+             _name.c_str());
+
+      pthread_exit(NULL);
+    };
+
+    enqueue_work(func);
+    pthread_join(promise.get_future().get(),NULL);
+
+    return 0;
+  }
+
+  int
+  set_threads(std::size_t const count_)
+  {
+    int diff;
+    {
+      std::lock_guard<std::mutex> lg(_threads_mutex);
+
+      diff = ((int)count_ - (int)_threads.size());
+    }
+
+    for(auto i = diff; i > 0; --i)
+      add_thread();
+    for(auto i = diff; i < 0; ++i)
+      remove_thread();
+
+    return diff;
+  }
+
+public:
+  template<typename FuncType>
+  void
+  enqueue_work(moodycamel::ProducerToken  &ptok_,
+               FuncType                  &&f_)
+  {
+    timespec ts = {0,1000};
+    for(unsigned i = 0; i < 1000000; i++)
+      {
+        if(_queue_depth.load(std::memory_order_acquire) < _max_queue_depth)
+          break;
+        ::nanosleep(&ts,NULL);
+      }
+
+    _queue.enqueue(ptok_,f_);
+    _queue_depth.fetch_add(1,std::memory_order_release);
+  }
+
+  template<typename FuncType>
+  void
+  enqueue_work(FuncType &&f_)
+  {
+    timespec ts = {0,1000};
+    for(unsigned i = 0; i < 1000000; i++)
+      {
+        if(_queue_depth.load(std::memory_order_acquire) < _max_queue_depth)
+          break;
+        ::nanosleep(&ts,NULL);
+      }
+
+    _queue.enqueue(f_);
+    _queue_depth.fetch_add(1,std::memory_order_release);
+  }
+
+  template<typename FuncType>
+  [[nodiscard]]
+  std::future<typename std::result_of<FuncType()>::type>
+  enqueue_task(FuncType&& f_)
+  {
+    using TaskReturnType = typename std::result_of<FuncType()>::type;
+    using Promise        = std::promise<TaskReturnType>;
+
+    auto promise = std::make_shared<Promise>();
+    auto future  = promise->get_future();
+
+    auto work = [=]()
+    {
+      auto rv = f_();
+      promise->set_value(rv);
+    };
+
+    timespec ts = {0,1000};
+    for(unsigned i = 0; i < 1000000; i++)
+      {
+        if(_queue_depth.load(std::memory_order_acquire) < _max_queue_depth)
+          break;
+        ::nanosleep(&ts,NULL);
+      }
+
+    _queue.enqueue(work);
+    _queue_depth.fetch_add(1,std::memory_order_release);
+
+    return future;
+  }
+
+public:
+  std::vector<pthread_t>
+  threads() const
+  {
+    std::lock_guard<std::mutex> lg(_threads_mutex);
+
+    return _threads;
+  }
+
+  moodycamel::ProducerToken
+  ptoken()
+  {
+    return moodycamel::ProducerToken(_queue);
+  }
+
+private:
+  Queue _queue;
+  std::atomic<unsigned> _queue_depth;
+  unsigned const        _max_queue_depth;
+
+private:
+  std::string const      _name;
+  std::vector<pthread_t> _threads;
+  mutable std::mutex     _threads_mutex;
+};
@@ -182,8 +182,7 @@ static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
  }

  while (len) {
-    res = splice(src->fd, srcpos, dst->fd, dstpos, len,
-                 splice_flags);
+    res = splice(src->fd, srcpos, dst->fd, dstpos, len, splice_flags);
    if (res == -1) {
      if (copied)
        break;
@@ -0,0 +1,163 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "cpu.hpp"
+#include "ghc/filesystem.hpp"
+#include "fmt/core.h"
+
+#include <sched.h>
+
+#include <fstream>
+
+
+int
+CPU::getaffinity(const pthread_t  thread_id_,
+                 cpu_set_t       *cpuset_)
+{
+  CPU_ZERO(cpuset_);
+  return sched_getaffinity(thread_id_,
+                           sizeof(cpu_set_t),
+                           cpuset_);
+}
+
+int
+CPU::setaffinity(const pthread_t  thread_id_,
+                 cpu_set_t       *cpuset_)
+{
+  return pthread_setaffinity_np(thread_id_,
+                                sizeof(cpu_set_t),
+                                cpuset_);
+}
+
+int
+CPU::setaffinity(const pthread_t thread_id_,
+                 const int       cpu_)
+{
+  cpu_set_t cpuset;
+
+  CPU_ZERO(&cpuset);
+  CPU_SET(cpu_,&cpuset);
+
+  return CPU::setaffinity(thread_id_,&cpuset);
+}
+
+int
+CPU::setaffinity(const pthread_t     thread_id_,
+                 const std::set<int> cpus_)
+{
+  cpu_set_t cpuset;
+
+  CPU_ZERO(&cpuset);
+  for(auto const cpu : cpus_)
+    CPU_SET(cpu,&cpuset);
+
+  return CPU::setaffinity(thread_id_,&cpuset);
+}
+
+static
+ghc::filesystem::path
+generate_cpu_core_id_path(const int cpu_id_)
+{
+  const ghc::filesystem::path basepath{"/sys/devices/system/cpu"};
+
+  return basepath / fmt::format("cpu{}",cpu_id_) / "topology" / "core_id";
+}
+
+int
+CPU::count()
+{
+  int rv;
+  cpu_set_t cpuset;
+
+  rv = CPU::getaffinity(0,&cpuset);
+  if(rv < 0)
+    return rv;
+
+  return CPU_COUNT(&cpuset);
+}
+
+CPU::CPUVec
+CPU::cpus()
+{
+  cpu_set_t cpuset;
+  CPU::CPUVec cpuvec;
+
+  CPU::getaffinity(0,&cpuset);
+
+  for(int i = 0; i < CPU_SETSIZE; i++)
+    {
+      if(!CPU_ISSET(i,&cpuset))
+        continue;
+
+      cpuvec.push_back(i);
+    }
+
+  return cpuvec;
+}
+
+CPU::CPU2CoreMap
+CPU::cpu2core()
+{
+  cpu_set_t cpuset;
+  CPU::CPU2CoreMap c2c;
+
+  CPU::getaffinity(0,&cpuset);
+
+  for(int i = 0; i < CPU_SETSIZE; i++)
+    {
+      int core_id;
+      std::ifstream ifs;
+      ghc::filesystem::path path;
+
+      if(!CPU_ISSET(i,&cpuset))
+        continue;
+
+      path = ::generate_cpu_core_id_path(i);
+
+      ifs.open(path);
+      if(!ifs)
+        break;
+
+      ifs >> core_id;
+
+      c2c[i] = core_id;
+
+      ifs.close();
+    }
+
+  return c2c;
+}
+
+CPU::Core2CPUsMap
+CPU::core2cpus()
+{
+  cpu_set_t cpuset;
+  CPU::Core2CPUsMap c2c;
+
+  CPU::getaffinity(0,&cpuset);
+
+  for(int i = 0; i < CPU_SETSIZE; i++)
+    {
+      int core_id;
+      std::ifstream ifs;
+      ghc::filesystem::path path;
+
+      if(!CPU_ISSET(i,&cpuset))
+        continue;
+
+      path = ::generate_cpu_core_id_path(i);
+
+      ifs.open(path);
+      if(!ifs)
+        break;
+
+      ifs >> core_id;
+
+      c2c[core_id].insert(i);
+
+      ifs.close();
+    }
+
+  return c2c;
+}
@@ -0,0 +1,33 @@
+#pragma once
+
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <pthread.h>
+#include <sched.h>
+
+#include <set>
+#include <unordered_map>
+#include <vector>
+
+
+class CPU
+{
+public:
+  typedef std::vector<pthread_t> ThreadIdVec;
+  typedef std::vector<int> CPUVec;
+  typedef std::unordered_map<int,int> CPU2CoreMap;
+  typedef std::unordered_map<int,std::set<int>> Core2CPUsMap;
+
+public:
+  static int count();
+  static int getaffinity(const pthread_t thread_id, cpu_set_t *cpuset);
+  static int setaffinity(const pthread_t thread_id, cpu_set_t *cpuset);
+  static int setaffinity(const pthread_t thread_id, const int cpu);
+  static int setaffinity(const pthread_t thread_id, const std::set<int> cpus);
+
+  static CPU::CPUVec cpus();
+  static CPU::CPU2CoreMap cpu2core();
+  static CPU::Core2CPUsMap core2cpus();
+};
@@ -0,0 +1,112 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "crc32b.h"
+
+static
+const
+crc32b_t CRC32BTABLE[256] =
+  {
+   0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F,
+   0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
+   0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, 0x1DB71064, 0x6AB020F2,
+   0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
+   0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
+   0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
+   0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, 0x35B5A8FA, 0x42B2986C,
+   0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
+   0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423,
+   0xCFBA9599, 0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
+   0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190, 0x01DB7106,
+   0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
+   0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D,
+   0x91646C97, 0xE6635C01, 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
+   0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
+   0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
+   0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7,
+   0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
+   0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA,
+   0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
+   0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81,
+   0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
+   0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, 0xE3630B12, 0x94643B84,
+   0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
+   0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
+   0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
+   0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, 0xD6D6A3E8, 0xA1D1937E,
+   0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
+   0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55,
+   0x316E8EEF, 0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
+   0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE, 0xB2BD0B28,
+   0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
+   0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F,
+   0x72076785, 0x05005713, 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
+   0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
+   0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
+   0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69,
+   0x616BFFD3, 0x166CCF45, 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
+   0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC,
+   0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
+   0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693,
+   0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
+   0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
+  };
+
+crc32b_t
+crc32b_start(void)
+{
+  return 0xFFFFFFFF;
+}
+
+crc32b_t
+crc32b_continue(const void     *buf_,
+                const crc32b_t  len_,
+                const crc32b_t  crc_)
+{
+  int i;
+  char *buf;
+  crc32b_t crc;
+
+  crc = crc_;
+  buf = (char*)buf_;
+  for(i = 0; i < len_; i++)
+    {
+      crc = (CRC32BTABLE[(crc ^ buf[i]) & 0xFFL] ^ (crc >> 8));
+    }
+
+  return crc;
+}
+
+crc32b_t
+crc32b_finish(const crc32b_t crc_)
+{
+  return (crc_ ^ 0xFFFFFFFF);
+}
+
+crc32b_t
+crc32b(const void     *buf_,
+       const crc32b_t  len_)
+{
+  crc32b_t crc;
+
+  crc = crc32b_start();
+  crc = crc32b_continue(buf_,len_,crc);
+  crc = crc32b_finish(crc);
+
+  return crc;
+}
@@ -0,0 +1,32 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#ifndef CRC32B_H_INCLUDED
+#define CRC32B_H_INCLUDED
+
+typedef unsigned int crc32b_t;
+
+crc32b_t crc32b_start(void);
+crc32b_t crc32b_continue(const void     *buf,
+                         const crc32b_t  len,
+                         const crc32b_t  crc);
+crc32b_t crc32b_finish(const crc32b_t crc);
+
+crc32b_t crc32b(const void *buf, crc32b_t len);
+
+#endif
@@ -0,0 +1,51 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "fuse_kernel.h"
+
+void debug_fuse_open_out(const uint64_t              unique,
+                         const struct fuse_open_out *arg,
+                         const uint64_t              argsize);
+void debug_fuse_init_in(const struct fuse_init_in *arg);
+void debug_fuse_init_out(const uint64_t              unique,
+                         const struct fuse_init_out *arg,
+                         const uint64_t              argsize);
+void debug_fuse_entry_out(const uint64_t               unique,
+                          const struct fuse_entry_out *arg,
+                          const uint64_t               argsize);
+void debug_fuse_attr_out(const uint64_t              unique,
+                         const struct fuse_attr_out *arg,
+                         const uint64_t              argsize);
+void debug_fuse_entry_open_out(const uint64_t               unique,
+                               const struct fuse_entry_out *earg,
+                               const struct fuse_open_out  *oarg);
+void debug_fuse_readlink(const uint64_t  unique,
+                         const char     *linkname);
+void debug_fuse_write_out(const uint64_t               unique,
+                          const struct fuse_write_out *arg);
+void debug_fuse_statfs_out(const uint64_t                unique,
+                           const struct fuse_statfs_out *arg);
+void debug_fuse_getxattr_out(const uint64_t                  unique,
+                             const struct fuse_getxattr_out *arg);
+void debug_fuse_lk_out(const uint64_t            unique,
+                       const struct fuse_lk_out *arg);
+void debug_fuse_bmap_out(const uint64_t              unique,
+                         const struct fuse_bmap_out *arg);
+void debug_fuse_in_header(const struct fuse_in_header *hdr);
@@ -0,0 +1,380 @@
+/*
+  ISC License
+
+  Copyright (c) 2021, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "kvec.h"
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#define ROUND_UP(N,S) ((((N) + (S) - 1) / (S)) * (S))
+
+typedef kvec_t(void*) slab_kvec_t;
+
+typedef struct mem_stack_t mem_stack_t;
+struct mem_stack_t
+{
+  mem_stack_t *next;
+};
+
+typedef struct fmp_t fmp_t;
+struct fmp_t
+{
+  mem_stack_t *objs;
+  slab_kvec_t  slabs;
+  uint64_t     avail_objs;
+  uint64_t     obj_size;
+  uint64_t     page_size;
+  uint64_t     slab_size;
+};
+
+static
+inline
+uint64_t
+fmp_page_size()
+{
+  return sysconf(_SC_PAGESIZE);
+}
+
+static
+inline
+void
+fmp_init(fmp_t          *fmp_,
+         const uint64_t  obj_size_,
+         const uint64_t  page_multiple_)
+{
+  kv_init(fmp_->slabs);
+  fmp_->objs       = NULL;
+  fmp_->avail_objs = 0;
+  fmp_->obj_size   = ROUND_UP(obj_size_,sizeof(void*));
+  fmp_->page_size  = fmp_page_size();
+  fmp_->slab_size  = (fmp_->page_size * page_multiple_);
+}
+
+static
+inline
+uint64_t
+fmp_slab_count(fmp_t *fmp_)
+{
+  return kv_size(fmp_->slabs);
+}
+
+static
+inline
+void*
+fmp_slab_alloc_posix_memalign(fmp_t *fmp_)
+{
+  int rv;
+  void *mem;
+  const size_t alignment = fmp_->page_size;
+  const size_t size      = fmp_->slab_size;
+
+  rv = posix_memalign(&mem,alignment,size);
+  if(rv != 0)
+    return NULL;
+
+  return NULL;
+}
+
+static
+inline
+void*
+fmp_slab_alloc_mmap(fmp_t *fmp_)
+{
+  void         *mem;
+  void         *address = NULL;
+  const size_t  length  = fmp_->slab_size;
+  const int     protect = PROT_READ|PROT_WRITE;
+  const int     flags   = MAP_PRIVATE|MAP_ANONYMOUS;
+  const int     filedes = -1;
+  const off_t   offset  = 0;
+
+  mem = mmap(address,length,protect,flags,filedes,offset);
+  if(mem == MAP_FAILED)
+    return NULL;
+
+  return mem;
+}
+
+static
+inline
+void
+fmp_slab_free_posix_memalign(fmp_t*  fmp_,
+                             void   *mem_)
+{
+  (void)fmp_;
+  free(mem_);
+}
+
+static
+inline
+void
+fmp_slab_free_mmap(fmp_t*  fmp_,
+                   void   *mem_)
+{
+  void   *addr   = mem_;
+  size_t  length = fmp_->slab_size;
+
+  (void)munmap(addr,length);
+}
+
+static
+inline
+int
+fmp_slab_alloc(fmp_t *fmp_)
+{
+  char *i;
+  void *mem;
+
+  mem = fmp_slab_alloc_mmap(fmp_);
+  if(mem == NULL)
+    return -ENOMEM;
+
+  kv_push(void*,fmp_->slabs,mem);
+
+  i = ((char*)mem + fmp_->slab_size - fmp_->obj_size);
+  while(i >= (char*)mem)
+    {
+      mem_stack_t *obj = (mem_stack_t*)i;
+
+      obj->next  = fmp_->objs;
+      fmp_->objs = obj;
+      fmp_->avail_objs++;
+
+      i -= fmp_->obj_size;
+    }
+
+  return 0;
+}
+
+static
+inline
+void*
+fmp_alloc(fmp_t *fmp_)
+{
+  void *rv;
+
+  if(fmp_->objs == NULL)
+    fmp_slab_alloc(fmp_);
+  if(fmp_->objs == NULL)
+    return NULL;
+
+  rv = fmp_->objs;
+
+  fmp_->objs = fmp_->objs->next;
+  fmp_->avail_objs--;
+
+  return rv;
+}
+
+static
+inline
+void*
+fmp_calloc(fmp_t *fmp_)
+{
+  void *obj;
+
+  obj = fmp_alloc(fmp_);
+  if(obj == NULL)
+    return NULL;
+
+  memset(obj,0,fmp_->obj_size);
+
+  return obj;
+}
+
+static
+inline
+void
+fmp_free(fmp_t *fmp_,
+         void  *obj_)
+{
+  mem_stack_t *obj = (mem_stack_t*)obj_;
+
+  obj->next  = fmp_->objs;
+  fmp_->objs = obj;
+  fmp_->avail_objs++;
+}
+
+static
+inline
+void
+fmp_clear(fmp_t *fmp_)
+{
+  while(kv_size(fmp_->slabs))
+    {
+      void *slab = kv_pop(fmp_->slabs);
+
+      fmp_slab_free_mmap(fmp_,slab);
+    }
+
+  fmp_->objs       = NULL;
+  fmp_->avail_objs = 0;
+}
+
+static
+inline
+void
+fmp_destroy(fmp_t *fmp_)
+{
+  fmp_clear(fmp_);
+  kv_destroy(fmp_->slabs);
+}
+
+static
+inline
+uint64_t
+fmp_avail_objs(fmp_t *fmp_)
+{
+  return fmp_->avail_objs;
+}
+
+static
+inline
+uint64_t
+fmp_objs_per_slab(fmp_t *fmp_)
+{
+  return (fmp_->slab_size / fmp_->obj_size);
+}
+
+static
+inline
+uint64_t
+fmp_objs_in_slab(fmp_t *fmp_,
+                 void  *slab_)
+{
+  char *slab;
+  uint64_t objs_per_slab;
+  uint64_t objs_in_slab;
+
+  slab          = (char*)slab_;
+  objs_in_slab  = 0;
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  for(mem_stack_t *stack = fmp_->objs; stack != NULL; stack = stack->next)
+    {
+      char *obj = (char*)stack;
+      if((obj >= slab) && (obj < (slab + fmp_->slab_size)))
+        objs_in_slab++;
+      if(objs_in_slab >= objs_per_slab)
+        break;
+    }
+
+  return objs_in_slab;
+}
+
+static
+inline
+void
+fmp_remove_objs_in_slab(fmp_t *fmp_,
+                        void  *slab_)
+{
+  char *slab;
+  uint64_t objs_per_slab;
+  uint64_t objs_in_slab;
+  mem_stack_t **p;
+
+  p             = &fmp_->objs;
+  slab          = (char*)slab_;
+  objs_in_slab  = 0;
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  while((*p) != NULL)
+    {
+      char *obj = (char*)*p;
+
+      if((obj >= slab) && (obj < (slab + fmp_->slab_size)))
+        {
+          objs_in_slab++;
+          *p = (*p)->next;
+          fmp_->avail_objs--;
+
+          if(objs_in_slab >= objs_per_slab)
+            break;
+          continue;
+        }
+
+      p = &(*p)->next;
+    }
+}
+
+static
+inline
+int
+fmp_gc_slab(fmp_t    *fmp_,
+            uint64_t  slab_idx_)
+{
+  char *slab;
+  uint64_t objs_in_slab;
+  uint64_t objs_per_slab;
+
+  slab_idx_ = (slab_idx_ % kv_size(fmp_->slabs));
+
+  slab = kv_A(fmp_->slabs,slab_idx_);
+
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  objs_in_slab  = fmp_objs_in_slab(fmp_,slab);
+  if(objs_in_slab != objs_per_slab)
+    return 0;
+
+  fmp_remove_objs_in_slab(fmp_,slab);
+  kv_delete(fmp_->slabs,slab_idx_);
+  fmp_slab_free_mmap(fmp_,slab);
+
+  return 1;
+}
+
+
+static
+inline
+int
+fmp_gc(fmp_t *fmp_)
+{
+  uint64_t slab_idx;
+
+  slab_idx = rand();
+
+  return fmp_gc_slab(fmp_,slab_idx);
+}
+
+static
+inline
+double
+fmp_slab_usage_ratio(fmp_t *fmp_)
+{
+  double avail_objs;
+  double objs_per_slab;
+  double nums_of_slabs;
+
+  avail_objs    = fmp_->avail_objs;
+  objs_per_slab = fmp_objs_per_slab(fmp_);
+  nums_of_slabs = kv_size(fmp_->slabs);
+
+  return (avail_objs / (objs_per_slab * nums_of_slabs));
+}
+
+static
+inline
+uint64_t
+fmp_total_allocated_memory(fmp_t *fmp_)
+{
+  return (fmp_->slab_size * kv_size(fmp_->slabs));
+}
@@ -0,0 +1,234 @@
+// Formatting library for C++ - dynamic format arguments
+//
+// 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_
+
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+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> const T& unwrap(const T& v) { return v; }
+template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
+  return static_cast<const T&>(v);
+}
+
+class dynamic_arg_list {
+  // 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 storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  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> const T& push(const Arg& arg) {
+    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
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ 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, Context>::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_type = 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>;
+
+  unsigned long long get_types() const {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  const basic_format_arg<Context>* data() const {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(detail::make_arg<Context>(arg));
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(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].value_.named_args = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  constexpr dynamic_format_arg_store() = default;
+
+  /**
+    \rst
+    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);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+    \rst
+    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"
+    \endrst
+  */
+  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_type<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_ = detail::dynamic_arg_list();
+  }
+
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
+  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);
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_
@@ -0,0 +1,651 @@
+// 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_MODULE_EXPORT_BEGIN
+
+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 {
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_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;
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type {
+  FMT_CONSTEXPR color_type() noexcept : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) noexcept : is_rgb(true), value{} {
+    value.rgb_color = static_cast<uint32_t>(rgb_color);
+  }
+  FMT_CONSTEXPR color_type(rgb rgb_color) noexcept : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+  }
+  FMT_CONSTEXPR color_type(terminal_color term_color) noexcept
+      : is_rgb(), value{} {
+    value.term_color = static_cast<uint8_t>(term_color);
+  }
+  bool is_rgb;
+  union color_union {
+    uint8_t term_color;
+    uint32_t rgb_color;
+  } value;
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+/** A text style consisting of foreground and background colors and emphasis. */
+class text_style {
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) noexcept
+      : set_foreground_color(), set_background_color(), ems(em) {}
+
+  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
+                                            const text_style& rhs) {
+    return lhs |= rhs;
+  }
+
+  FMT_CONSTEXPR bool has_foreground() const noexcept {
+    return set_foreground_color;
+  }
+  FMT_CONSTEXPR bool has_background() const noexcept {
+    return set_background_color;
+  }
+  FMT_CONSTEXPR bool has_emphasis() const noexcept {
+    return static_cast<uint8_t>(ems) != 0;
+  }
+  FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return foreground_color;
+  }
+  FMT_CONSTEXPR detail::color_type get_background() const noexcept {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return background_color;
+  }
+  FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return ems;
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(bool is_foreground,
+                           detail::color_type text_color) noexcept
+      : set_foreground_color(), set_background_color(), ems() {
+    if (is_foreground) {
+      foreground_color = text_color;
+      set_foreground_color = true;
+    } else {
+      background_color = text_color;
+      set_background_color = true;
+    }
+  }
+
+  friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;
+
+  friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;
+
+  detail::color_type foreground_color;
+  detail::color_type background_color;
+  bool set_foreground_color;
+  bool set_background_color;
+  emphasis ems;
+};
+
+/** Creates a text style from the foreground (text) color. */
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept {
+  return text_style(true, foreground);
+}
+
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
+  return text_style(false, background);
+}
+
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
+  return text_style(lhs) | rhs;
+}
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template <typename Char> struct ansi_color_escape {
+  FMT_CONSTEXPR ansi_color_escape(detail::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_rgb) {
+      bool is_background = esc == string_view("\x1b[48;2;");
+      uint32_t value = text_color.value.term_color;
+      // 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.rgb_color);
+    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 const Char* begin() const noexcept { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const noexcept {
+    return buffer + std::char_traits<Char>::length(buffer);
+  }
+
+ 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 bool has_emphasis(emphasis em, emphasis mask) noexcept {
+    return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
+  }
+};
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
+    detail::color_type foreground) noexcept {
+  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
+    detail::color_type background) noexcept {
+  return ansi_color_escape<Char>(background, "\x1b[48;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
+  return ansi_color_escape<Char>(em);
+}
+
+template <typename Char> inline void fputs(const Char* chars, FILE* stream) {
+  int result = std::fputs(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template <> inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) {
+  int result = std::fputws(chars, stream);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+template <typename Char> inline void reset_color(FILE* stream) {
+  fputs("\x1b[0m", stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) {
+  fputs(L"\x1b[0m", stream);
+}
+
+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 {
+  const T& value;
+  text_style style;
+};
+
+template <typename Char>
+void vformat_to(buffer<Char>& buf, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  bool has_style = false;
+  if (ts.has_emphasis()) {
+    has_style = true;
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    has_style = true;
+    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    has_style = true;
+    auto background = detail::make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  detail::vformat_to(buf, format_str, args, {});
+  if (has_style) detail::reset_color<Char>(buf);
+}
+
+FMT_END_DETAIL_NAMESPACE
+
+template <typename S, typename Char = char_t<S>>
+void vprint(std::FILE* f, const text_style& ts, const S& format,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, detail::to_string_view(format), args);
+  if (detail::is_utf8()) {
+    detail::print(f, basic_string_view<Char>(buf.begin(), buf.size()));
+  } else {
+    buf.push_back(Char(0));
+    detail::fputs(buf.data(), f);
+  }
+}
+
+/**
+  \rst
+  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);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_format_args<buffer_context<char_t<S>>>(args...));
+}
+
+/**
+  \rst
+  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);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
+  return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  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);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
+                                      const Args&... args) {
+  return fmt::vformat(ts, detail::to_string_view(format_str),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+/**
+  Formats a string with the given text_style and writes the output to ``out``.
+ */
+template <typename OutputIt, typename Char,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+OutputIt vformat_to(
+    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, ts, format_str, args);
+  return detail::get_iterator(buf);
+}
+
+/**
+  \rst
+  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);
+  \endrst
+*/
+template <typename OutputIt, typename S, typename... Args,
+          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
+              detail::is_string<S>::value>
+inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, ts, detail::to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<char_t<S>>>(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;
+    const auto& value = arg.value;
+    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 = std::copy(emphasis.begin(), emphasis.end(), out);
+    }
+    if (ts.has_foreground()) {
+      has_style = true;
+      auto foreground =
+          detail::make_foreground_color<Char>(ts.get_foreground());
+      out = std::copy(foreground.begin(), foreground.end(), out);
+    }
+    if (ts.has_background()) {
+      has_style = true;
+      auto background =
+          detail::make_background_color<Char>(ts.get_background());
+      out = std::copy(background.begin(), background.end(), out);
+    }
+    out = formatter<T, Char>::format(value, ctx);
+    if (has_style) {
+      auto reset_color = string_view("\x1b[0m");
+      out = std::copy(reset_color.begin(), reset_color.end(), out);
+    }
+    return out;
+  }
+};
+
+/**
+  \rst
+  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)));
+  \endrst
+ */
+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_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_COLOR_H_
@@ -0,0 +1,611 @@
+// 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_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename Char, typename InputIt>
+FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
+                                                counting_iterator it) {
+  return it + (end - begin);
+}
+
+template <typename OutputIt> class truncating_iterator_base {
+ protected:
+  OutputIt out_;
+  size_t limit_;
+  size_t count_ = 0;
+
+  truncating_iterator_base() : out_(), limit_(0) {}
+
+  truncating_iterator_base(OutputIt out, size_t limit)
+      : out_(out), limit_(limit) {}
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = typename std::iterator_traits<OutputIt>::value_type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  FMT_UNCHECKED_ITERATOR(truncating_iterator_base);
+
+  OutputIt base() const { return out_; }
+  size_t count() const { return count_; }
+};
+
+// An output iterator that truncates the output and counts the number of objects
+// written to it.
+template <typename OutputIt,
+          typename Enable = typename std::is_void<
+              typename std::iterator_traits<OutputIt>::value_type>::type>
+class truncating_iterator;
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::false_type>
+    : public truncating_iterator_base<OutputIt> {
+  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
+
+ public:
+  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
+
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  truncating_iterator& operator++() {
+    if (this->count_++ < this->limit_) ++this->out_;
+    return *this;
+  }
+
+  truncating_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  value_type& operator*() const {
+    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
+  }
+};
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::true_type>
+    : public truncating_iterator_base<OutputIt> {
+ public:
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  template <typename T> truncating_iterator& operator=(T val) {
+    if (this->count_++ < this->limit_) *this->out_++ = val;
+    return *this;
+  }
+
+  truncating_iterator& operator++() { return *this; }
+  truncating_iterator& operator++(int) { return *this; }
+  truncating_iterator& operator*() { return *this; }
+};
+
+// A compile-time string which is compiled into fast formatting code.
+class compiled_string {};
+
+template <typename S>
+struct is_compiled_string : std::is_base_of<compiled_string, S> {};
+
+/**
+  \rst
+  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);
+  \endrst
+ */
+#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#else
+#  define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string {
+  using char_type = Char;
+  explicit constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#endif
+
+template <typename T, typename... Tail>
+const T& first(const T& value, const Tail&...) {
+  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...);
+}
+
+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 {
+    return write<Char>(out, value);
+  }
+};
+
+// 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 {
+    return write<Char>(out, get_arg_checked<T, N>(args...));
+  }
+};
+
+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 format_str);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS !=
+                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+    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;
+};
+
+constexpr int 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_ref<Char> arg_id;
+
+  constexpr int operator()() {
+    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
+    return 0;
+  }
+  constexpr int operator()(int id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+  constexpr int operator()(basic_string_view<Char> id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+
+  constexpr void on_error(const char* message) {
+    FMT_THROW(format_error(message));
+  }
+};
+
+template <typename Char> struct parse_arg_id_result {
+  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_ref<Char>{}};
+  auto arg_id_end = parse_arg_id(begin, end, handler);
+  return parse_arg_id_result<Char>{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 format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  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>(),
+        format_str);
+  } 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},
+          format_str);
+    }
+  }
+}
+
+// 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 format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  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), format_str);
+    } 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>(
+          format_str);
+    } 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.arg_id.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.val.index;
+        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
+                                                 Args, arg_id_end_pos,
+                                                 arg_index, manual_indexing_id>(
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+        constexpr auto arg_index =
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+        if constexpr (arg_index != invalid_arg_index) {
+          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>(format_str);
+        } else {
+          if constexpr (c == '}') {
+            return parse_tail<Args, arg_id_end_pos + 1, ID>(
+                runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+                format_str);
+          } 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), format_str);
+  } 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),
+                                       format_str);
+    } else {
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
+    }
+  }
+}
+
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+  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>(
+            format_str);
+    return result;
+  }
+}
+#endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
+}  // namespace detail
+
+FMT_MODULE_EXPORT_BEGIN
+
+#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(detail::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(detail::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(detail::is_compiled_string<S>::value)>
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
+                                         const S& format_str, Args&&... args) {
+  auto it = fmt::format_to(detail::truncating_iterator<OutputIt>(out, n),
+                           format_str, std::forward<Args>(args)...);
+  return {it.base(), it.count()};
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR20 size_t formatted_size(const S& format_str,
+                                      const Args&... args) {
+  return fmt::format_to(detail::counting_iterator(), format_str, args...)
+      .count();
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  fmt::format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_ARGS
+inline namespace literals {
+template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
+  using char_t = remove_cvref_t<decltype(Str.data[0])>;
+  return detail::udl_compiled_string<char_t, sizeof(Str.data) / sizeof(char_t),
+                                     Str>();
+}
+}  // namespace literals
+#endif
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_
@@ -0,0 +1,478 @@
+// 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 <cerrno>
+#include <cstddef>
+#include <cstdio>
+#include <system_error>  // std::system_error
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#endif
+
+#include "format.h"
+
+#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_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_MODULE_EXPORT_BEGIN
+
+/**
+  \rst
+  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 to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+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) {}
+
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
+
+  /** Returns the pointer to a C string. */
+  const Char* c_str() const { return data_; }
+};
+
+using cstring_view = basic_cstring_view<char>;
+using wcstring_view = basic_cstring_view<wchar_t>;
+
+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(),
+                              basic_format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
+};
+
+#ifdef _WIN32
+FMT_API const std::error_category& system_category() noexcept;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+// A converter from UTF-16 to UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
+class utf16_to_utf8 {
+ private:
+  memory_buffer buffer_;
+
+ public:
+  utf16_to_utf8() {}
+  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
+  operator string_view() const { return string_view(&buffer_[0], size()); }
+  size_t size() const { return buffer_.size() - 1; }
+  const char* c_str() const { return &buffer_[0]; }
+  std::string str() const { return std::string(&buffer_[0], size()); }
+
+  // Performs conversion returning a system error code instead of
+  // throwing exception on conversion error. This method may still throw
+  // in case of memory allocation error.
+  FMT_API int convert(basic_string_view<wchar_t> s);
+};
+
+FMT_API void format_windows_error(buffer<char>& out, int error_code,
+                                  const char* message) noexcept;
+FMT_END_DETAIL_NAMESPACE
+
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
+                                         format_args args);
+
+/**
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
+
+ .. parsed-literal::
+   *<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);
+   }
+ \endrst
+*/
+template <typename... Args>
+std::system_error windows_error(int error_code, string_view message,
+                                const Args&... args) {
+  return vwindows_error(error_code, message, fmt::make_format_args(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 const std::error_category& system_category() noexcept {
+  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& format_str, Args&&... args) {
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+}
+#endif
+
+// A buffered file.
+class buffered_file {
+ private:
+  FILE* file_;
+
+  friend class file;
+
+  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.
+  buffered_file() noexcept : file_(nullptr) {}
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() noexcept;
+
+ public:
+  buffered_file(buffered_file&& other) noexcept : file_(other.file_) {
+    other.file_ = nullptr;
+  }
+
+  buffered_file& operator=(buffered_file&& other) {
+    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.
+  FILE* get() const noexcept { return file_; }
+
+  FMT_API int descriptor() const;
+
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args&... args) {
+    vprint(format_str, fmt::make_format_args(args...));
+  }
+};
+
+#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) {}
+
+ 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.
+  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;
+
+  file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+
+  // Move assignment is not noexcept because close may throw.
+  file& operator=(file&& other) {
+    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.
+  int descriptor() const noexcept { return fd_; }
+
+  // Closes the file.
+  void close();
+
+  // Returns the file size. The size has signed type for consistency with
+  // stat::st_size.
+  long long size() const;
+
+  // Attempts to read count bytes from the file into the specified buffer.
+  size_t read(void* buffer, size_t count);
+
+  // Attempts to write count bytes from the specified buffer to the file.
+  size_t write(const void* buffer, size_t count);
+
+  // Duplicates a file descriptor with the dup function and returns
+  // the duplicate as a file object.
+  static file dup(int fd);
+
+  // 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 pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  static void pipe(file& read_end, file& write_end);
+
+  // Creates a buffered_file object associated with this file and detaches
+  // this file object from the file.
+  buffered_file fdopen(const char* mode);
+};
+
+// Returns the memory page size.
+long getpagesize();
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+struct buffer_size {
+  buffer_size() = default;
+  size_t value = 0;
+  buffer_size operator=(size_t val) const {
+    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;
+
+  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
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+// Added {} below to work around default constructor error known to
+// occur in Xcode versions 7.2.1 and 8.2.1.
+constexpr detail::buffer_size buffer_size{};
+
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream final : private detail::buffer<char> {
+ private:
+  file file_;
+
+  void grow(size_t) override;
+
+  ostream(cstring_view path, const detail::ostream_params& params)
+      : file_(path, params.oflag) {
+    set(new char[params.buffer_size], params.buffer_size);
+  }
+
+ public:
+  ostream(ostream&& other)
+      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
+        file_(std::move(other.file_)) {
+    other.clear();
+    other.set(nullptr, 0);
+  }
+  ~ostream() {
+    flush();
+    delete[] data();
+  }
+
+  void flush() {
+    if (size() == 0) return;
+    file_.write(data(), size());
+    clear();
+  }
+
+  template <typename... T>
+  friend ostream output_file(cstring_view path, T... params);
+
+  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(detail::buffer_appender<char>(*this), fmt,
+               fmt::make_format_args(args...));
+  }
+};
+
+/**
+  \rst
+  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");
+  \endrst
+ */
+template <typename... T>
+inline ostream output_file(cstring_view path, T... params) {
+  return {path, detail::ostream_params(params...)};
+}
+#endif  // FMT_USE_FCNTL
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_OS_H_
@@ -0,0 +1,237 @@
+// 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_
+
+#include <fstream>
+#include <ostream>
+#if defined(_WIN32) && defined(__GLIBCXX__)
+#  include <ext/stdio_filebuf.h>
+#  include <ext/stdio_sync_filebuf.h>
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+#  include <__std_stream>
+#endif
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+template <typename OutputIt, typename Char> class basic_printf_context;
+
+namespace detail {
+
+// Checks if T has a user-defined operator<<.
+template <typename T, typename Char, typename Enable = void>
+class is_streamable {
+ private:
+  template <typename U>
+  static auto test(int)
+      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
+                              << std::declval<U>()) != 0>;
+
+  template <typename> static auto test(...) -> std::false_type;
+
+  using result = decltype(test<T>(0));
+
+ public:
+  is_streamable() = default;
+
+  static const bool value = result::value;
+};
+
+// Formatting of built-in types and arrays is intentionally disabled because
+// it's handled by standard (non-ostream) formatters.
+template <typename T, typename Char>
+struct is_streamable<
+    T, Char,
+    enable_if_t<
+        std::is_arithmetic<T>::value || std::is_array<T>::value ||
+        std::is_pointer<T>::value || std::is_same<T, char8_type>::value ||
+        std::is_convertible<T, fmt::basic_string_view<Char>>::value ||
+        std::is_same<T, std_string_view<Char>>::value ||
+        (std::is_convertible<T, int>::value && !std::is_enum<T>::value)>>
+    : std::false_type {};
+
+// Generate a unique explicit instantion in every translation unit using a tag
+// type in an anonymous namespace.
+namespace {
+struct file_access_tag {};
+}  // namespace
+template <class Tag, class BufType, FILE* BufType::*FileMemberPtr>
+class file_access {
+  friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
+};
+
+#if FMT_MSC_VERSION
+template class file_access<file_access_tag, std::filebuf,
+                           &std::filebuf::_Myfile>;
+auto get_file(std::filebuf&) -> FILE*;
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+template class file_access<file_access_tag, std::__stdoutbuf<char>,
+                           &std::__stdoutbuf<char>::__file_>;
+auto get_file(std::__stdoutbuf<char>&) -> FILE*;
+#endif
+
+inline bool write_ostream_unicode(std::ostream& os, fmt::string_view data) {
+#if FMT_MSC_VERSION
+  if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#elif defined(_WIN32) && defined(__GLIBCXX__)
+  auto* rdbuf = os.rdbuf();
+  FILE* c_file;
+  if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
+    c_file = fbuf->file();
+  else
+    return false;
+  if (c_file) return write_console(c_file, data);
+#elif defined(_WIN32) && defined(_LIBCPP_VERSION)
+  if (auto* buf = dynamic_cast<std::__stdoutbuf<char>*>(os.rdbuf()))
+    if (FILE* f = get_file(*buf)) return write_console(f, data);
+#else
+  ignore_unused(os, data);
+#endif
+  return false;
+}
+inline bool write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) {
+  return false;
+}
+
+// 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 = std::make_unsigned<std::streamsize>::type;
+  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 Char, typename T>
+void format_value(buffer<Char>& buf, const T& value,
+                  locale_ref loc = locale_ref()) {
+  auto&& format_buf = formatbuf<std::basic_streambuf<Char>>(buf);
+  auto&& output = std::basic_ostream<Char>(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  if (loc) output.imbue(loc.get<std::locale>());
+#endif
+  output << value;
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+}
+
+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 OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx) const
+      -> OutputIt {
+    auto buffer = basic_memory_buffer<Char>();
+    format_value(buffer, value, ctx.locale());
+    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 OutputIt>
+  auto format(detail::streamed_view<T> view,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
+    return basic_ostream_formatter<Char>::format(view.value, ctx);
+  }
+};
+
+/**
+  \rst
+  Returns a view that formats `value` via an ostream ``operator<<``.
+
+  **Example**::
+
+    fmt::print("Current thread id: {}\n",
+               fmt::streamed(std::this_thread::get_id()));
+  \endrst
+ */
+template <typename T>
+auto streamed(const T& value) -> detail::streamed_view<T> {
+  return {value};
+}
+
+namespace detail {
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : basic_ostream_formatter<Char> {
+  using basic_ostream_formatter<Char>::format;
+};
+
+inline void vprint_directly(std::ostream& os, string_view format_str,
+                            format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, format_str, args);
+  detail::write_buffer(os, buffer);
+}
+
+}  // namespace detail
+
+FMT_MODULE_EXPORT template <typename Char>
+void vprint(std::basic_ostream<Char>& os,
+            basic_string_view<type_identity_t<Char>> format_str,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  auto buffer = basic_memory_buffer<Char>();
+  detail::vformat_to(buffer, format_str, args);
+  if (detail::write_ostream_unicode(os, {buffer.data(), buffer.size()})) return;
+  detail::write_buffer(os, buffer);
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+FMT_MODULE_EXPORT template <typename... T>
+void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  const auto& vargs = fmt::make_format_args(args...);
+  if (detail::is_utf8())
+    vprint(os, fmt, vargs);
+  else
+    detail::vprint_directly(os, fmt, vargs);
+}
+
+FMT_MODULE_EXPORT
+template <typename... Args>
+void print(std::wostream& os,
+           basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+           Args&&... args) {
+  vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
+}
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_
@@ -0,0 +1,640 @@
+// Formatting library for C++ - legacy printf implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_PRINTF_H_
+#define FMT_PRINTF_H_
+
+#include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+template <typename T> struct printf_formatter { printf_formatter() = delete; };
+
+template <typename Char>
+class basic_printf_parse_context : public basic_format_parse_context<Char> {
+  using basic_format_parse_context<Char>::basic_format_parse_context;
+};
+
+template <typename OutputIt, typename Char> class basic_printf_context {
+ private:
+  OutputIt out_;
+  basic_format_args<basic_printf_context> args_;
+
+ public:
+  using char_type = Char;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = basic_printf_parse_context<Char>;
+  template <typename T> using formatter_type = printf_formatter<T>;
+
+  /**
+    \rst
+    Constructs a ``printf_context`` object. References to the arguments are
+    stored in the context object so make sure they have appropriate lifetimes.
+    \endrst
+   */
+  basic_printf_context(OutputIt out,
+                       basic_format_args<basic_printf_context> args)
+      : out_(out), args_(args) {}
+
+  OutputIt out() { return out_; }
+  void advance_to(OutputIt it) { out_ = it; }
+
+  detail::locale_ref locale() { return {}; }
+
+  format_arg arg(int id) const { return args_.get(id); }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    detail::error_handler().on_error(message);
+  }
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// Checks if a value fits in int - used to avoid warnings about comparing
+// signed and unsigned integers.
+template <bool IsSigned> struct int_checker {
+  template <typename T> static bool fits_in_int(T value) {
+    unsigned max = max_value<int>();
+    return value <= max;
+  }
+  static bool fits_in_int(bool) { return true; }
+};
+
+template <> struct int_checker<true> {
+  template <typename T> static bool fits_in_int(T value) {
+    return value >= (std::numeric_limits<int>::min)() &&
+           value <= max_value<int>();
+  }
+  static bool fits_in_int(int) { return true; }
+};
+
+class printf_precision_handler {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  int operator()(T value) {
+    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+      FMT_THROW(format_error("number is too big"));
+    return (std::max)(static_cast<int>(value), 0);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  int operator()(T) {
+    FMT_THROW(format_error("precision is not integer"));
+    return 0;
+  }
+};
+
+// An argument visitor that returns true iff arg is a zero integer.
+class is_zero_int {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  bool operator()(T value) {
+    return value == 0;
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  bool operator()(T) {
+    return false;
+  }
+};
+
+template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
+
+template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+
+template <typename T, typename Context> class arg_converter {
+ private:
+  using char_type = typename Context::char_type;
+
+  basic_format_arg<Context>& arg_;
+  char_type type_;
+
+ public:
+  arg_converter(basic_format_arg<Context>& arg, char_type type)
+      : arg_(arg), type_(type) {}
+
+  void operator()(bool value) {
+    if (type_ != 's') operator()<bool>(value);
+  }
+
+  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
+  void operator()(U value) {
+    bool is_signed = type_ == 'd' || type_ == 'i';
+    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+    if (const_check(sizeof(target_type) <= sizeof(int))) {
+      // Extra casts are used to silence warnings.
+      if (is_signed) {
+        arg_ = detail::make_arg<Context>(
+            static_cast<int>(static_cast<target_type>(value)));
+      } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        arg_ = detail::make_arg<Context>(
+            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+      }
+    } else {
+      if (is_signed) {
+        // glibc's printf doesn't sign extend arguments of smaller types:
+        //   std::printf("%lld", -42);  // prints "4294967254"
+        // but we don't have to do the same because it's a UB.
+        arg_ = detail::make_arg<Context>(static_cast<long long>(value));
+      } else {
+        arg_ = detail::make_arg<Context>(
+            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
+    }
+  }
+
+  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+  void operator()(U) {}  // No conversion needed for non-integral types.
+};
+
+// Converts an integer argument to T for printf, if T is an integral type.
+// If T is void, the argument is converted to corresponding signed or unsigned
+// type depending on the type specifier: 'd' and 'i' - signed, other -
+// unsigned).
+template <typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context>& arg, Char type) {
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+}
+
+// Converts an integer argument to char for printf.
+template <typename Context> class char_converter {
+ private:
+  basic_format_arg<Context>& arg_;
+
+ public:
+  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  void operator()(T value) {
+    arg_ = detail::make_arg<Context>(
+        static_cast<typename Context::char_type>(value));
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  void operator()(T) {}  // No conversion needed for non-integral types.
+};
+
+// An argument visitor that return a pointer to a C string if argument is a
+// string or null otherwise.
+template <typename Char> struct get_cstring {
+  template <typename T> const Char* operator()(T) { return nullptr; }
+  const Char* operator()(const Char* s) { return s; }
+};
+
+// Checks if an argument is a valid printf width specifier and sets
+// left alignment if it is negative.
+template <typename Char> class printf_width_handler {
+ private:
+  using format_specs = basic_format_specs<Char>;
+
+  format_specs& specs_;
+
+ public:
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  unsigned operator()(T value) {
+    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
+    if (detail::is_negative(value)) {
+      specs_.align = align::left;
+      width = 0 - width;
+    }
+    unsigned int_max = max_value<int>();
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
+    return static_cast<unsigned>(width);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  unsigned operator()(T) {
+    FMT_THROW(format_error("width is not integer"));
+    return 0;
+  }
+};
+
+// The ``printf`` argument formatter.
+template <typename OutputIt, typename Char>
+class printf_arg_formatter : public arg_formatter<Char> {
+ private:
+  using base = arg_formatter<Char>;
+  using context_type = basic_printf_context<OutputIt, Char>;
+  using format_specs = basic_format_specs<Char>;
+
+  context_type& context_;
+
+  OutputIt write_null_pointer(bool is_string = false) {
+    auto s = this->specs;
+    s.type = presentation_type::none;
+    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
+  }
+
+ public:
+  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
+      : base{iter, s, locale_ref()}, context_(ctx) {}
+
+  OutputIt operator()(monostate value) { return base::operator()(value); }
+
+  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
+  OutputIt operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and Char so use
+    // std::is_same instead.
+    if (std::is_same<T, Char>::value) {
+      format_specs fmt_specs = this->specs;
+      if (fmt_specs.type != presentation_type::none &&
+          fmt_specs.type != presentation_type::chr) {
+        return (*this)(static_cast<int>(value));
+      }
+      fmt_specs.sign = sign::none;
+      fmt_specs.alt = false;
+      fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
+      // align::numeric needs to be overwritten here since the '0' flag is
+      // ignored for non-numeric types
+      if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
+        fmt_specs.align = align::right;
+      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
+    }
+    return base::operator()(value);
+  }
+
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  OutputIt operator()(T value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a null-terminated C string. */
+  OutputIt operator()(const char* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
+  }
+
+  /** Formats a null-terminated wide C string. */
+  OutputIt operator()(const wchar_t* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != presentation_type::pointer);
+  }
+
+  OutputIt operator()(basic_string_view<Char> value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a pointer. */
+  OutputIt operator()(const void* value) {
+    return value ? base::operator()(value) : write_null_pointer();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
+    auto parse_ctx =
+        basic_printf_parse_context<Char>(basic_string_view<Char>());
+    handle.format(parse_ctx, context_);
+    return this->out;
+  }
+};
+
+template <typename Char>
+void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
+                 const Char* end) {
+  for (; it != end; ++it) {
+    switch (*it) {
+    case '-':
+      specs.align = align::left;
+      break;
+    case '+':
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      if (specs.sign != sign::plus) {
+        specs.sign = sign::space;
+      }
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
+    }
+  }
+}
+
+template <typename Char, typename GetArg>
+int parse_header(const Char*& it, const Char* end,
+                 basic_format_specs<Char>& specs, GetArg get_arg) {
+  int arg_index = -1;
+  Char c = *it;
+  if (c >= '0' && c <= '9') {
+    // Parse an argument index (if followed by '$') or a width possibly
+    // preceded with '0' flag(s).
+    int value = parse_nonnegative_int(it, end, -1);
+    if (it != end && *it == '$') {  // value is an argument index
+      ++it;
+      arg_index = value != -1 ? value : max_value<int>();
+    } else {
+      if (c == '0') specs.fill[0] = '0';
+      if (value != 0) {
+        // Nonzero value means that we parsed width and don't need to
+        // parse it or flags again, so return now.
+        if (value == -1) FMT_THROW(format_error("number is too big"));
+        specs.width = value;
+        return arg_index;
+      }
+    }
+  }
+  parse_flags(specs, it, end);
+  // Parse width.
+  if (it != end) {
+    if (*it >= '0' && *it <= '9') {
+      specs.width = parse_nonnegative_int(it, end, -1);
+      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
+    } else if (*it == '*') {
+      ++it;
+      specs.width = static_cast<int>(visit_format_arg(
+          detail::printf_width_handler<Char>(specs), get_arg(-1)));
+    }
+  }
+  return arg_index;
+}
+
+template <typename Char, typename Context>
+void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
+             basic_format_args<Context> args) {
+  using OutputIt = buffer_appender<Char>;
+  auto out = OutputIt(buf);
+  auto context = basic_printf_context<OutputIt, Char>(out, args);
+  auto parse_ctx = basic_printf_parse_context<Char>(format);
+
+  // Returns the argument with specified index or, if arg_index is -1, the next
+  // argument.
+  auto get_arg = [&](int arg_index) {
+    if (arg_index < 0)
+      arg_index = parse_ctx.next_arg_id();
+    else
+      parse_ctx.check_arg_id(--arg_index);
+    return detail::get_arg(context, arg_index);
+  };
+
+  const Char* start = parse_ctx.begin();
+  const Char* end = parse_ctx.end();
+  auto it = start;
+  while (it != end) {
+    if (!detail::find<false, Char>(it, end, '%', it)) {
+      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
+      break;
+    }
+    Char c = *it++;
+    if (it != end && *it == c) {
+      out = detail::write(
+          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
+      start = ++it;
+      continue;
+    }
+    out = detail::write(out, basic_string_view<Char>(
+                                 start, detail::to_unsigned(it - 1 - start)));
+
+    basic_format_specs<Char> specs;
+    specs.align = align::right;
+
+    // Parse argument index, flags and width.
+    int arg_index = parse_header(it, end, specs, get_arg);
+    if (arg_index == 0) parse_ctx.on_error("argument not found");
+
+    // Parse precision.
+    if (it != end && *it == '.') {
+      ++it;
+      c = it != end ? *it : 0;
+      if ('0' <= c && c <= '9') {
+        specs.precision = parse_nonnegative_int(it, end, 0);
+      } else if (c == '*') {
+        ++it;
+        specs.precision = static_cast<int>(
+            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
+      } else {
+        specs.precision = 0;
+      }
+    }
+
+    auto arg = get_arg(arg_index);
+    // For d, i, o, u, x, and X conversion specifiers, if a precision is
+    // specified, the '0' flag is ignored
+    if (specs.precision >= 0 && arg.is_integral())
+      specs.fill[0] =
+          ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
+    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
+      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
+      auto str_end = str + specs.precision;
+      auto nul = std::find(str, str_end, Char());
+      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
+          basic_string_view<Char>(
+              str, detail::to_unsigned(nul != str_end ? nul - str
+                                                      : specs.precision)));
+    }
+    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+      specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic() && specs.align != align::left)
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+                              // flag is also present.
+    }
+
+    // Parse length and convert the argument to the required type.
+    c = it != end ? *it++ : 0;
+    Char t = it != end ? *it : 0;
+    using detail::convert_arg;
+    switch (c) {
+    case 'h':
+      if (t == 'h') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<signed char>(arg, t);
+      } else {
+        convert_arg<short>(arg, t);
+      }
+      break;
+    case 'l':
+      if (t == 'l') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<long long>(arg, t);
+      } else {
+        convert_arg<long>(arg, t);
+      }
+      break;
+    case 'j':
+      convert_arg<intmax_t>(arg, t);
+      break;
+    case 'z':
+      convert_arg<size_t>(arg, t);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, t);
+      break;
+    case 'L':
+      // printf produces garbage when 'L' is omitted for long double, no
+      // need to do the same.
+      break;
+    default:
+      --it;
+      convert_arg<void>(arg, c);
+    }
+
+    // Parse type.
+    if (it == end) FMT_THROW(format_error("invalid format string"));
+    char type = static_cast<char>(*it++);
+    if (arg.is_integral()) {
+      // Normalize type.
+      switch (type) {
+      case 'i':
+      case 'u':
+        type = 'd';
+        break;
+      case 'c':
+        visit_format_arg(
+            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
+            arg);
+        break;
+      }
+    }
+    specs.type = parse_presentation_type(type);
+    if (specs.type == presentation_type::none)
+      parse_ctx.on_error("invalid type specifier");
+
+    start = it;
+
+    // Format argument.
+    out = visit_format_arg(
+        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
+  }
+  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+}
+FMT_END_DETAIL_NAMESPACE
+
+template <typename Char>
+using basic_printf_context_t =
+    basic_printf_context<detail::buffer_appender<Char>, Char>;
+
+using printf_context = basic_printf_context_t<char>;
+using wprintf_context = basic_printf_context_t<wchar_t>;
+
+using printf_args = basic_format_args<printf_context>;
+using wprintf_args = basic_format_args<wprintf_context>;
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template <typename... T>
+inline auto make_printf_args(const T&... args)
+    -> format_arg_store<printf_context, T...> {
+  return {args...};
+}
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::wprintf_args`.
+  \endrst
+ */
+template <typename... T>
+inline auto make_wprintf_args(const T&... args)
+    -> format_arg_store<wprintf_context, T...> {
+  return {args...};
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vsprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, detail::to_string_view(fmt), args);
+  return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename S, typename... T,
+          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
+  using context = basic_printf_context_t<Char>;
+  return vsprintf(detail::to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vfprintf(
+    std::FILE* f, const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, detail::to_string_view(fmt), args);
+  size_t size = buffer.size();
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
+             ? -1
+             : static_cast<int>(size);
+}
+
+/**
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename S, typename... T, typename Char = char_t<S>>
+inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
+  using context = basic_printf_context_t<Char>;
+  return vfprintf(f, detail::to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  return vfprintf(stdout, detail::to_string_view(fmt), args);
+}
+
+/**
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
+inline auto printf(const S& fmt, const T&... args) -> int {
+  return vprintf(
+      detail::to_string_view(fmt),
+      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_PRINTF_H_
@@ -0,0 +1,722 @@
+// Formatting library for C++ - experimental range support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifndef FMT_RANGES_H_
+#define FMT_RANGES_H_
+
+#include <initializer_list>
+#include <tuple>
+#include <type_traits>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename RangeT, typename OutputIterator>
+OutputIterator copy(const RangeT& range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(const char* str, OutputIterator out) {
+  while (*str) *out++ = *str++;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(wchar_t ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+// Returns true if T has a std::string-like interface, like std::string_view.
+template <typename T> class is_std_string_like {
+  template <typename U>
+  static auto check(U* p)
+      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+  template <typename> static void check(...);
+
+ public:
+  static constexpr const bool value =
+      is_string<T>::value ||
+      std::is_convertible<T, std_string_view<char>>::value ||
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template <typename Char>
+struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
+
+template <typename T> class is_map {
+  template <typename U> static auto check(U*) -> typename U::mapped_type;
+  template <typename> static void check(...);
+
+ public:
+#ifdef FMT_FORMAT_MAP_AS_LIST
+  static constexpr const bool value = false;
+#else
+  static constexpr const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+#endif
+};
+
+template <typename T> class is_set {
+  template <typename U> static auto check(U*) -> typename U::key_type;
+  template <typename> static void check(...);
+
+ public:
+#ifdef FMT_FORMAT_SET_AS_LIST
+  static constexpr const bool value = false;
+#else
+  static constexpr const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value && !is_map<T>::value;
+#endif
+};
+
+template <typename... Ts> struct conditional_helper {};
+
+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION > 1800
+
+#  define FMT_DECLTYPE_RETURN(val)  \
+    ->decltype(val) { return val; } \
+    static_assert(                  \
+        true, "")  // This makes it so that a semicolon is required after the
+                   // macro, which helps clang-format handle the formatting.
+
+// C array overload
+template <typename T, std::size_t N>
+auto range_begin(const T (&arr)[N]) -> const T* {
+  return arr;
+}
+template <typename T, std::size_t N>
+auto range_end(const T (&arr)[N]) -> const T* {
+  return arr + N;
+}
+
+template <typename T, typename Enable = void>
+struct has_member_fn_begin_end_t : std::false_type {};
+
+template <typename T>
+struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
+                                           decltype(std::declval<T>().end())>>
+    : std::true_type {};
+
+// Member function overload
+template <typename T>
+auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
+template <typename T>
+auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
+
+// ADL overload. Only participates in overload resolution if member functions
+// are not found.
+template <typename T>
+auto range_begin(T&& rng)
+    -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                   decltype(begin(static_cast<T&&>(rng)))> {
+  return begin(static_cast<T&&>(rng));
+}
+template <typename T>
+auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                                       decltype(end(static_cast<T&&>(rng)))> {
+  return end(static_cast<T&&>(rng));
+}
+
+template <typename T, typename Enable = void>
+struct has_const_begin_end : std::false_type {};
+template <typename T, typename Enable = void>
+struct has_mutable_begin_end : std::false_type {};
+
+template <typename T>
+struct has_const_begin_end<
+    T,
+    void_t<
+        decltype(detail::range_begin(std::declval<const remove_cvref_t<T>&>())),
+        decltype(detail::range_end(std::declval<const remove_cvref_t<T>&>()))>>
+    : std::true_type {};
+
+template <typename T>
+struct has_mutable_begin_end<
+    T, void_t<decltype(detail::range_begin(std::declval<T>())),
+              decltype(detail::range_end(std::declval<T>())),
+              enable_if_t<std::is_copy_constructible<T>::value>>>
+    : std::true_type {};
+
+template <typename T>
+struct is_range_<T, void>
+    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
+                                    has_mutable_begin_end<T>::value)> {};
+#  undef FMT_DECLTYPE_RETURN
+#endif
+
+// tuple_size and tuple_element check.
+template <typename T> class is_tuple_like_ {
+  template <typename U>
+  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
+  template <typename> static void check(...);
+
+ public:
+  static constexpr const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+// Check for integer_sequence
+#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VERSION >= 1900
+template <typename T, T... N>
+using integer_sequence = std::integer_sequence<T, N...>;
+template <size_t... N> using index_sequence = std::index_sequence<N...>;
+template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
+#else
+template <typename T, T... N> struct integer_sequence {
+  using value_type = T;
+
+  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
+};
+
+template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
+
+template <typename T, size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
+template <typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+#endif
+
+template <typename T>
+using tuple_index_sequence = make_index_sequence<std::tuple_size<T>::value>;
+
+template <typename T, typename C, bool = is_tuple_like_<T>::value>
+class is_tuple_formattable_ {
+ public:
+  static constexpr const bool value = false;
+};
+template <typename T, typename C> class is_tuple_formattable_<T, C, true> {
+  template <std::size_t... I>
+  static std::true_type check2(index_sequence<I...>,
+                               integer_sequence<bool, (I == I)...>);
+  static std::false_type check2(...);
+  template <std::size_t... I>
+  static decltype(check2(
+      index_sequence<I...>{},
+      integer_sequence<
+          bool, (is_formattable<typename std::tuple_element<I, T>::type,
+                                C>::value)...>{})) check(index_sequence<I...>);
+
+ public:
+  static constexpr const bool value =
+      decltype(check(tuple_index_sequence<T>{}))::value;
+};
+
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) noexcept {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
+}
+
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
+    T const&) {
+  return {};
+}
+
+template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+#if FMT_MSC_VERSION && FMT_MSC_VERSION < 1920
+// Older MSVC doesn't get the reference type correctly for arrays.
+template <typename R> struct range_reference_type_impl {
+  using type = decltype(*detail::range_begin(std::declval<R&>()));
+};
+
+template <typename T, std::size_t N> struct range_reference_type_impl<T[N]> {
+  using type = T&;
+};
+
+template <typename T>
+using range_reference_type = typename range_reference_type_impl<T>::type;
+#else
+template <typename Range>
+using range_reference_type =
+    decltype(*detail::range_begin(std::declval<Range&>()));
+#endif
+
+// We don't use the Range's value_type for anything, but we do need the Range's
+// reference type, with cv-ref stripped.
+template <typename Range>
+using uncvref_type = remove_cvref_t<range_reference_type<Range>>;
+
+template <typename Range>
+using uncvref_first_type =
+    remove_cvref_t<decltype(std::declval<range_reference_type<Range>>().first)>;
+
+template <typename Range>
+using uncvref_second_type = remove_cvref_t<
+    decltype(std::declval<range_reference_type<Range>>().second)>;
+
+template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
+  *out++ = ',';
+  *out++ = ' ';
+  return out;
+}
+
+template <typename Char, typename OutputIt>
+auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
+  return write_escaped_string(out, str);
+}
+
+template <typename Char, typename OutputIt, typename T,
+          FMT_ENABLE_IF(std::is_convertible<T, std_string_view<char>>::value)>
+inline auto write_range_entry(OutputIt out, const T& str) -> OutputIt {
+  auto sv = std_string_view<Char>(str);
+  return write_range_entry<Char>(out, basic_string_view<Char>(sv));
+}
+
+template <typename Char, typename OutputIt, typename Arg,
+          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg v) {
+  return write_escaped_char(out, v);
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
+                  !std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  return write<Char>(out, v);
+}
+
+}  // namespace detail
+
+template <typename T> struct is_tuple_like {
+  static constexpr const bool value =
+      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
+};
+
+template <typename T, typename C> struct is_tuple_formattable {
+  static constexpr const bool value =
+      detail::is_tuple_formattable_<T, C>::value;
+};
+
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char,
+                 enable_if_t<fmt::is_tuple_like<TupleT>::value &&
+                             fmt::is_tuple_formattable<TupleT, Char>::value>> {
+ private:
+  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
+  basic_string_view<Char> opening_bracket_ =
+      detail::string_literal<Char, '('>{};
+  basic_string_view<Char> closing_bracket_ =
+      detail::string_literal<Char, ')'>{};
+
+  // C++11 generic lambda for format().
+  template <typename FormatContext> struct format_each {
+    template <typename T> void operator()(const T& v) {
+      if (i > 0) out = detail::copy_str<Char>(separator, out);
+      out = detail::write_range_entry<Char>(out, v);
+      ++i;
+    }
+    int i;
+    typename FormatContext::iterator& out;
+    basic_string_view<Char> separator;
+  };
+
+ public:
+  FMT_CONSTEXPR formatter() {}
+
+  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
+    separator_ = sep;
+  }
+
+  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
+                                  basic_string_view<Char> close) {
+    opening_bracket_ = open;
+    closing_bracket_ = close;
+  }
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT& values, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::copy_str<Char>(opening_bracket_, out);
+    detail::for_each(values, format_each<FormatContext>{0, out, separator_});
+    out = detail::copy_str<Char>(closing_bracket_, out);
+    return out;
+  }
+};
+
+template <typename T, typename Char> struct is_range {
+  static constexpr const bool value =
+      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_convertible<T, detail::std_string_view<Char>>::value;
+};
+
+namespace detail {
+template <typename Context> struct range_mapper {
+  using mapper = arg_mapper<Context>;
+
+  template <typename T,
+            FMT_ENABLE_IF(has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value) -> T&& {
+    return static_cast<T&&>(value);
+  }
+  template <typename T,
+            FMT_ENABLE_IF(!has_formatter<remove_cvref_t<T>, Context>::value)>
+  static auto map(T&& value)
+      -> decltype(mapper().map(static_cast<T&&>(value))) {
+    return mapper().map(static_cast<T&&>(value));
+  }
+};
+
+template <typename Char, typename Element>
+using range_formatter_type = conditional_t<
+    is_formattable<Element, Char>::value,
+    formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
+                  std::declval<Element>()))>,
+              Char>,
+    fallback_formatter<Element, Char>>;
+
+template <typename R>
+using maybe_const_range =
+    conditional_t<has_const_begin_end<R>::value, const R, R>;
+
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+template <typename R, typename Char>
+struct is_formattable_delayed
+    : disjunction<
+          is_formattable<uncvref_type<maybe_const_range<R>>, Char>,
+          has_fallback_formatter<uncvref_type<maybe_const_range<R>>, Char>> {};
+#endif
+
+}  // namespace detail
+
+template <typename T, typename Char, typename Enable = void>
+struct range_formatter;
+
+template <typename T, typename Char>
+struct range_formatter<
+    T, Char,
+    enable_if_t<conjunction<
+        std::is_same<T, remove_cvref_t<T>>,
+        disjunction<is_formattable<T, Char>,
+                    detail::has_fallback_formatter<T, Char>>>::value>> {
+ private:
+  detail::range_formatter_type<Char, T> underlying_;
+  bool custom_specs_ = false;
+  basic_string_view<Char> separator_ = detail::string_literal<Char, ',', ' '>{};
+  basic_string_view<Char> opening_bracket_ =
+      detail::string_literal<Char, '['>{};
+  basic_string_view<Char> closing_bracket_ =
+      detail::string_literal<Char, ']'>{};
+
+  template <class U>
+  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, int)
+      -> decltype(u.set_debug_format()) {
+    u.set_debug_format();
+  }
+
+  template <class U>
+  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
+
+  FMT_CONSTEXPR void maybe_set_debug_format() {
+    maybe_set_debug_format(underlying_, 0);
+  }
+
+ public:
+  FMT_CONSTEXPR range_formatter() {}
+
+  FMT_CONSTEXPR auto underlying() -> detail::range_formatter_type<Char, T>& {
+    return underlying_;
+  }
+
+  FMT_CONSTEXPR void set_separator(basic_string_view<Char> sep) {
+    separator_ = sep;
+  }
+
+  FMT_CONSTEXPR void set_brackets(basic_string_view<Char> open,
+                                  basic_string_view<Char> close) {
+    opening_bracket_ = open;
+    closing_bracket_ = close;
+  }
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+    if (it == end || *it == '}') {
+      maybe_set_debug_format();
+      return it;
+    }
+
+    if (*it == 'n') {
+      set_brackets({}, {});
+      ++it;
+    }
+
+    if (*it == '}') {
+      maybe_set_debug_format();
+      return it;
+    }
+
+    if (*it != ':')
+      FMT_THROW(format_error("no other top-level range formatters supported"));
+
+    custom_specs_ = true;
+    ++it;
+    ctx.advance_to(it);
+    return underlying_.parse(ctx);
+  }
+
+  template <typename R, class FormatContext>
+  auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
+    detail::range_mapper<buffer_context<Char>> mapper;
+    auto out = ctx.out();
+    out = detail::copy_str<Char>(opening_bracket_, out);
+    int i = 0;
+    auto it = detail::range_begin(range);
+    auto end = detail::range_end(range);
+    for (; it != end; ++it) {
+      if (i > 0) out = detail::copy_str<Char>(separator_, out);
+      ;
+      ctx.advance_to(out);
+      out = underlying_.format(mapper.map(*it), ctx);
+      ++i;
+    }
+    out = detail::copy_str<Char>(closing_bracket_, out);
+    return out;
+  }
+};
+
+enum class range_format { disabled, map, set, sequence, string, debug_string };
+
+namespace detail {
+template <typename T> struct range_format_kind_ {
+  static constexpr auto value = std::is_same<range_reference_type<T>, T>::value
+                                    ? range_format::disabled
+                                : is_map<T>::value ? range_format::map
+                                : is_set<T>::value ? range_format::set
+                                                   : range_format::sequence;
+};
+
+template <range_format K, typename R, typename Char, typename Enable = void>
+struct range_default_formatter;
+
+template <range_format K>
+using range_format_constant = std::integral_constant<range_format, K>;
+
+template <range_format K, typename R, typename Char>
+struct range_default_formatter<
+    K, R, Char,
+    enable_if_t<(K == range_format::sequence || K == range_format::map ||
+                 K == range_format::set)>> {
+  using range_type = detail::maybe_const_range<R>;
+  range_formatter<detail::uncvref_type<range_type>, Char> underlying_;
+
+  FMT_CONSTEXPR range_default_formatter() { init(range_format_constant<K>()); }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::set>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
+  }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::map>) {
+    underlying_.set_brackets(detail::string_literal<Char, '{'>{},
+                             detail::string_literal<Char, '}'>{});
+    underlying_.underlying().set_brackets({}, {});
+    underlying_.underlying().set_separator(
+        detail::string_literal<Char, ':', ' '>{});
+  }
+
+  FMT_CONSTEXPR void init(range_format_constant<range_format::sequence>) {}
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return underlying_.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  auto format(range_type& range, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return underlying_.format(range, ctx);
+  }
+};
+}  // namespace detail
+
+template <typename T, typename Char, typename Enable = void>
+struct range_format_kind
+    : conditional_t<
+          is_range<T, Char>::value, detail::range_format_kind_<T>,
+          std::integral_constant<range_format, range_format::disabled>> {};
+
+template <typename R, typename Char>
+struct formatter<
+    R, Char,
+    enable_if_t<conjunction<bool_constant<range_format_kind<R, Char>::value !=
+                                          range_format::disabled>
+// Workaround a bug in MSVC 2015 and earlier.
+#if !FMT_MSC_VERSION || FMT_MSC_VERSION >= 1910
+                            ,
+                            detail::is_formattable_delayed<R, Char>
+#endif
+                            >::value>>
+    : detail::range_default_formatter<range_format_kind<R, Char>::value, R,
+                                      Char> {
+};
+
+template <typename Char, typename... T> struct tuple_join_view : detail::view {
+  const std::tuple<T...>& tuple;
+  basic_string_view<Char> sep;
+
+  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
+      : tuple(t), sep{s} {}
+};
+
+template <typename Char, typename... T>
+using tuple_arg_join = tuple_join_view<Char, T...>;
+
+// Define FMT_TUPLE_JOIN_SPECIFIERS to enable experimental format specifiers
+// support in tuple_join. It is disabled by default because of issues with
+// the dynamic width and precision.
+#ifndef FMT_TUPLE_JOIN_SPECIFIERS
+#  define FMT_TUPLE_JOIN_SPECIFIERS 0
+#endif
+
+template <typename Char, typename... T>
+struct formatter<tuple_join_view<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return do_parse(ctx, std::integral_constant<size_t, sizeof...(T)>());
+  }
+
+  template <typename FormatContext>
+  auto format(const tuple_join_view<Char, T...>& value,
+              FormatContext& ctx) const -> typename FormatContext::iterator {
+    return do_format(value, ctx,
+                     std::integral_constant<size_t, sizeof...(T)>());
+  }
+
+ private:
+  std::tuple<formatter<typename std::decay<T>::type, Char>...> formatters_;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+                              std::integral_constant<size_t, 0>)
+      -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename ParseContext, size_t N>
+  FMT_CONSTEXPR auto do_parse(ParseContext& ctx,
+                              std::integral_constant<size_t, N>)
+      -> decltype(ctx.begin()) {
+    auto end = ctx.begin();
+#if FMT_TUPLE_JOIN_SPECIFIERS
+    end = std::get<sizeof...(T) - N>(formatters_).parse(ctx);
+    if (N > 1) {
+      auto end1 = do_parse(ctx, std::integral_constant<size_t, N - 1>());
+      if (end != end1)
+        FMT_THROW(format_error("incompatible format specs for tuple elements"));
+    }
+#endif
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto do_format(const tuple_join_view<Char, T...>&, FormatContext& ctx,
+                 std::integral_constant<size_t, 0>) const ->
+      typename FormatContext::iterator {
+    return ctx.out();
+  }
+
+  template <typename FormatContext, size_t N>
+  auto do_format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
+                 std::integral_constant<size_t, N>) const ->
+      typename FormatContext::iterator {
+    auto out = std::get<sizeof...(T) - N>(formatters_)
+                   .format(std::get<sizeof...(T) - N>(value.tuple), ctx);
+    if (N > 1) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return do_format(value, ctx, std::integral_constant<size_t, N - 1>());
+    }
+    return out;
+  }
+};
+
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
+    -> tuple_join_view<char, T...> {
+  return {tuple, sep};
+}
+
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
+                        basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, T...> {
+  return {tuple, sep};
+}
+
+/**
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
+
+  **Example**::
+
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
+ */
+template <typename T>
+auto join(std::initializer_list<T> list, string_view sep)
+    -> join_view<const T*, const T*> {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_RANGES_H_
@@ -0,0 +1,171 @@
+// Formatting library for C++ - formatters for standard library types
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_STD_H_
+#define FMT_STD_H_
+
+#include <thread>
+#include <type_traits>
+#include <utility>
+
+#include "ostream.h"
+
+#if FMT_HAS_INCLUDE(<version>)
+#  include <version>
+#endif
+// Checking FMT_CPLUSPLUS for warning suppression in MSVC.
+#if FMT_CPLUSPLUS >= 201703L
+#  if FMT_HAS_INCLUDE(<filesystem>)
+#    include <filesystem>
+#  endif
+#  if FMT_HAS_INCLUDE(<variant>)
+#    include <variant>
+#  endif
+#endif
+
+#ifdef __cpp_lib_filesystem
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename Char>
+void write_escaped_path(basic_memory_buffer<Char>& quoted,
+                        const std::filesystem::path& p) {
+  write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
+}
+#  ifdef _WIN32
+template <>
+inline void write_escaped_path<char>(basic_memory_buffer<char>& quoted,
+                                     const std::filesystem::path& p) {
+  auto s = p.u8string();
+  write_escaped_string<char>(
+      std::back_inserter(quoted),
+      string_view(reinterpret_cast<const char*>(s.c_str()), s.size()));
+}
+#  endif
+template <>
+inline void write_escaped_path<std::filesystem::path::value_type>(
+    basic_memory_buffer<std::filesystem::path::value_type>& quoted,
+    const std::filesystem::path& p) {
+  write_escaped_string<std::filesystem::path::value_type>(
+      std::back_inserter(quoted), p.native());
+}
+
+}  // namespace detail
+
+template <typename Char>
+struct formatter<std::filesystem::path, Char>
+    : formatter<basic_string_view<Char>> {
+  template <typename FormatContext>
+  auto format(const std::filesystem::path& p, FormatContext& ctx) const ->
+      typename FormatContext::iterator {
+    basic_memory_buffer<Char> quoted;
+    detail::write_escaped_path(quoted, p);
+    return formatter<basic_string_view<Char>>::format(
+        basic_string_view<Char>(quoted.data(), quoted.size()), ctx);
+  }
+};
+FMT_END_NAMESPACE
+#endif
+
+FMT_BEGIN_NAMESPACE
+template <typename Char>
+struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
+FMT_END_NAMESPACE
+
+#ifdef __cpp_lib_variant
+FMT_BEGIN_NAMESPACE
+template <typename Char> struct formatter<std::monostate, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const std::monostate&, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write<Char>(out, "monostate");
+    return out;
+  }
+};
+
+namespace detail {
+
+template <typename T>
+using variant_index_sequence =
+    std::make_index_sequence<std::variant_size<T>::value>;
+
+// variant_size and variant_alternative check.
+template <typename T, typename U = void>
+struct is_variant_like_ : std::false_type {};
+template <typename T>
+struct is_variant_like_<T, std::void_t<decltype(std::variant_size<T>::value)>>
+    : std::true_type {};
+
+// formattable element check
+template <typename T, typename C> class is_variant_formattable_ {
+  template <std::size_t... I>
+  static std::conjunction<
+      is_formattable<std::variant_alternative_t<I, T>, C>...>
+      check(std::index_sequence<I...>);
+
+ public:
+  static constexpr const bool value =
+      decltype(check(variant_index_sequence<T>{}))::value;
+};
+
+template <typename Char, typename OutputIt, typename T>
+auto write_variant_alternative(OutputIt out, const T& v) -> OutputIt {
+  if constexpr (is_string<T>::value)
+    return write_escaped_string<Char>(out, detail::to_string_view(v));
+  else if constexpr (std::is_same_v<T, Char>)
+    return write_escaped_char(out, v);
+  else
+    return write<Char>(out, v);
+}
+
+}  // namespace detail
+
+template <typename T> struct is_variant_like {
+  static constexpr const bool value = detail::is_variant_like_<T>::value;
+};
+
+template <typename T, typename C> struct is_variant_formattable {
+  static constexpr const bool value =
+      detail::is_variant_formattable_<T, C>::value;
+};
+
+template <typename Variant, typename Char>
+struct formatter<
+    Variant, Char,
+    std::enable_if_t<std::conjunction_v<
+        is_variant_like<Variant>, is_variant_formattable<Variant, Char>>>> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const Variant& value, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+
+    out = detail::write<Char>(out, "variant(");
+    std::visit(
+        [&](const auto& v) {
+          out = detail::write_variant_alternative<Char>(out, v);
+        },
+        value);
+    *out++ = ')';
+    return out;
+  }
+};
+FMT_END_NAMESPACE
+#endif
+
+#endif  // FMT_STD_H_
@@ -0,0 +1,229 @@
+// Formatting library for C++ - optional wchar_t and exotic character support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_XCHAR_H_
+#define FMT_XCHAR_H_
+
+#include <cwchar>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template <typename T>
+using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
+}
+
+FMT_MODULE_EXPORT_BEGIN
+
+using wstring_view = basic_string_view<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
+using wformat_args = basic_format_args<wformat_context>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename... Args> using wformat_string = wstring_view;
+inline auto runtime(wstring_view s) -> wstring_view { return s; }
+#else
+template <typename... Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+inline auto runtime(wstring_view s) -> basic_runtime<wchar_t> { return {{s}}; }
+#endif
+
+template <> struct is_char<wchar_t> : std::true_type {};
+template <> struct is_char<detail::char8_type> : std::true_type {};
+template <> struct is_char<char16_t> : std::true_type {};
+template <> struct is_char<char32_t> : std::true_type {};
+
+template <typename... Args>
+constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
+    const Args&... args) {
+  return {args...};
+}
+
+inline namespace literals {
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_ARGS
+constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
+  return {s};
+}
+#endif
+}  // namespace literals
+
+template <typename It, typename Sentinel>
+auto join(It begin, Sentinel end, wstring_view sep)
+    -> join_view<It, Sentinel, wchar_t> {
+  return {begin, end, sep};
+}
+
+template <typename Range>
+auto join(Range&& range, wstring_view sep)
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
+                 wchar_t> {
+  return join(std::begin(range), std::end(range), sep);
+}
+
+template <typename T>
+auto join(std::initializer_list<T> list, wstring_view sep)
+    -> join_view<const T*, const T*, wchar_t> {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto vformat(basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args);
+  return to_string(buffer);
+}
+
+template <typename... T>
+auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
+  return vformat(fmt::wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+// Pass char_t as a default template parameter instead of using
+// std::basic_string<char_t<S>> to reduce the symbol size.
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value &&
+                        !std::is_same<Char, wchar_t>::value)>
+auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
+  return vformat(detail::to_string_view(format_str),
+                 fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename Locale, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat(
+    const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, detail::to_string_view(format_str), args);
+}
+
+template <typename Locale, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format(const Locale& loc, const S& format_str, Args&&... args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, detail::to_string_view(format_str),
+                         fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename OutputIt, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+auto vformat_to(OutputIt out, const S& format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, detail::to_string_view(format_str), args);
+  return detail::get_iterator(buf);
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
+  return vformat_to(out, detail::to_string_view(fmt),
+                    fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename Locale, typename S, typename OutputIt, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_locale<Locale>::value&&
+                                detail::is_exotic_char<Char>::value)>
+inline auto vformat_to(
+    OutputIt out, const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  vformat_to(buf, detail::to_string_view(format_str), args,
+             detail::locale_ref(loc));
+  return detail::get_iterator(buf);
+}
+
+template <
+    typename OutputIt, typename Locale, typename S, typename... Args,
+    typename Char = char_t<S>,
+    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
+        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
+inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, loc, to_string_view(format_str),
+                    fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename OutputIt, typename Char, typename... Args,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat_to_n(
+    OutputIt out, size_t n, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> format_to_n_result<OutputIt> {
+  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
+                                                                           n);
+  detail::vformat_to(buf, format_str, args);
+  return {buf.out(), buf.count()};
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
+                        const Args&... args) -> format_to_n_result<OutputIt> {
+  return vformat_to_n(out, n, detail::to_string_view(fmt),
+                      fmt::make_format_args<buffer_context<Char>>(args...));
+}
+
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
+inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
+  detail::counting_buffer<Char> buf;
+  detail::vformat_to(buf, detail::to_string_view(fmt),
+                     fmt::make_format_args<buffer_context<Char>>(args...));
+  return buf.count();
+}
+
+inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
+  wmemory_buffer buffer;
+  detail::vformat_to(buffer, fmt, args);
+  buffer.push_back(L'\0');
+  if (std::fputws(buffer.data(), f) == -1)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+inline void vprint(wstring_view fmt, wformat_args args) {
+  vprint(stdout, fmt, args);
+}
+
+template <typename... T>
+void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
+  return vprint(f, wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
+  return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
+}
+
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
+template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
+  return format(FMT_STRING(L"{}"), value);
+}
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_XCHAR_H_
@@ -0,0 +1,47 @@
+// Formatting library for C++
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/format-inl.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template FMT_API auto dragonbox::to_decimal(float x) noexcept
+    -> dragonbox::decimal_fp<float>;
+template FMT_API auto dragonbox::to_decimal(double x) noexcept
+    -> dragonbox::decimal_fp<double>;
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template FMT_API locale_ref::locale_ref(const std::locale& loc);
+template FMT_API auto locale_ref::get<std::locale>() const -> std::locale;
+#endif
+
+// Explicit instantiations for char.
+
+template FMT_API auto thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<char>;
+template FMT_API auto decimal_point_impl(locale_ref) -> char;
+
+template FMT_API void buffer<char>::append(const char*, const char*);
+
+// DEPRECATED!
+// There is no correspondent extern template in format.h because of
+// incompatibility between clang and gcc (#2377).
+template FMT_API void vformat_to(buffer<char>&, string_view,
+                                 basic_format_args<FMT_BUFFER_CONTEXT(char)>,
+                                 locale_ref);
+
+// Explicit instantiations for wchar_t.
+
+template FMT_API auto thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<wchar_t>;
+template FMT_API auto decimal_point_impl(locale_ref) -> wchar_t;
+
+template FMT_API void buffer<wchar_t>::append(const wchar_t*, const wchar_t*);
+
+}  // namespace detail
+FMT_END_NAMESPACE
@@ -0,0 +1,73 @@
+/*
+  ISC License
+
+  Copyright (c) 2023, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include <string>
+
+static int         g_READ_THREAD_COUNT          = -1;
+static int         g_PROCESS_THREAD_COUNT       = -1;
+static int         g_PROCESS_THREAD_QUEUE_DEPTH = -1;
+static std::string g_PIN_THREADS                = {};
+
+
+int
+fuse_config_get_read_thread_count()
+{
+  return g_READ_THREAD_COUNT;
+}
+
+void
+fuse_config_set_read_thread_count(int const v_)
+{
+  g_READ_THREAD_COUNT = v_;
+}
+
+int
+fuse_config_get_process_thread_count()
+{
+  return g_PROCESS_THREAD_COUNT;
+}
+
+void
+fuse_config_set_process_thread_count(int const v_)
+{
+  g_PROCESS_THREAD_COUNT = v_;
+}
+
+int
+fuse_config_get_process_thread_queue_depth()
+{
+  return g_PROCESS_THREAD_QUEUE_DEPTH;
+}
+
+void
+fuse_config_set_process_thread_queue_depth(int const v_)
+{
+  g_PROCESS_THREAD_QUEUE_DEPTH = v_;
+}
+
+std::string
+fuse_config_get_pin_threads()
+{
+  return g_PIN_THREADS;
+}
+
+void
+fuse_config_set_pin_threads(std::string const v_)
+{
+  g_PIN_THREADS = v_;
+}
@@ -19,6 +19,14 @@
 /* 32KB - same as glibc getdents buffer size */
 #define DEFAULT_SIZE (1024 * 32)

+static
+uint64_t
+round_up(const uint64_t number_,
+         const uint64_t multiple_)
+{
+  return (((number_ + multiple_ - 1) / multiple_) * multiple_);
+}
+
 static
 uint64_t
 align_uint64_t(uint64_t v_)
@@ -57,16 +65,15 @@ int
 fuse_dirents_buf_resize(fuse_dirents_t *d_,
                        uint64_t        size_)
 {
-  void *p;
-
-  if((d_->data_len + size_) >= d_->buf_len)
+  if((kv_size(d_->data) + size_) >= kv_max(d_->data))
    {
-      p = realloc(d_->buf,(d_->buf_len * 2));
-      if(p == NULL)
-        return -errno;
+      uint64_t new_size;

-      d_->buf      = p;
-      d_->buf_len *= 2;
+      new_size = round_up((kv_size(d_->data) + size_),DEFAULT_SIZE);
+
+      kv_resize(char,d_->data,new_size);
+      if(d_->data.a == NULL)
+        return -ENOMEM;
    }

  return 0;
@@ -87,9 +94,8 @@ fuse_dirents_dirent_alloc(fuse_dirents_t *d_,
  if(rv)
    return NULL;

-  d = (fuse_dirent_t*)&d_->buf[d_->data_len];
-
-  d_->data_len += size;
+  d = (fuse_dirent_t*)&kv_end(d_->data);
+  kv_size(d_->data) += size;

  return d;
 }
@@ -109,9 +115,8 @@ fuse_dirents_direntplus_alloc(fuse_dirents_t *d_,
  if(rv)
    return NULL;

-  d = (fuse_dirent_t*)&d_->buf[d_->data_len];
-
-  d_->data_len += size;
+  d = (fuse_dirent_t*)&kv_end(d_->data);
+  kv_size(d_->data) += size;

  return d;
 }
@@ -170,8 +175,8 @@ fuse_dirent_find(fuse_dirents_t *d_,
  if(d_->type != NORMAL)
    return NULL;

-  cur = (fuse_dirent_t*)&d_->buf[0];
-  end = (fuse_dirent_t*)&d_->buf[d_->data_len];
+  cur = (fuse_dirent_t*)&kv_first(d_->data);
+  end = (fuse_dirent_t*)&kv_end(d_->data);
  while(cur < end)
    {
      if(cur->ino == ino_)
@@ -193,8 +198,8 @@ fuse_direntplus_find(fuse_dirents_t *d_,
  if(d_->type != PLUS)
    return NULL;

-  cur = (fuse_direntplus_t*)&d_->buf[0];
-  end = (fuse_direntplus_t*)&d_->buf[d_->data_len];
+  cur = (fuse_direntplus_t*)&kv_first(d_->data);
+  end = (fuse_direntplus_t*)&kv_end(d_->data);
  while(cur < end)
    {
      if(cur->dirent.ino == ino_)
@@ -251,7 +256,7 @@ fuse_dirents_add(fuse_dirents_t      *d_,
    return -ENOMEM;

  d->off     = kv_size(d_->offs);
-  kv_push(uint32_t,d_->offs,d_->data_len);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
  d->ino     = dirent_->d_ino;
  d->namelen = namelen_;
  d->type    = dirent_->d_type;
@@ -285,7 +290,7 @@ fuse_dirents_add_plus(fuse_dirents_t      *d_,
    return -ENOMEM;

  d->dirent.off     = kv_size(d_->offs);
-  kv_push(uint32_t,d_->offs,d_->data_len);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
  d->dirent.ino     = dirent_->d_ino;
  d->dirent.namelen = namelen_;
  d->dirent.type    = dirent_->d_type;
@@ -299,9 +304,9 @@ fuse_dirents_add_plus(fuse_dirents_t      *d_,
 }

 int
-fuse_dirents_add_linux(fuse_dirents_t              *d_,
-                       const struct linux_dirent64 *dirent_,
-                       const uint64_t               namelen_)
+fuse_dirents_add_linux(fuse_dirents_t         *d_,
+                       const linux_dirent64_t *dirent_,
+                       const uint64_t          namelen_)
 {
  fuse_dirent_t *d;

@@ -321,7 +326,7 @@ fuse_dirents_add_linux(fuse_dirents_t              *d_,
    return -ENOMEM;

  d->off     = kv_size(d_->offs);
-  kv_push(uint32_t,d_->offs,d_->data_len);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
  d->ino     = dirent_->ino;
  d->namelen = namelen_;
  d->type    = dirent_->type;
@@ -331,11 +336,11 @@ fuse_dirents_add_linux(fuse_dirents_t              *d_,
 }

 int
-fuse_dirents_add_linux_plus(fuse_dirents_t              *d_,
-                            const struct linux_dirent64 *dirent_,
-                            const uint64_t               namelen_,
-                            const fuse_entry_t          *entry_,
-                            const struct stat           *st_)
+fuse_dirents_add_linux_plus(fuse_dirents_t         *d_,
+                            const linux_dirent64_t *dirent_,
+                            const uint64_t          namelen_,
+                            const fuse_entry_t     *entry_,
+                            const struct stat      *st_)
 {
  fuse_direntplus_t *d;

@@ -355,7 +360,7 @@ fuse_dirents_add_linux_plus(fuse_dirents_t              *d_,
    return -ENOMEM;

  d->dirent.off     = kv_size(d_->offs);
-  kv_push(uint32_t,d_->offs,d_->data_len);
+  kv_push(uint32_t,d_->offs,kv_size(d_->data));
  d->dirent.ino     = dirent_->ino;
  d->dirent.namelen = namelen_;
  d->dirent.type    = dirent_->type;
@@ -371,25 +376,21 @@ fuse_dirents_add_linux_plus(fuse_dirents_t              *d_,
 void
 fuse_dirents_reset(fuse_dirents_t *d_)
 {
-  d_->data_len      = 0;
  d_->type          = UNSET;
+  kv_size(d_->data) = 0;
  kv_size(d_->offs) = 1;
 }

 int
 fuse_dirents_init(fuse_dirents_t *d_)
 {
-  void *buf;
+  d_->type = UNSET;

-  buf = calloc(DEFAULT_SIZE,1);
-  if(buf == NULL)
+  kv_init(d_->data);
+  kv_resize(char,d_->data,DEFAULT_SIZE);
+  if(d_->data.a == NULL)
    return -ENOMEM;

-  d_->buf      = buf;
-  d_->buf_len  = DEFAULT_SIZE;
-  d_->data_len = 0;
-  d_->type     = UNSET;
-
  kv_init(d_->offs);
  kv_resize(uint32_t,d_->offs,64);
  kv_push(uint32_t,d_->offs,0);
@@ -400,11 +401,6 @@ fuse_dirents_init(fuse_dirents_t *d_)
 void
 fuse_dirents_free(fuse_dirents_t *d_)
 {
-  d_->buf_len  = 0;
-  d_->data_len = 0;
-  d_->type     = UNSET;
-
+  kv_destroy(d_->data);
  kv_destroy(d_->offs);
-
-  free(d_->buf);
 }
@@ -10,24 +10,25 @@

 #include "fuse.h"
 #include "fuse_lowlevel.h"
+#include "fuse_msgbuf.h"
+
+#include "extern_c.h"

 struct fuse_chan;
 struct fuse_ll;

 struct fuse_session
 {
-  struct fuse_session_ops op;
+  int (*receive_buf)(struct fuse_session *se,
+                     fuse_msgbuf_t       *msgbuf);

-  int (*receive_buf)(struct fuse_session *se, struct fuse_buf *buf,
-                     struct fuse_chan **chp);
+  void (*process_buf)(struct fuse_session *se,
+                      const fuse_msgbuf_t *msgbuf);

-  void (*process_buf)(void *data, const struct fuse_buf *buf,
-                      struct fuse_chan *ch);
-
-  void *data;
+  void (*destroy)(void *data);

+  struct fuse_ll *f;
  volatile int exited;
-
  struct fuse_chan *ch;
 };

@@ -35,30 +36,18 @@ struct fuse_req
 {
  struct fuse_ll *f;
  uint64_t unique;
-  int ctr;
-  pthread_mutex_t lock;
  struct fuse_ctx ctx;
  struct fuse_chan *ch;
-  int interrupted;
  unsigned int ioctl_64bit : 1;
-  union {
-    struct {
-      uint64_t unique;
-    } i;
-    struct {
-      fuse_interrupt_func_t func;
-      void *data;
-    } ni;
-  } u;
-  struct fuse_req *next;
-  struct fuse_req *prev;
 };

 struct fuse_notify_req
 {
  uint64_t unique;
-  void (*reply)(struct fuse_notify_req *, fuse_req_t, fuse_ino_t,
-                const void *, const struct fuse_buf *);
+  void (*reply)(struct fuse_notify_req *,
+                fuse_req_t,
+                uint64_t,
+                const void *);
  struct fuse_notify_req *next;
  struct fuse_notify_req *prev;
 };
@@ -66,24 +55,15 @@ struct fuse_notify_req
 struct fuse_ll
 {
  int debug;
-  int allow_root;
  int no_remote_posix_lock;
  int no_remote_flock;
  int big_writes;
-  int splice_write;
-  int splice_move;
-  int splice_read;
-  int no_splice_write;
-  int no_splice_move;
-  int no_splice_read;
  struct fuse_lowlevel_ops op;
-  int got_init;
  void *userdata;
  uid_t owner;
  struct fuse_conn_info conn;
-  struct fuse_req list;
-  struct fuse_req interrupts;
  pthread_mutex_t lock;
+  int got_init;
  int got_destroy;
  pthread_key_t pipe_key;
  int broken_splice_nonblock;
@@ -98,9 +78,11 @@ struct fuse_cmd
  struct fuse_chan *ch;
 };

+EXTERN_C_BEGIN
+
 struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
 			     const struct fuse_operations *op,
-			     size_t op_size, void *user_data);
+			     size_t op_size);

 struct fuse_chan *fuse_kern_chan_new(int fd);

@@ -122,7 +104,8 @@ struct fuse *fuse_setup_common(int argc, char *argv[],
 			       const struct fuse_operations *op,
 			       size_t op_size,
 			       char **mountpoint,
-			       int *fd,
-			       void *user_data);
+			       int *fd);

 int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg);
+
+EXTERN_C_END
@@ -1,103 +0,0 @@
-/*
-  FUSE: Filesystem in Userspace
-  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB
-*/
-
-#include "fuse_lowlevel.h"
-#include "fuse_kernel.h"
-#include "fuse_i.h"
-
-#include <stdio.h>
-#include <errno.h>
-#include <unistd.h>
-#include <assert.h>
-
-static int fuse_kern_chan_receive(struct fuse_chan **chp, char *buf,
-				  size_t size)
-{
-  struct fuse_chan *ch = *chp;
-  int err;
-  ssize_t res;
-  struct fuse_session *se = fuse_chan_session(ch);
-  assert(se != NULL);
-
- restart:
-  res = read(fuse_chan_fd(ch), buf, size);
-  err = errno;
-
-  if (fuse_session_exited(se))
-    return 0;
-  if (res == -1) {
-    /* ENOENT means the operation was interrupted, it's safe
-       to restart */
-    if (err == ENOENT)
-      goto restart;
-
-    if (err == ENODEV) {
-      fuse_session_exit(se);
-      return 0;
-    }
-    /* Errors occurring during normal operation: EINTR (read
-       interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
-       umounted) */
-    if (err != EINTR && err != EAGAIN)
-      perror("fuse: reading device");
-    return -err;
-  }
-  if ((size_t) res < sizeof(struct fuse_in_header)) {
-    fprintf(stderr, "short read on fuse device\n");
-    return -EIO;
-  }
-  return res;
-}
-
-static int fuse_kern_chan_send(struct fuse_chan *ch, const struct iovec iov[],
-			       size_t count)
-{
-  if (iov) {
-    ssize_t res = writev(fuse_chan_fd(ch), iov, count);
-    int err = errno;
-
-    if (res == -1) {
-      struct fuse_session *se = fuse_chan_session(ch);
-
-      assert(se != NULL);
-
-      /* ENOENT means the operation was interrupted */
-      if (!fuse_session_exited(se) && err != ENOENT)
-        perror("fuse: writing device");
-      return -err;
-    }
-  }
-  return 0;
-}
-
-static void fuse_kern_chan_destroy(struct fuse_chan *ch)
-{
-  int fd = fuse_chan_fd(ch);
-
-  if (fd != -1)
-    close(fd);
-}
-
-struct fuse_chan *
-fuse_kern_chan_new(int fd_)
-{
-  long pagesize;
-  size_t bufsize;
-  struct fuse_chan_ops op =
-    {
-      .receive = fuse_kern_chan_receive,
-      .send    = fuse_kern_chan_send,
-      .destroy = fuse_kern_chan_destroy,
-    };
-
-  pagesize = sysconf(_SC_PAGESIZE);
-
-  bufsize = ((FUSE_MAX_MAX_PAGES * pagesize) + 0x1000);
-
-  return fuse_chan_new(&op, fd_, bufsize, NULL);
-}
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "fuse_msgbuf.h"
+
+int fuse_receive_buf(struct fuse_session *se,
+                     fuse_msgbuf_t       *msgbuf);
+void fuse_process_buf(void *data,
+                      const fuse_msgbuf_t *msgbuf,
+                      struct fuse_chan *ch);
@@ -0,0 +1,555 @@
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include "cpu.hpp"
+#include "fmt/core.h"
+#include "make_unique.hpp"
+#include "scope_guard.hpp"
+#include "thread_pool.hpp"
+
+#include "fuse_i.h"
+#include "fuse_kernel.h"
+#include "fuse_lowlevel.h"
+#include "fuse_misc.h"
+
+#include "fuse_config.hpp"
+#include "fuse_msgbuf.hpp"
+#include "fuse_ll.hpp"
+
+#include <errno.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <syslog.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <vector>
+
+static
+bool
+retriable_receive_error(const int err_)
+{
+  switch(err_)
+    {
+    case -EINTR:
+    case -EAGAIN:
+    case -ENOENT:
+      return true;
+    default:
+      return false;
+    }
+}
+
+static
+bool
+fatal_receive_error(const int err_)
+{
+  return (err_ < 0);
+}
+
+static
+void
+handle_receive_error(const int      rv_,
+                     fuse_msgbuf_t *msgbuf_)
+{
+  msgbuf_free(msgbuf_);
+
+  fmt::print(stderr,
+             "mergerfs: error reading from /dev/fuse - {} ({})\n",
+             strerror(-rv_),
+             -rv_);
+}
+
+struct AsyncWorker
+{
+  fuse_session *_se;
+  sem_t *_finished;
+  std::shared_ptr<ThreadPool> _process_tp;
+
+  AsyncWorker(fuse_session                       *se_,
+              sem_t                              *finished_,
+              std::shared_ptr<ThreadPool>  process_tp_)
+    : _se(se_),
+      _finished(finished_),
+      _process_tp(process_tp_)
+  {
+  }
+
+  inline
+  void
+  operator()() const
+  {
+    DEFER{ fuse_session_exit(_se); };
+    DEFER{ sem_post(_finished); };
+
+    moodycamel::ProducerToken ptok(_process_tp->ptoken());
+    while(!fuse_session_exited(_se))
+      {
+        int rv;
+        fuse_msgbuf_t *msgbuf;
+
+        msgbuf = msgbuf_alloc();
+
+        do
+          {
+            pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
+            rv = _se->receive_buf(_se,msgbuf);
+            pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
+            if(rv == 0)
+              return;
+            if(retriable_receive_error(rv))
+              continue;
+            if(fatal_receive_error(rv))
+              return handle_receive_error(rv,msgbuf);
+          } while(false);
+
+        auto const func = [=]
+        {
+          _se->process_buf(_se,msgbuf);
+          msgbuf_free(msgbuf);
+        };
+
+        _process_tp->enqueue_work(ptok,func);
+      }
+  }
+};
+
+struct SyncWorker
+{
+  fuse_session *_se;
+  sem_t *_finished;
+
+  SyncWorker(fuse_session *se_,
+             sem_t        *finished_)
+
+    : _se(se_),
+      _finished(finished_)
+  {
+  }
+
+  inline
+  void
+  operator()() const
+  {
+    DEFER{ fuse_session_exit(_se); };
+    DEFER{ sem_post(_finished); };
+
+    while(!fuse_session_exited(_se))
+      {
+        int rv;
+        fuse_msgbuf_t *msgbuf;
+
+        msgbuf = msgbuf_alloc();
+
+        do
+          {
+            pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
+            rv = _se->receive_buf(_se,msgbuf);
+            pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
+            if(rv == 0)
+              return;
+            if(retriable_receive_error(rv))
+              continue;
+            if(fatal_receive_error(rv))
+              return handle_receive_error(rv,msgbuf);
+          } while(false);
+
+        _se->process_buf(_se,msgbuf);
+        msgbuf_free(msgbuf);
+      }
+  }
+};
+
+int
+fuse_start_thread(pthread_t *thread_id,
+                  void      *(*func)(void *),
+                  void      *arg)
+{
+  int res;
+  sigset_t oldset;
+  sigset_t newset;
+
+  sigfillset(&newset);
+  pthread_sigmask(SIG_BLOCK,&newset,&oldset);
+  res = pthread_create(thread_id,NULL,func,arg);
+  pthread_sigmask(SIG_SETMASK,&oldset,NULL);
+
+  if(res != 0)
+    {
+      fprintf(stderr,
+              "fuse: error creating thread: %s\n",
+              strerror(res));
+      return -1;
+    }
+
+  return 0;
+}
+
+static
+int
+calculate_thread_count(const int raw_thread_count_)
+{
+  int thread_count;
+
+  thread_count = 4;
+  if(raw_thread_count_ == 0)
+    thread_count = std::thread::hardware_concurrency();
+  else if(raw_thread_count_ < 0)
+    thread_count = (std::thread::hardware_concurrency() / -raw_thread_count_);
+  else if(raw_thread_count_ > 0)
+    thread_count = raw_thread_count_;
+
+  if(thread_count <= 0)
+    thread_count = 1;
+
+  return thread_count;
+}
+
+static
+void
+calculate_thread_counts(int *read_thread_count_,
+                        int *process_thread_count_,
+                        int *process_thread_queue_depth_)
+{
+  if((*read_thread_count_ == -1) && (*process_thread_count_ == -1))
+    {
+      int nproc;
+
+      nproc = std::thread::hardware_concurrency();
+      *read_thread_count_ = 2;
+      *process_thread_count_ = std::max(2,(nproc - 2));
+    }
+  else
+    {
+      *read_thread_count_ = ::calculate_thread_count(*read_thread_count_);
+      if(*process_thread_count_ != -1)
+        *process_thread_count_ = ::calculate_thread_count(*process_thread_count_);
+    }
+
+  if(*process_thread_queue_depth_ <= 0)
+    *process_thread_queue_depth_ = *process_thread_count_;
+}
+
+static
+void
+pin_threads_R1L(const CPU::ThreadIdVec read_threads_)
+{
+  CPU::CPUVec cpus;
+
+  cpus = CPU::cpus();
+  if(cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    CPU::setaffinity(thread_id,cpus.front());
+}
+
+static
+void
+pin_threads_R1P(const CPU::ThreadIdVec read_threads_)
+{
+  CPU::Core2CPUsMap core2cpus;
+
+  core2cpus = CPU::core2cpus();
+  if(core2cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    CPU::setaffinity(thread_id,core2cpus.begin()->second);
+}
+
+static
+void
+pin_threads_RP1L(const CPU::ThreadIdVec read_threads_,
+                 const CPU::ThreadIdVec process_threads_)
+{
+  CPU::CPUVec cpus;
+
+  cpus = CPU::cpus();
+  if(cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    CPU::setaffinity(thread_id,cpus.front());
+  for(auto const thread_id : process_threads_)
+    CPU::setaffinity(thread_id,cpus.front());
+}
+
+static
+void
+pin_threads_RP1P(const CPU::ThreadIdVec read_threads_,
+                 const CPU::ThreadIdVec process_threads_)
+{
+  CPU::Core2CPUsMap core2cpus;
+
+  core2cpus = CPU::core2cpus();
+  if(core2cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    CPU::setaffinity(thread_id,core2cpus.begin()->second);
+  for(auto const thread_id : process_threads_)
+    CPU::setaffinity(thread_id,core2cpus.begin()->second);
+}
+
+static
+void
+pin_threads_R1LP1L(const std::vector<pthread_t> read_threads_,
+                   const std::vector<pthread_t> process_threads_)
+{
+  CPU::CPUVec cpus;
+
+  cpus = CPU::cpus();
+  if(cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    CPU::setaffinity(thread_id,cpus.front());
+
+  for(auto const thread_id : process_threads_)
+    CPU::setaffinity(thread_id,cpus.back());
+}
+
+static
+void
+pin_threads_R1PP1P(const std::vector<pthread_t> read_threads_,
+                   const std::vector<pthread_t> process_threads_)
+{
+  CPU::Core2CPUsMap core2cpus;
+
+  core2cpus = CPU::core2cpus();
+  if(core2cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    CPU::setaffinity(thread_id,core2cpus.begin()->second);
+
+  if(core2cpus.size() > 1)
+    core2cpus.erase(core2cpus.begin());
+
+  for(auto const thread_id : process_threads_)
+    CPU::setaffinity(thread_id,core2cpus.begin()->second);
+}
+
+static
+void
+pin_threads_RPSL(const std::vector<pthread_t> read_threads_,
+                 const std::vector<pthread_t> process_threads_)
+{
+  CPU::CPUVec cpus;
+
+  cpus = CPU::cpus();
+  if(cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    {
+      if(cpus.empty())
+        cpus = CPU::cpus();
+      CPU::setaffinity(thread_id,cpus.back());
+      cpus.pop_back();
+    }
+
+  for(auto const thread_id : process_threads_)
+    {
+      if(cpus.empty())
+        cpus = CPU::cpus();
+      CPU::setaffinity(thread_id,cpus.back());
+      cpus.pop_back();
+    }
+}
+
+static
+void
+pin_threads_RPSP(const std::vector<pthread_t> read_threads_,
+                 const std::vector<pthread_t> process_threads_)
+{
+  CPU::Core2CPUsMap core2cpus;
+
+  core2cpus = CPU::core2cpus();
+  if(core2cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    {
+      if(core2cpus.empty())
+        core2cpus = CPU::core2cpus();
+      CPU::setaffinity(thread_id,core2cpus.begin()->second);
+      core2cpus.erase(core2cpus.begin());
+    }
+
+  for(auto const thread_id : process_threads_)
+    {
+      if(core2cpus.empty())
+        core2cpus = CPU::core2cpus();
+      CPU::setaffinity(thread_id,core2cpus.begin()->second);
+      core2cpus.erase(core2cpus.begin());
+    }
+}
+
+static
+void
+pin_threads_R1PPSP(const std::vector<pthread_t> read_threads_,
+                   const std::vector<pthread_t> process_threads_)
+{
+  CPU::Core2CPUsMap core2cpus;
+  CPU::Core2CPUsMap leftover;
+
+  core2cpus = CPU::core2cpus();
+  if(core2cpus.empty())
+    return;
+
+  for(auto const thread_id : read_threads_)
+    CPU::setaffinity(thread_id,core2cpus.begin()->second);
+
+  core2cpus.erase(core2cpus.begin());
+  if(core2cpus.empty())
+    core2cpus = CPU::core2cpus();
+  leftover = core2cpus;
+
+  for(auto const thread_id : process_threads_)
+    {
+      if(core2cpus.empty())
+        core2cpus = leftover;
+      CPU::setaffinity(thread_id,core2cpus.begin()->second);
+      core2cpus.erase(core2cpus.begin());
+    }
+}
+
+static
+void
+pin_threads(const std::vector<pthread_t> read_threads_,
+            const std::vector<pthread_t> process_threads_,
+            const std::string            type_)
+{
+  if(type_.empty() || (type_ == "false"))
+    return;
+  if(type_ == "R1L")
+    return ::pin_threads_R1L(read_threads_);
+  if(type_ == "R1P")
+    return ::pin_threads_R1P(read_threads_);
+  if(type_ == "RP1L")
+    return ::pin_threads_RP1L(read_threads_,process_threads_);
+  if(type_ == "RP1P")
+    return ::pin_threads_RP1P(read_threads_,process_threads_);
+  if(type_ == "R1LP1L")
+    return ::pin_threads_R1LP1L(read_threads_,process_threads_);
+  if(type_ == "R1PP1P")
+    return ::pin_threads_R1PP1P(read_threads_,process_threads_);
+  if(type_ == "RPSL")
+    return ::pin_threads_RPSL(read_threads_,process_threads_);
+  if(type_ == "RPSP")
+    return ::pin_threads_RPSP(read_threads_,process_threads_);
+  if(type_ == "R1PPSP")
+    return ::pin_threads_R1PPSP(read_threads_,process_threads_);
+
+  syslog(LOG_WARNING,
+         "Invalid pin-threads value, ignoring: %s",
+         type_.c_str());
+}
+
+static
+void
+wait(fuse_session *se_,
+     sem_t        *finished_sem_)
+{
+  while(!fuse_session_exited(se_))
+    sem_wait(finished_sem_);
+}
+
+int
+fuse_session_loop_mt(struct fuse_session *se_,
+                     const int            raw_read_thread_count_,
+                     const int            raw_process_thread_count_,
+                     const int            raw_process_thread_queue_depth_,
+                     const std::string    pin_threads_type_)
+{
+  sem_t finished;
+  int read_thread_count;
+  int process_thread_count;
+  int process_thread_queue_depth;
+  std::vector<pthread_t> read_threads;
+  std::vector<pthread_t> process_threads;
+  std::unique_ptr<ThreadPool> read_tp;
+  std::shared_ptr<ThreadPool> process_tp;
+
+  sem_init(&finished,0,0);
+
+  read_thread_count          = raw_read_thread_count_;
+  process_thread_count       = raw_process_thread_count_;
+  process_thread_queue_depth = raw_process_thread_queue_depth_;
+  ::calculate_thread_counts(&read_thread_count,
+                            &process_thread_count,
+                            &process_thread_queue_depth);
+
+  if(process_thread_count > 0)
+    process_tp = std::make_shared<ThreadPool>(process_thread_count,
+                                              (process_thread_count *
+                                               process_thread_queue_depth),
+                                              "fuse.process");
+
+  read_tp = std::make_unique<ThreadPool>(read_thread_count,
+                                         read_thread_count,
+                                         "fuse.read");
+  if(process_tp)
+    {
+      for(auto i = 0; i < read_thread_count; i++)
+        read_tp->enqueue_work(AsyncWorker(se_,&finished,process_tp));
+    }
+  else
+    {
+      for(auto i = 0; i < read_thread_count; i++)
+        read_tp->enqueue_work(SyncWorker(se_,&finished));
+    }
+
+  if(read_tp)
+    read_threads = read_tp->threads();
+  if(process_tp)
+    process_threads = process_tp->threads();
+
+  ::pin_threads(read_threads,process_threads,pin_threads_type_);
+
+  syslog(LOG_INFO,
+         "read-thread-count=%d; "
+         "process-thread-count=%d; "
+         "process-thread-queue-depth=%d; "
+         "pin-threads=%s;"
+         ,
+         read_thread_count,
+         process_thread_count,
+         process_thread_queue_depth,
+         pin_threads_type_.c_str());
+
+  ::wait(se_,&finished);
+
+  sem_destroy(&finished);
+
+  return 0;
+}
+
+int
+fuse_loop_mt(struct fuse *f)
+{
+  if(f == NULL)
+    return -1;
+
+  int res = fuse_start_maintenance_thread(f);
+  if(res)
+    return -1;
+
+  res = fuse_session_loop_mt(fuse_get_session(f),
+                             fuse_config_get_read_thread_count(),
+                             fuse_config_get_process_thread_count(),
+                             fuse_config_get_process_thread_queue_depth(),
+                             fuse_config_get_pin_threads());
+
+  fuse_stop_maintenance_thread(f);
+
+  return res;
+}
@@ -1,225 +0,0 @@
-/*
-  FUSE: Filesystem in Userspace
-  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB.
-*/
-
-#include "fuse_lowlevel.h"
-#include "fuse_misc.h"
-#include "fuse_kernel.h"
-#include "fuse_i.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <signal.h>
-#include <semaphore.h>
-#include <errno.h>
-#include <sys/time.h>
-#include <unistd.h>
-
-/* Environment var controlling the thread stack size */
-#define ENVNAME_THREAD_STACK "FUSE_THREAD_STACK"
-
-struct fuse_worker {
-  struct fuse_worker *prev;
-  struct fuse_worker *next;
-  pthread_t thread_id;
-  size_t bufsize;
-  char *buf;
-  struct fuse_mt *mt;
-};
-
-struct fuse_mt {
-  struct fuse_session *se;
-  struct fuse_chan *prevch;
-  struct fuse_worker main;
-  sem_t finish;
-  int exit;
-  int error;
-};
-
-static void list_add_worker(struct fuse_worker *w, struct fuse_worker *next)
-{
-  struct fuse_worker *prev = next->prev;
-  w->next = next;
-  w->prev = prev;
-  prev->next = w;
-  next->prev = w;
-}
-
-static void list_del_worker(struct fuse_worker *w)
-{
-  struct fuse_worker *prev = w->prev;
-  struct fuse_worker *next = w->next;
-  prev->next = next;
-  next->prev = prev;
-}
-
-static int fuse_loop_start_thread(struct fuse_mt *mt);
-
-static void *fuse_do_work(void *data)
-{
-  struct fuse_worker *w  = (struct fuse_worker *) data;
-  struct fuse_mt     *mt = w->mt;
-
-  while (!fuse_session_exited(mt->se)) {
-    struct fuse_chan *ch = mt->prevch;
-    struct fuse_buf fbuf = {
-      .mem = w->buf,
-      .size = w->bufsize,
-    };
-    int res;
-
-    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
-    res = fuse_session_receive_buf(mt->se, &fbuf, &ch);
-    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
-    if (res == -EINTR)
-      continue;
-    if (res <= 0) {
-      if (res < 0) {
-        fuse_session_exit(mt->se);
-        mt->error = -1;
-      }
-      break;
-    }
-
-    if (mt->exit)
-      return NULL;
-
-    fuse_session_process_buf(mt->se, &fbuf, ch);
-  }
-
-  sem_post(&mt->finish);
-
-  return NULL;
-}
-
-int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg)
-{
-  sigset_t oldset;
-  sigset_t newset;
-  int res;
-  pthread_attr_t attr;
-  char *stack_size;
-
-  /* Override default stack size */
-  pthread_attr_init(&attr);
-  stack_size = getenv(ENVNAME_THREAD_STACK);
-  if (stack_size && pthread_attr_setstacksize(&attr, atoi(stack_size)))
-    fprintf(stderr, "fuse: invalid stack size: %s\n", stack_size);
-
-  /* Disallow signal reception in worker threads */
-  sigemptyset(&newset);
-  sigaddset(&newset, SIGTERM);
-  sigaddset(&newset, SIGINT);
-  sigaddset(&newset, SIGHUP);
-  sigaddset(&newset, SIGQUIT);
-  pthread_sigmask(SIG_BLOCK, &newset, &oldset);
-  res = pthread_create(thread_id, &attr, func, arg);
-  pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-  pthread_attr_destroy(&attr);
-  if (res != 0) {
-    fprintf(stderr, "fuse: error creating thread: %s\n",
-            strerror(res));
-    return -1;
-  }
-
-  return 0;
-}
-
-static int fuse_loop_start_thread(struct fuse_mt *mt)
-{
-  int res;
-  struct fuse_worker *w = malloc(sizeof(struct fuse_worker));
-  if (!w) {
-    fprintf(stderr, "fuse: failed to allocate worker structure\n");
-    return -1;
-  }
-  memset(w, 0, sizeof(struct fuse_worker));
-  w->bufsize = fuse_chan_bufsize(mt->prevch);
-  w->buf = calloc(w->bufsize,1);
-  w->mt = mt;
-  if (!w->buf) {
-    fprintf(stderr, "fuse: failed to allocate read buffer\n");
-    free(w);
-    return -1;
-  }
-
-  res = fuse_start_thread(&w->thread_id, fuse_do_work, w);
-  if (res == -1) {
-    free(w->buf);
-    free(w);
-    return -1;
-  }
-  list_add_worker(w, &mt->main);
-
-  return 0;
-}
-
-static void fuse_join_worker(struct fuse_worker *w)
-{
-  pthread_join(w->thread_id, NULL);
-  list_del_worker(w);
-  free(w->buf);
-  free(w);
-}
-
-static int number_of_threads(void)
-{
-#ifdef _SC_NPROCESSORS_ONLN
-  return sysconf(_SC_NPROCESSORS_ONLN);
-#endif
-
-  return 4;
-}
-
-int fuse_session_loop_mt(struct fuse_session *se,
-                         const int            _threads)
-{
-  int i;
-  int err;
-  int threads;
-  struct fuse_mt mt;
-  struct fuse_worker *w;
-
-  memset(&mt, 0, sizeof(struct fuse_mt));
-  mt.se = se;
-  mt.prevch = fuse_session_next_chan(se, NULL);
-  mt.error = 0;
-  mt.main.thread_id = pthread_self();
-  mt.main.prev = mt.main.next = &mt.main;
-  sem_init(&mt.finish, 0, 0);
-
-  threads = ((_threads > 0) ? _threads : number_of_threads());
-  if(_threads < 0)
-    threads /= -_threads;
-  if(threads == 0)
-    threads = 1;
-
-  err = 0;
-  for(i = 0; (i < threads) && !err; i++)
-    err = fuse_loop_start_thread(&mt);
-
-  if (!err) {
-    /* sem_wait() is interruptible */
-    while (!fuse_session_exited(se))
-      sem_wait(&mt.finish);
-
-    for (w = mt.main.next; w != &mt.main; w = w->next)
-      pthread_cancel(w->thread_id);
-    mt.exit = 1;
-
-    while (mt.main.next != &mt.main)
-      fuse_join_worker(mt.main.next);
-
-    err = mt.error;
-  }
-
-  sem_destroy(&mt.finish);
-  fuse_session_reset(se);
-  return err;
-}
@@ -0,0 +1,228 @@
+/*
+  ISC License
+
+  Copyright (c) 2022, Antonio SJ Musumeci <trapexit@spawn.link>
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "fuse_msgbuf.hpp"
+#include "fuse.h"
+#include "fuse_kernel.h"
+
+#include <unistd.h>
+
+#include <atomic>
+#include <cstdint>
+#include <cstdlib>
+#include <mutex>
+#include <vector>
+
+
+static std::uint32_t g_PAGESIZE = 0;
+static std::uint32_t g_BUFSIZE  = 0;
+
+static std::atomic<std::uint_fast64_t> g_MSGBUF_ALLOC_COUNT;
+
+static std::mutex g_MUTEX;
+static std::vector<fuse_msgbuf_t*> g_MSGBUF_STACK;
+
+uint64_t
+msgbuf_get_bufsize()
+{
+  return g_BUFSIZE;
+}
+
+void
+msgbuf_set_bufsize(const uint32_t size_in_pages_)
+{
+  g_BUFSIZE = ((size_in_pages_ + 1) * g_PAGESIZE);
+}
+
+void
+msgbuf_page_align(fuse_msgbuf_t *msgbuf_)
+{
+  msgbuf_->mem   = (char*)msgbuf_;
+  msgbuf_->mem  += g_PAGESIZE;
+  msgbuf_->size  = (g_BUFSIZE - g_PAGESIZE);
+}
+
+void
+msgbuf_write_align(fuse_msgbuf_t *msgbuf_)
+{
+  msgbuf_->mem   = (char*)msgbuf_;
+  msgbuf_->mem  += g_PAGESIZE;
+  msgbuf_->mem  -= sizeof(struct fuse_in_header);
+  msgbuf_->mem  -= sizeof(struct fuse_write_in);
+  msgbuf_->size  = (g_BUFSIZE - g_PAGESIZE);
+}
+
+static
+__attribute__((constructor))
+void
+msgbuf_constructor()
+{
+  g_PAGESIZE = sysconf(_SC_PAGESIZE);
+  // FUSE_MAX_MAX_PAGES for payload + 1 for message header
+  msgbuf_set_bufsize(FUSE_MAX_MAX_PAGES + 1);
+}
+
+static
+__attribute__((destructor))
+void
+msgbuf_destroy()
+{
+
+}
+
+static
+void*
+page_aligned_malloc(const uint64_t size_)
+{
+  int rv;
+  void *buf = NULL;
+
+  rv = posix_memalign(&buf,g_PAGESIZE,size_);
+  if(rv != 0)
+    return NULL;
+
+  return buf;
+}
+
+typedef void (*msgbuf_setup_func_t)(fuse_msgbuf_t*);
+
+static
+fuse_msgbuf_t*
+_msgbuf_alloc(msgbuf_setup_func_t setup_func_)
+{
+  fuse_msgbuf_t *msgbuf;
+
+  g_MUTEX.lock();
+  if(g_MSGBUF_STACK.empty())
+    {
+      g_MUTEX.unlock();
+
+      msgbuf = (fuse_msgbuf_t*)page_aligned_malloc(g_BUFSIZE);
+      if(msgbuf == NULL)
+        return NULL;
+
+      g_MSGBUF_ALLOC_COUNT.fetch_add(1,std::memory_order_relaxed);
+    }
+  else
+    {
+      msgbuf = g_MSGBUF_STACK.back();
+      g_MSGBUF_STACK.pop_back();
+      g_MUTEX.unlock();
+    }
+
+  setup_func_(msgbuf);
+
+  return msgbuf;
+}
+
+// Offset the memory so write request payload will be placed on page
+// boundry so O_DIRECT can work. No impact on other message types
+// except for `read` which will require using `msgbuf_page_align`.
+fuse_msgbuf_t*
+msgbuf_alloc()
+{
+  return _msgbuf_alloc(msgbuf_write_align);
+}
+
+fuse_msgbuf_t*
+msgbuf_alloc_page_aligned()
+{
+  return _msgbuf_alloc(msgbuf_page_align);
+}
+
+static
+void
+msgbuf_destroy(fuse_msgbuf_t *msgbuf_)
+{
+  //  free(msgbuf_->mem);
+  free(msgbuf_);
+}
+
+void
+msgbuf_free(fuse_msgbuf_t *msgbuf_)
+{
+  std::lock_guard<std::mutex> lck(g_MUTEX);
+
+  if(msgbuf_->size != (g_BUFSIZE - g_PAGESIZE))
+    {
+      msgbuf_destroy(msgbuf_);
+      g_MSGBUF_ALLOC_COUNT.fetch_sub(1,std::memory_order_relaxed);
+      return;
+    }
+
+  g_MSGBUF_STACK.emplace_back(msgbuf_);
+
+}
+
+uint64_t
+msgbuf_alloc_count()
+{
+  return g_MSGBUF_ALLOC_COUNT;
+}
+
+uint64_t
+msgbuf_avail_count()
+{
+  std::lock_guard<std::mutex> lck(g_MUTEX);
+
+  return g_MSGBUF_STACK.size();
+}
+
+void
+msgbuf_gc_10percent()
+{
+  std::vector<fuse_msgbuf_t*> togc;
+
+  {
+    std::size_t size;
+    std::size_t ten_percent;
+
+    std::lock_guard<std::mutex> lck(g_MUTEX);
+
+    size        = g_MSGBUF_STACK.size();
+    ten_percent = (size / 10);
+
+    for(std::size_t i = 0; i < ten_percent; i++)
+      {
+        togc.push_back(g_MSGBUF_STACK.back());
+        g_MSGBUF_STACK.pop_back();
+      }
+  }
+
+  for(auto msgbuf : togc)
+    {
+      msgbuf_destroy(msgbuf);
+      g_MSGBUF_ALLOC_COUNT.fetch_sub(1,std::memory_order_relaxed);
+    }
+}
+
+void
+msgbuf_gc()
+{
+  std::vector<fuse_msgbuf_t*> oldstack;
+
+  {
+    std::lock_guard<std::mutex> lck(g_MUTEX);
+    oldstack.swap(g_MSGBUF_STACK);
+  }
+
+  for(auto msgbuf: oldstack)
+    {
+      msgbuf_destroy(msgbuf);
+      g_MSGBUF_ALLOC_COUNT.fetch_sub(1,std::memory_order_relaxed);
+    }
+}
@@ -0,0 +1,42 @@
+/*
+  ISC License
+
+  Copyright (c) 2022, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "fuse_msgbuf.h"
+#include "extern_c.h"
+
+EXTERN_C_BEGIN
+
+void     msgbuf_set_bufsize(const uint32_t size);
+uint64_t msgbuf_get_bufsize();
+
+fuse_msgbuf_t *msgbuf_alloc();
+fuse_msgbuf_t *msgbuf_alloc_page_aligned();
+void           msgbuf_free(fuse_msgbuf_t *msgbuf);
+
+void           msgbuf_gc();
+void           msgbuf_gc_10percent();
+
+uint64_t       msgbuf_alloc_count();
+uint64_t       msgbuf_avail_count();
+
+void           msgbuf_page_align(fuse_msgbuf_t *msgbuf);
+void           msgbuf_write_align(fuse_msgbuf_t *msgbuf);
+
+EXTERN_C_END
@@ -1,123 +0,0 @@
-/*
-  FUSE: Filesystem in Userspace
-  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB.
-*/
-
-#include "fuse_i.h"
-#include "fuse_misc.h"
-#include "fuse_lowlevel.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <pthread.h>
-#include <assert.h>
-
-struct procdata
-{
-  struct fuse *f;
-  struct fuse_chan *prevch;
-  struct fuse_session *prevse;
-  fuse_processor_t proc;
-  void *data;
-};
-
-static void mt_session_proc(void *data, const char *buf, size_t len,
-			    struct fuse_chan *ch)
-{
-  struct procdata *pd = (struct procdata *) data;
-  struct fuse_cmd *cmd = *(struct fuse_cmd **) buf;
-
-  (void) len;
-  (void) ch;
-  pd->proc(pd->f, cmd, pd->data);
-}
-
-static void mt_session_exit(void *data, int val)
-{
-  struct procdata *pd = (struct procdata *) data;
-  if (val)
-    fuse_session_exit(pd->prevse);
-  else
-    fuse_session_reset(pd->prevse);
-}
-
-static int mt_session_exited(void *data)
-{
-  struct procdata *pd = (struct procdata *) data;
-  return fuse_session_exited(pd->prevse);
-}
-
-static int mt_chan_receive(struct fuse_chan **chp, char *buf, size_t size)
-{
-  struct fuse_cmd *cmd;
-  struct procdata *pd = (struct procdata *) fuse_chan_data(*chp);
-
-  assert(size >= sizeof(cmd));
-
-  cmd = fuse_read_cmd(pd->f);
-  if (cmd == NULL)
-    return 0;
-
-  *(struct fuse_cmd **)buf = cmd;
-
-  return sizeof(cmd);
-}
-
-int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data)
-{
-  int res;
-  struct procdata pd;
-  struct fuse_session *prevse = fuse_get_session(f);
-  struct fuse_session *se;
-  struct fuse_chan *prevch = fuse_session_next_chan(prevse, NULL);
-  struct fuse_chan *ch;
-  struct fuse_session_ops sop = {
-    .exit = mt_session_exit,
-    .exited = mt_session_exited,
-    .process = mt_session_proc,
-  };
-  struct fuse_chan_ops cop = {
-    .receive = mt_chan_receive,
-  };
-
-  pd.f = f;
-  pd.prevch = prevch;
-  pd.prevse = prevse;
-  pd.proc = proc;
-  pd.data = data;
-
-  se = fuse_session_new(&sop, &pd);
-  if (se == NULL)
-    return -1;
-
-  ch = fuse_chan_new(&cop, fuse_chan_fd(prevch),
-                     sizeof(struct fuse_cmd *), &pd);
-  if (ch == NULL) {
-    fuse_session_destroy(se);
-    return -1;
-  }
-  fuse_session_add_chan(se, ch);
-  res = fuse_session_loop_mt(se,
-                             fuse_config_num_threads(f));
-  fuse_session_destroy(se);
-  return res;
-}
-
-int fuse_loop_mt(struct fuse *f)
-{
-  if (f == NULL)
-    return -1;
-
-  int res = fuse_start_cleanup_thread(f);
-  if (res)
-    return -1;
-
-  res = fuse_session_loop_mt(fuse_get_session(f),
-                             fuse_config_num_threads(f));
-  fuse_stop_cleanup_thread(f);
-  return res;
-}
@@ -0,0 +1,224 @@
+#include "fuse_node.h"
+
+#include "khash.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <stdio.h> // for debugging
+
+#define UNKNOWN_INO    UINT64_MAX
+#define ROOT_NODE_ID   0
+#define ROOT_NODE_NAME "/"
+
+typedef struct node_idname_t node_idname_t;
+struct node_idname_t
+{
+  uint64_t    id;
+  const char *name;
+};
+
+static khint_t idname_hash_func(const node_idname_t idname);
+static int     idname_hash_equal(const node_idname_t idname0, const node_idname_t idname1);
+
+KHASH_INIT(node,node_idname_t,fuse_node_t*,1,idname_hash_func,idname_hash_equal);
+
+typedef struct fuse_node_hashtable_t fuse_node_hashtable_t;
+struct fuse_node_hashtable_t
+{
+  kh_node_t *ht;
+  uint64_t   id;
+  uint64_t   generation;
+};
+
+static
+inline
+khint_t
+idname_hash_func(const node_idname_t idname_)
+{
+  if(idname_.name == NULL)
+    return idname_.id;
+  return (idname_.id ^ kh_str_hash_func(idname_.name));
+}
+
+static
+inline
+int
+idname_hash_equal(const node_idname_t idname0_,
+                  const node_idname_t idname1_)
+{
+  return ((idname0_.id == idname1_.id) &&
+          ((idname0_.name == idname1_.name) ||
+           (strcmp(idname0_.name,idname1_.name) == 0)));
+}
+
+static
+inline
+fuse_node_t*
+fuse_node_alloc(const uint64_t  id_,
+                const char     *name_)
+{
+  fuse_node_t *node;
+
+  node = (fuse_node_t*)calloc(1,sizeof(fuse_node_t));
+
+  node->id           = id_;
+  node->name         = strdup(name_);
+  node->ref_count    = 1;
+  node->lookup_count = 1;
+
+  return node;
+}
+
+static
+inline
+void
+fuse_node_free(fuse_node_t *node_)
+{
+  free(node_->name);
+  free(node_);
+}
+
+static
+inline
+uint64_t
+rand64()
+{
+  uint64_t rv;
+
+  rv   = rand();
+  rv <<= 32;
+  rv  |= rand();
+
+  return rv;
+}
+
+static
+inline
+void
+node_hashtable_gen_unique_id(fuse_node_hashtable_t *ht_)
+{
+  do
+    {
+      ht_->id++;
+      if(ht_->id == 0)
+        ht_->generation++;
+    }
+  while((ht_->id == 0) || (ht_->id == UNKNOWN_INO));
+}
+
+static
+inline
+void
+node_hashtable_put_root(fuse_node_hashtable_t *ht_)
+{
+  int rv;
+  khint_t k;
+  fuse_node_t *root_node;
+  const node_idname_t idname0 = {ROOT_NODE_ID,""};
+  const node_idname_t idname1 = {ROOT_NODE_ID,ROOT_NODE_NAME};
+
+  root_node = fuse_node_alloc(ROOT_NODE_ID,ROOT_NODE_NAME);
+
+  k = kh_put_node(ht_->ht,idname0,&rv);
+  kh_value(ht_->ht,k) = root_node;
+
+  k = kh_put_node(ht_->ht,idname1,&rv);
+  kh_value(ht_->ht,k) = root_node;
+}
+
+static
+inline
+void
+node_hashtable_set_id_gen(fuse_node_hashtable_t *ht_,
+                          fuse_node_t           *node_)
+{
+  node_hashtable_gen_unique_id(ht_);
+  node_->id         = ht_->id;
+  node_->generation = ht_->generation;
+}
+
+fuse_node_hashtable_t*
+fuse_node_hashtable_init()
+{
+  fuse_node_hashtable_t *ht;
+
+  ht = (fuse_node_hashtable_t*)calloc(sizeof(fuse_node_hashtable_t),1);
+  if(ht == NULL)
+    return NULL;
+
+  ht->ht = kh_init_node();
+  if(ht->ht == NULL)
+    {
+      free(ht);
+      return NULL;
+    }
+
+  srand(time(NULL));
+  ht->id         = 0;
+  ht->generation = rand64();
+
+  node_hashtable_put_root(ht);
+
+  return ht;
+}
+
+fuse_node_t*
+fuse_node_hashtable_put(fuse_node_hashtable_t *ht_,
+                        const uint64_t         parent_id_,
+                        const uint64_t         child_id_,
+                        const char            *child_name_)
+{
+  int rv;
+  khint_t k;
+  fuse_node_t *child_node;
+  const node_idname_t p_idname  = {parent_id_,""};
+  const node_idname_t c0_idname = {child_id_,child_name_};
+  const node_idname_t c1_idname = {parent_id_,child_name_};
+
+  child_node = fuse_node_alloc(child_id_,child_name_);
+
+  k = kh_get_node(ht_->ht,p_idname);
+  child_node->parent = kh_value(ht_->ht,k);
+  child_node->parent->ref_count++;
+
+  k = kh_put_node(ht_->ht,c0_idname,&rv);
+  kh_value(ht_->ht,k) = child_node;
+
+  k = kh_put_node(ht_->ht,c1_idname,&rv);
+  kh_value(ht_->ht,k) = child_node;
+
+  return child_node;
+}
+
+fuse_node_t*
+fuse_node_hashtable_get(fuse_node_hashtable_t *ht_,
+                        const uint64_t         id_)
+{
+  return fuse_node_hashtable_get_child(ht_,id_,"");
+}
+
+fuse_node_t*
+fuse_node_hashtable_get_child(fuse_node_hashtable_t *ht_,
+                              const uint64_t         parent_id_,
+                              const char            *child_name_)
+{
+  khint_t k;
+  fuse_node_t *node;
+  const node_idname_t idname = {parent_id_,child_name_};
+
+  k = kh_get_node(ht_->ht,idname);
+  node = ((k != kh_end(ht_->ht)) ?
+          kh_value(ht_->ht,k) :
+          NULL);
+
+  return node;
+}
+
+void
+fuse_node_hashtable_del(fuse_node_hashtable_t *ht_,
+                        fuse_node_t           *node_)
+{
+
+}
@@ -0,0 +1,36 @@
+#include <stdint.h>
+
+typedef struct fuse_node_t fuse_node_t;
+struct fuse_node_t
+{
+  uint64_t     id;
+  uint64_t     generation;  
+  char        *name;
+  fuse_node_t *parent;
+  uint32_t     ref_count;
+  uint64_t     lookup_count;
+  uint64_t     open_count;
+};
+
+struct fuse_node_hashtable_t;
+typedef struct fuse_node_hashtable_t fuse_node_hashtable_t;
+
+
+fuse_node_hashtable_t *fuse_node_hashtable_init();
+
+fuse_node_t *fuse_node_hashtable_put(fuse_node_hashtable_t *ht,
+                                     const uint64_t         parent_id,
+                                     const uint64_t         child_id,
+                                     const char            *child_name);
+
+fuse_node_t* fuse_node_hashtable_get(fuse_node_hashtable_t *ht,
+                                     const uint64_t         id);
+fuse_node_t* fuse_node_hashtable_get_child(fuse_node_hashtable_t *ht,
+                                           const uint64_t         id,
+                                           const char            *name);
+void fuse_node_hashtable_del(fuse_node_hashtable_t *ht,
+                             fuse_node_t           *node);
+
+void fuse_node_hashtable_get_path(fuse_node_hashtable_t *ht,
+                                  char                  *buf,
+                                  uint32_t               buflen);
@@ -8,23 +8,29 @@

 #include "fuse_i.h"
 #include "fuse_misc.h"
+#include "fuse_kernel.h"

+#include <assert.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <assert.h>
-#include <errno.h>
+#include <unistd.h>
+#include <sys/uio.h>
+

 struct fuse_chan
 {
-  struct fuse_chan_ops op;
  struct fuse_session *se;
  int fd;
  size_t bufsize;
-  void *data;
 };

-struct fuse_session *fuse_session_new(struct fuse_session_ops *op, void *data)
+struct fuse_session *
+fuse_session_new(void *data,
+                 void *receive_buf,
+                 void *process_buf,
+                 void *destroy)
 {
  struct fuse_session *se = (struct fuse_session *) malloc(sizeof(*se));
  if (se == NULL) {
@@ -33,8 +39,10 @@ struct fuse_session *fuse_session_new(struct fuse_session_ops *op, void *data)
  }

  memset(se, 0, sizeof(*se));
-  se->op = *op;
-  se->data = data;
+  se->f           = data;
+  se->receive_buf = receive_buf;
+  se->process_buf = process_buf;
+  se->destroy     = destroy;

  return se;
 }
@@ -57,110 +65,59 @@ void fuse_session_remove_chan(struct fuse_chan *ch)
  }
 }

-struct fuse_chan *fuse_session_next_chan(struct fuse_session *se,
-					 struct fuse_chan *ch)
+void
+fuse_session_destroy(struct fuse_session *se)
 {
-  assert(ch == NULL || ch == se->ch);
-  if (ch == NULL)
-    return se->ch;
-  else
-    return NULL;
-}
-
-void fuse_session_process(struct fuse_session *se, const char *buf, size_t len,
-			  struct fuse_chan *ch)
-{
-  se->op.process(se->data, buf, len, ch);
-}
-
-void fuse_session_process_buf(struct fuse_session *se,
-			      const struct fuse_buf *buf, struct fuse_chan *ch)
-{
-  if (se->process_buf) {
-    se->process_buf(se->data, buf, ch);
-  } else {
-    assert(!(buf->flags & FUSE_BUF_IS_FD));
-    fuse_session_process(se->data, buf->mem, buf->size, ch);
-  }
-}
-
-int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf,
-			     struct fuse_chan **chp)
-{
-  int res;
-
-  if (se->receive_buf) {
-    res = se->receive_buf(se, buf, chp);
-  } else {
-    res = fuse_chan_recv(chp, buf->mem, buf->size);
-    if (res > 0)
-      buf->size = res;
-  }
-
-  return res;
-}
-
-
-void fuse_session_destroy(struct fuse_session *se)
-{
-  if (se->op.destroy)
-    se->op.destroy(se->data);
-  if (se->ch != NULL)
+  se->destroy(se->f);
+  if(se->ch != NULL)
    fuse_chan_destroy(se->ch);
  free(se);
 }

-void fuse_session_exit(struct fuse_session *se)
-{
-  if (se->op.exit)
-    se->op.exit(se->data, 1);
-  se->exited = 1;
-}
-
 void fuse_session_reset(struct fuse_session *se)
 {
-  if (se->op.exit)
-    se->op.exit(se->data, 0);
  se->exited = 0;
 }

-int fuse_session_exited(struct fuse_session *se)
+int
+fuse_session_exited(struct fuse_session *se)
 {
-  if (se->op.exited)
-    return se->op.exited(se->data);
-  else
-    return se->exited;
+  return se->exited;
 }

-void *fuse_session_data(struct fuse_session *se)
+void
+fuse_session_exit(struct fuse_session *se_)
 {
-  return se->data;
+  se_->exited = 1;
 }

-static struct fuse_chan *fuse_chan_new_common(struct fuse_chan_ops *op, int fd,
-					      size_t bufsize, void *data)
+void*
+fuse_session_data(struct fuse_session *se)
 {
-  struct fuse_chan *ch = (struct fuse_chan *) malloc(sizeof(*ch));
-  if (ch == NULL) {
-    fprintf(stderr, "fuse: failed to allocate channel\n");
-    return NULL;
-  }
+  return se->f;
+}
+
+struct fuse_chan *
+fuse_chan_new(int fd,
+              size_t bufsize)
+{
+  struct fuse_chan *ch;
+
+  ch = (struct fuse_chan*)malloc(sizeof(*ch));
+  if(ch == NULL)
+    {
+      fprintf(stderr, "fuse: failed to allocate channel\n");
+      return NULL;
+    }

  memset(ch, 0, sizeof(*ch));
-  ch->op = *op;
+
  ch->fd = fd;
  ch->bufsize = bufsize;
-  ch->data = data;

  return ch;
 }

-struct fuse_chan *fuse_chan_new(struct fuse_chan_ops *op, int fd,
-				size_t bufsize, void *data)
-{
-  return fuse_chan_new_common(op, fd, bufsize, data);
-}
-
 int fuse_chan_fd(struct fuse_chan *ch)
 {
  return ch->fd;
@@ -178,40 +135,21 @@ size_t fuse_chan_bufsize(struct fuse_chan *ch)
  return ch->bufsize;
 }

-void *fuse_chan_data(struct fuse_chan *ch)
-{
-  return ch->data;
-}
-
 struct fuse_session *fuse_chan_session(struct fuse_chan *ch)
 {
  return ch->se;
 }

-int fuse_chan_recv(struct fuse_chan **chp, char *buf, size_t size)
+void
+fuse_chan_destroy(struct fuse_chan *ch)
 {
-  struct fuse_chan *ch = *chp;
+  int fd;

-  return ch->op.receive(chp, buf, size);
-}
-
-int fuse_chan_receive(struct fuse_chan *ch, char *buf, size_t size)
-{
-  int res;
-
-  res = fuse_chan_recv(&ch, buf, size);
-  return res >= 0 ? res : (res != -EINTR && res != -EAGAIN) ? -1 : 0;
-}
-
-int fuse_chan_send(struct fuse_chan *ch, const struct iovec iov[], size_t count)
-{
-  return ch->op.send(ch, iov, count);
-}
-
-void fuse_chan_destroy(struct fuse_chan *ch)
-{
  fuse_session_remove_chan(ch);
-  if (ch->op.destroy)
-    ch->op.destroy(ch);
+
+  fd = fuse_chan_fd(ch);
+  if(fd != -1)
+    close(fd);
+
  free(ch);
 }
@@ -14,9 +14,11 @@

 static struct fuse_session *fuse_instance;

-static void exit_handler(int sig)
+static
+void
+exit_handler(int sig)
 {
-  (void) sig;
+  (void)sig;
  if (fuse_instance)
    fuse_session_exit(fuse_instance);
 }
@@ -46,10 +48,10 @@ static int set_one_signal_handler(int sig, void (*handler)(int), int remove)

 int fuse_set_signal_handlers(struct fuse_session *se)
 {
-  if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
-      set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
-      set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
-      set_one_signal_handler(SIGPIPE, SIG_IGN, 0) == -1)
+  if((set_one_signal_handler(SIGINT, exit_handler, 0)  == -1) ||
+     (set_one_signal_handler(SIGTERM, exit_handler, 0) == -1) ||
+     (set_one_signal_handler(SIGQUIT, exit_handler, 0) == -1) ||
+     (set_one_signal_handler(SIGPIPE, SIG_IGN, 0)      == -1))
    return -1;

  fuse_instance = se;
@@ -64,8 +66,8 @@ void fuse_remove_signal_handlers(struct fuse_session *se)
  else
    fuse_instance = NULL;

-  set_one_signal_handler(SIGHUP, exit_handler, 1);
  set_one_signal_handler(SIGINT, exit_handler, 1);
  set_one_signal_handler(SIGTERM, exit_handler, 1);
+  set_one_signal_handler(SIGQUIT, exit_handler, 1);
  set_one_signal_handler(SIGPIPE, SIG_IGN, 1);
 }
@@ -40,8 +40,6 @@ static
 const
 struct fuse_opt fuse_helper_opts[] =
  {
-    FUSE_HELPER_OPT("-d",	foreground),
-    FUSE_HELPER_OPT("debug",	foreground),
    FUSE_HELPER_OPT("-f",	foreground),
    FUSE_HELPER_OPT("fsname=",	nodefault_subtype),
    FUSE_HELPER_OPT("subtype=",	nodefault_subtype),
@@ -239,8 +237,10 @@ struct fuse_chan *
 fuse_mount_common(const char       *mountpoint_,
                  struct fuse_args *args_)
 {
-  struct fuse_chan *ch;
  int fd;
+  long bufsize;
+  long pagesize;
+  struct fuse_chan *ch;

  /*
   * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
@@ -257,7 +257,10 @@ fuse_mount_common(const char       *mountpoint_,
  if(fd == -1)
    return NULL;

-  ch = fuse_kern_chan_new(fd);
+  pagesize = sysconf(_SC_PAGESIZE);
+  bufsize  = ((FUSE_MAX_MAX_PAGES + 1) * pagesize);
+
+  ch = fuse_chan_new(fd,bufsize);
  if(!ch)
    fuse_kern_unmount(mountpoint_, fd);

@@ -286,12 +289,13 @@ void fuse_unmount(const char *mountpoint, struct fuse_chan *ch)
  fuse_unmount_common(mountpoint, ch);
 }

-struct fuse *fuse_setup_common(int argc, char *argv[],
-			       const struct fuse_operations *op,
-			       size_t op_size,
-			       char **mountpoint,
-			       int *fd,
-			       void *user_data)
+struct fuse *
+fuse_setup_common(int argc,
+                  char *argv[],
+                  const struct fuse_operations *op,
+                  size_t op_size,
+                  char **mountpoint,
+                  int *fd)
 {
  struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
  struct fuse_chan *ch;
@@ -309,7 +313,7 @@ struct fuse *fuse_setup_common(int argc, char *argv[],
    goto err_free;
  }

-  fuse = fuse_new_common(ch, &args, op, op_size, user_data);
+  fuse = fuse_new_common(ch, &args, op, op_size);
  fuse_opt_free_args(&args);
  if (fuse == NULL)
    goto err_unmount;
@@ -338,16 +342,16 @@ struct fuse *fuse_setup_common(int argc, char *argv[],

 struct fuse *fuse_setup(int argc, char *argv[],
 			const struct fuse_operations *op, size_t op_size,
-			char **mountpoint, void *user_data)
+			char **mountpoint)
 {
  return fuse_setup_common(argc, argv, op, op_size, mountpoint,
-                           NULL, user_data);
+                           NULL);
 }

 static void fuse_teardown_common(struct fuse *fuse, char *mountpoint)
 {
  struct fuse_session *se = fuse_get_session(fuse);
-  struct fuse_chan *ch = fuse_session_next_chan(se, NULL);
+  struct fuse_chan *ch = se->ch;
  fuse_remove_signal_handlers(se);
  fuse_unmount_common(mountpoint, ch);
  fuse_destroy(fuse);
@@ -360,8 +364,7 @@ void fuse_teardown(struct fuse *fuse, char *mountpoint)
 }

 static int fuse_main_common(int argc, char *argv[],
-			    const struct fuse_operations *op, size_t op_size,
-			    void *user_data)
+			    const struct fuse_operations *op, size_t op_size)
 {
  struct fuse *fuse;
  char *mountpoint;
@@ -369,7 +372,7 @@ static int fuse_main_common(int argc, char *argv[],

  fuse = fuse_setup_common(argc, argv, op, op_size,
                           &mountpoint,
-                           NULL, user_data);
+                           NULL);
  if (fuse == NULL)
    return 1;

@@ -382,10 +385,12 @@ static int fuse_main_common(int argc, char *argv[],
  return 0;
 }

-int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
-		   size_t op_size, void *user_data)
+int fuse_main_real(int argc,
+                   char *argv[],
+                   const struct fuse_operations *op,
+		   size_t op_size)
 {
-  return fuse_main_common(argc, argv, op, op_size, user_data);
+  return fuse_main_common(argc, argv, op, op_size);
 }

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

 enum {
-  KEY_ALLOW_ROOT,
  KEY_RO,
  KEY_HELP,
  KEY_VERSION,
@@ -37,7 +36,6 @@ enum {

 struct mount_opts {
  int allow_other;
-  int allow_root;
  int ishelp;
  char *kernel_opts;
 };
@@ -47,8 +45,6 @@ struct mount_opts {

 static const struct fuse_opt fuse_mount_opts[] = {
  { "allow_other", offsetof(struct mount_opts, allow_other), 1 },
-  { "allow_root", offsetof(struct mount_opts, allow_root), 1 },
-  FUSE_OPT_KEY("allow_root",		KEY_ALLOW_ROOT),
  FUSE_OPT_KEY("-r",			KEY_RO),
  FUSE_OPT_KEY("-h",			KEY_HELP),
  FUSE_OPT_KEY("--help",			KEY_HELP),
@@ -94,16 +90,12 @@ static const struct fuse_opt fuse_mount_opts[] = {
   * handle them
   */
  FUSE_OPT_KEY("fsname=",			KEY_KERN),
-  FUSE_OPT_KEY("nonempty",		KEY_KERN),
  FUSE_OPT_KEY("large_read",		KEY_KERN),
  FUSE_OPT_END
 };

 static void mount_help(void)
 {
-  fprintf(stderr,
-          "    -o allow_root          allow access to root\n"
-          );
  system(FUSERMOUNT_PROG " --help");
  fputc('\n', stderr);
 }
@@ -119,12 +111,6 @@ static int fuse_mount_opt_proc(void *data, const char *arg, int key,
  struct mount_opts *mo = data;

  switch (key) {
-  case KEY_ALLOW_ROOT:
-    if (fuse_opt_add_opt(&mo->kernel_opts, "allow_other") == -1 ||
-        fuse_opt_add_arg(outargs, "-oallow_root") == -1)
-      return -1;
-    return 0;
-
  case KEY_RO:
    arg = "ro";
    /* fall through */
@@ -328,10 +314,6 @@ int fuse_kern_mount(const char *mountpoint, struct fuse_args *args)
      fuse_opt_parse(args, &mo, fuse_mount_opts, fuse_mount_opt_proc) == -1)
    return -1;

-  if (mo.allow_other && mo.allow_root) {
-    fprintf(stderr, "fuse: 'allow_other' and 'allow_root' options are mutually exclusive\n");
-    goto out;
-  }
  if (mo.ishelp)
    return 0;

@@ -55,7 +55,6 @@ enum {
  KEY_FUSERMOUNT_OPT,
  KEY_SUBTYPE_OPT,
  KEY_MTAB_OPT,
-  KEY_ALLOW_ROOT,
  KEY_RO,
  KEY_HELP,
  KEY_VERSION,
@@ -63,10 +62,8 @@ enum {

 struct mount_opts {
  int allow_other;
-  int allow_root;
  int ishelp;
  int flags;
-  int nonempty;
  int auto_unmount;
  int blkdev;
  char *fsname;
@@ -80,19 +77,15 @@ struct mount_opts {
 #define FUSE_MOUNT_OPT(t, p) { t, offsetof(struct mount_opts, p), 1 }

 static const struct fuse_opt fuse_mount_opts[] = {
-  FUSE_MOUNT_OPT("allow_other",		allow_other),
-  FUSE_MOUNT_OPT("allow_root",		allow_root),
-  FUSE_MOUNT_OPT("nonempty",		nonempty),
+  FUSE_MOUNT_OPT("allow_other",         allow_other),
  FUSE_MOUNT_OPT("blkdev",		blkdev),
-  FUSE_MOUNT_OPT("auto_unmount",		auto_unmount),
+  FUSE_MOUNT_OPT("auto_unmount",	auto_unmount),
  FUSE_MOUNT_OPT("fsname=%s",		fsname),
  FUSE_MOUNT_OPT("subtype=%s",		subtype),
-  FUSE_OPT_KEY("allow_other",		KEY_KERN_OPT),
-  FUSE_OPT_KEY("allow_root",		KEY_ALLOW_ROOT),
-  FUSE_OPT_KEY("nonempty",		KEY_FUSERMOUNT_OPT),
+  FUSE_OPT_KEY("allow_other",           KEY_KERN_OPT),
  FUSE_OPT_KEY("auto_unmount",		KEY_FUSERMOUNT_OPT),
-  FUSE_OPT_KEY("blkdev",			KEY_FUSERMOUNT_OPT),
-  FUSE_OPT_KEY("fsname=",			KEY_FUSERMOUNT_OPT),
+  FUSE_OPT_KEY("blkdev",		KEY_FUSERMOUNT_OPT),
+  FUSE_OPT_KEY("fsname=",		KEY_FUSERMOUNT_OPT),
  FUSE_OPT_KEY("subtype=",		KEY_SUBTYPE_OPT),
  FUSE_OPT_KEY("large_read",		KEY_KERN_OPT),
  FUSE_OPT_KEY("blksize=",		KEY_KERN_OPT),
@@ -108,18 +101,18 @@ static const struct fuse_opt fuse_mount_opts[] = {
  FUSE_OPT_KEY("ro",			KEY_KERN_FLAG),
  FUSE_OPT_KEY("rw",			KEY_KERN_FLAG),
  FUSE_OPT_KEY("suid",			KEY_KERN_FLAG),
-  FUSE_OPT_KEY("nosuid",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("nosuid",		KEY_KERN_FLAG),
  FUSE_OPT_KEY("dev",			KEY_KERN_FLAG),
  FUSE_OPT_KEY("nodev",			KEY_KERN_FLAG),
  FUSE_OPT_KEY("exec",			KEY_KERN_FLAG),
-  FUSE_OPT_KEY("noexec",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("noexec",		KEY_KERN_FLAG),
  FUSE_OPT_KEY("async",			KEY_KERN_FLAG),
  FUSE_OPT_KEY("sync",			KEY_KERN_FLAG),
-  FUSE_OPT_KEY("dirsync",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("dirsync",		KEY_KERN_FLAG),
  FUSE_OPT_KEY("atime",			KEY_KERN_FLAG),
-  FUSE_OPT_KEY("noatime",			KEY_KERN_FLAG),
+  FUSE_OPT_KEY("noatime",		KEY_KERN_FLAG),
  FUSE_OPT_KEY("-h",			KEY_HELP),
-  FUSE_OPT_KEY("--help",			KEY_HELP),
+  FUSE_OPT_KEY("--help",		KEY_HELP),
  FUSE_OPT_KEY("-V",			KEY_VERSION),
  FUSE_OPT_KEY("--version",		KEY_VERSION),
  FUSE_OPT_END
@@ -128,10 +121,7 @@ static const struct fuse_opt fuse_mount_opts[] = {
 static void mount_help(void)
 {
  fprintf(stderr,
-          "    -o allow_other         allow access to other users\n"
-          "    -o allow_root          allow access to root\n"
          "    -o auto_unmount        auto unmount on process termination\n"
-          "    -o nonempty            allow mounts over non-empty file/dir\n"
          "    -o default_permissions enable permission checking by kernel\n"
          "    -o fsname=NAME         set filesystem name\n"
          "    -o subtype=NAME        set filesystem type\n"
@@ -208,12 +198,6 @@ static int fuse_mount_opt_proc(void *data, const char *arg, int key,
  struct mount_opts *mo = data;

  switch (key) {
-  case KEY_ALLOW_ROOT:
-    if (fuse_opt_add_opt(&mo->kernel_opts, "allow_other") == -1 ||
-        fuse_opt_add_arg(outargs, "-oallow_root") == -1)
-      return -1;
-    return 0;
-
  case KEY_RO:
    arg = "ro";
    /* fall through */
@@ -435,13 +419,6 @@ static int fuse_mount_sys(const char *mnt, struct mount_opts *mo,
    return -1;
  }

-  if (!mo->nonempty) {
-    res = fuse_mnt_check_empty("fuse", mnt, stbuf.st_mode,
-                               stbuf.st_size);
-    if (res == -1)
-      return -1;
-  }
-
  if (mo->auto_unmount) {
    /* Tell the caller to fallback to fusermount because
       auto-unmount does not work otherwise. */
@@ -575,10 +552,6 @@ int fuse_kern_mount(const char *mountpoint, struct fuse_args *args)
      fuse_opt_parse(args, &mo, fuse_mount_opts, fuse_mount_opt_proc) == -1)
    return -1;

-  if (mo.allow_other && mo.allow_root) {
-    fprintf(stderr, "fuse: 'allow_other' and 'allow_root' options are mutually exclusive\n");
-    goto out;
-  }
  res = 0;
  if (mo.ishelp)
    goto out;
@@ -312,39 +312,6 @@ char *fuse_mnt_resolve_path(const char *progname, const char *orig)
  return dst;
 }

-int fuse_mnt_check_empty(const char *progname, const char *mnt,
-			 mode_t rootmode, off_t rootsize)
-{
-  int isempty = 1;
-
-  if (S_ISDIR(rootmode)) {
-    struct dirent *ent;
-    DIR *dp = opendir(mnt);
-    if (dp == NULL) {
-      fprintf(stderr,
-              "%s: failed to open mountpoint for reading: %s\n",
-              progname, strerror(errno));
-      return -1;
-    }
-    while ((ent = readdir(dp)) != NULL) {
-      if (strcmp(ent->d_name, ".") != 0 &&
-          strcmp(ent->d_name, "..") != 0) {
-        isempty = 0;
-        break;
-      }
-    }
-    closedir(dp);
-  } else if (rootsize)
-    isempty = 0;
-
-  if (!isempty) {
-    fprintf(stderr, "%s: mountpoint is not empty\n", progname);
-    fprintf(stderr, "%s: if you are sure this is safe, use the 'nonempty' mount option\n", progname);
-    return -1;
-  }
-  return 0;
-}
-
 int fuse_mnt_check_fuseblk(void)
 {
  char buf[256];
@@ -16,6 +16,4 @@ int fuse_mnt_remove_mount(const char *progname, const char *mnt);
 int fuse_mnt_umount(const char *progname, const char *abs_mnt,
 		    const char *rel_mnt, int lazy);
 char *fuse_mnt_resolve_path(const char *progname, const char *orig);
-int fuse_mnt_check_empty(const char *progname, const char *mnt,
-			 mode_t rootmode, off_t rootsize);
 int fuse_mnt_check_fuseblk(void);
@@ -0,0 +1,60 @@
+#include "node.h"
+
+#include "lfmp.h"
+
+static lfmp_t g_NODE_FMP;
+
+static
+__attribute__((constructor))
+void
+node_constructor()
+{
+  lfmp_init(&g_NODE_FMP,sizeof(node_t),256);
+}
+
+static
+__attribute__((destructor))
+void
+node_destructor()
+{
+  lfmp_destroy(&g_NODE_FMP);
+}
+
+node_t *
+node_alloc()
+{
+  return lfmp_calloc(&g_NODE_FMP);
+}
+
+void
+node_free(node_t *node_)
+{
+  lfmp_free(&g_NODE_FMP,node_);
+}
+
+int
+node_gc1()
+{
+  return lfmp_gc(&g_NODE_FMP);
+}
+
+void
+node_gc()
+{
+  int rv;
+  int fails;
+
+  fails = 0;
+  do
+    {
+      rv = node_gc1();
+      if(rv == 0)
+        fails++;
+    } while(rv || (fails < 3));
+}
+
+lfmp_t*
+node_lfmp()
+{
+  return &g_NODE_FMP;
+}
@@ -0,0 +1,30 @@
+#include "lock.h"
+#include "lfmp.h"
+
+typedef struct node_s node_t;
+struct node_s
+{
+  node_t *name_next;
+  node_t *id_next;
+
+  uint64_t nodeid;
+  char *name;
+  node_t *parent;
+
+  uint64_t nlookup;
+  uint32_t refctr;
+  uint32_t open_count;
+  uint64_t hidden_fh;
+
+  int32_t treelock;
+  lock_t *locks;
+
+  uint32_t stat_crc32b;
+  uint8_t is_stat_cache_valid:1;
+};
+
+node_t *node_alloc();
+void    node_free(node_t*);
+int     node_gc1();
+void    node_gc();
+lfmp_t *node_lfmp();
@@ -0,0 +1,361 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Disable bogus MSVC warnings.
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "fmt/os.h"
+
+#include <climits>
+
+#if FMT_USE_FCNTL
+#  include <sys/stat.h>
+#  include <sys/types.h>
+
+#  ifndef _WIN32
+#    include <unistd.h>
+#  else
+#    ifndef WIN32_LEAN_AND_MEAN
+#      define WIN32_LEAN_AND_MEAN
+#    endif
+#    include <io.h>
+
+#    ifndef S_IRUSR
+#      define S_IRUSR _S_IREAD
+#    endif
+#    ifndef S_IWUSR
+#      define S_IWUSR _S_IWRITE
+#    endif
+#    ifndef S_IRGRP
+#      define S_IRGRP 0
+#    endif
+#    ifndef S_IWGRP
+#      define S_IWGRP 0
+#    endif
+#    ifndef S_IROTH
+#      define S_IROTH 0
+#    endif
+#    ifndef S_IWOTH
+#      define S_IWOTH 0
+#    endif
+#  endif  // _WIN32
+#endif    // FMT_USE_FCNTL
+
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+namespace {
+#ifdef _WIN32
+// Return type of read and write functions.
+using rwresult = int;
+
+// On Windows the count argument to read and write is unsigned, so convert
+// it from size_t preventing integer overflow.
+inline unsigned convert_rwcount(std::size_t count) {
+  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
+}
+#elif FMT_USE_FCNTL
+// Return type of read and write functions.
+using rwresult = ssize_t;
+
+inline std::size_t convert_rwcount(std::size_t count) { return count; }
+#endif
+}  // namespace
+
+FMT_BEGIN_NAMESPACE
+
+#ifdef _WIN32
+detail::utf16_to_utf8::utf16_to_utf8(basic_string_view<wchar_t> s) {
+  if (int error_code = convert(s)) {
+    FMT_THROW(windows_error(error_code,
+                            "cannot convert string from UTF-16 to UTF-8"));
+  }
+}
+
+int detail::utf16_to_utf8::convert(basic_string_view<wchar_t> s) {
+  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
+  int s_size = static_cast<int>(s.size());
+  if (s_size == 0) {
+    // WideCharToMultiByte does not support zero length, handle separately.
+    buffer_.resize(1);
+    buffer_[0] = 0;
+    return 0;
+  }
+
+  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0,
+                                   nullptr, nullptr);
+  if (length == 0) return GetLastError();
+  buffer_.resize(length + 1);
+  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
+                               length, nullptr, nullptr);
+  if (length == 0) return GetLastError();
+  buffer_[length] = 0;
+  return 0;
+}
+
+namespace detail {
+
+class system_message {
+  system_message(const system_message&) = delete;
+  void operator=(const system_message&) = delete;
+
+  unsigned long result_;
+  wchar_t* message_;
+
+  static bool is_whitespace(wchar_t c) noexcept {
+    return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
+  }
+
+ public:
+  explicit system_message(unsigned long error_code)
+      : result_(0), message_(nullptr) {
+    result_ = FormatMessageW(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+        nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        reinterpret_cast<wchar_t*>(&message_), 0, nullptr);
+    if (result_ != 0) {
+      while (result_ != 0 && is_whitespace(message_[result_ - 1])) {
+        --result_;
+      }
+    }
+  }
+  ~system_message() { LocalFree(message_); }
+  explicit operator bool() const noexcept { return result_ != 0; }
+  operator basic_string_view<wchar_t>() const noexcept {
+    return basic_string_view<wchar_t>(message_, result_);
+  }
+};
+
+class utf8_system_category final : public std::error_category {
+ public:
+  const char* name() const noexcept override { return "system"; }
+  std::string message(int error_code) const override {
+    system_message msg(error_code);
+    if (msg) {
+      utf16_to_utf8 utf8_message;
+      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+        return utf8_message.str();
+      }
+    }
+    return "unknown error";
+  }
+};
+
+}  // namespace detail
+
+FMT_API const std::error_category& system_category() noexcept {
+  static const detail::utf8_system_category category;
+  return category;
+}
+
+std::system_error vwindows_error(int err_code, string_view format_str,
+                                 format_args args) {
+  auto ec = std::error_code(err_code, system_category());
+  return std::system_error(ec, vformat(format_str, args));
+}
+
+void detail::format_windows_error(detail::buffer<char>& out, int error_code,
+                                  const char* message) noexcept {
+  FMT_TRY {
+    system_message msg(error_code);
+    if (msg) {
+      utf16_to_utf8 utf8_message;
+      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+        fmt::format_to(buffer_appender<char>(out), "{}: {}", message, utf8_message);
+        return;
+      }
+    }
+  }
+  FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+void report_windows_error(int error_code, const char* message) noexcept {
+  report_error(detail::format_windows_error, error_code, message);
+}
+#endif  // _WIN32
+
+buffered_file::~buffered_file() noexcept {
+  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
+  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
+                nullptr);
+  if (!file_)
+    FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
+}
+
+void buffered_file::close() {
+  if (!file_) return;
+  int result = FMT_SYSTEM(fclose(file_));
+  file_ = nullptr;
+  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+}
+
+int buffered_file::descriptor() const {
+  int fd = FMT_POSIX_CALL(fileno(file_));
+  if (fd == -1) FMT_THROW(system_error(errno, "cannot get file descriptor"));
+  return fd;
+}
+
+#if FMT_USE_FCNTL
+file::file(cstring_view path, int oflag) {
+#  ifdef _WIN32
+  using mode_t = int;
+#  endif
+  constexpr mode_t mode =
+      S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
+#  if defined(_WIN32) && !defined(__MINGW32__)
+  fd_ = -1;
+  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
+#  else
+  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
+#  endif
+  if (fd_ == -1)
+    FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
+}
+
+file::~file() noexcept {
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+void file::close() {
+  if (fd_ == -1) return;
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  int result = FMT_POSIX_CALL(close(fd_));
+  fd_ = -1;
+  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+}
+
+long long file::size() const {
+#  ifdef _WIN32
+  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
+  // is less than 0x0500 as is the case with some default MinGW builds.
+  // Both functions support large file sizes.
+  DWORD size_upper = 0;
+  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
+  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
+  if (size_lower == INVALID_FILE_SIZE) {
+    DWORD error = GetLastError();
+    if (error != NO_ERROR)
+      FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
+  }
+  unsigned long long long_size = size_upper;
+  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
+#  else
+  using Stat = struct stat;
+  Stat file_stat = Stat();
+  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
+    FMT_THROW(system_error(errno, "cannot get file attributes"));
+  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
+                "return type of file::size is not large enough");
+  return file_stat.st_size;
+#  endif
+}
+
+std::size_t file::read(void* buffer, std::size_t count) {
+  rwresult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
+  if (result < 0) FMT_THROW(system_error(errno, "cannot read from file"));
+  return detail::to_unsigned(result);
+}
+
+std::size_t file::write(const void* buffer, std::size_t count) {
+  rwresult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
+  if (result < 0) FMT_THROW(system_error(errno, "cannot write to file"));
+  return detail::to_unsigned(result);
+}
+
+file file::dup(int fd) {
+  // Don't retry as dup doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
+  int new_fd = FMT_POSIX_CALL(dup(fd));
+  if (new_fd == -1)
+    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));
+  return file(new_fd);
+}
+
+void file::dup2(int fd) {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) {
+    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {} to {}",
+                           fd_, fd));
+  }
+}
+
+void file::dup2(int fd, std::error_code& ec) noexcept {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) ec = std::error_code(errno, std::generic_category());
+}
+
+void file::pipe(file& read_end, file& write_end) {
+  // Close the descriptors first to make sure that assignments don't throw
+  // and there are no leaks.
+  read_end.close();
+  write_end.close();
+  int fds[2] = {};
+#  ifdef _WIN32
+  // Make the default pipe capacity same as on Linux 2.6.11+.
+  enum { DEFAULT_CAPACITY = 65536 };
+  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
+#  else
+  // Don't retry as the pipe function doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
+  int result = FMT_POSIX_CALL(pipe(fds));
+#  endif
+  if (result != 0) FMT_THROW(system_error(errno, "cannot create pipe"));
+  // The following assignments don't throw because read_fd and write_fd
+  // are closed.
+  read_end = file(fds[0]);
+  write_end = file(fds[1]);
+}
+
+buffered_file file::fdopen(const char* mode) {
+// Don't retry as fdopen doesn't return EINTR.
+#  if defined(__MINGW32__) && defined(_POSIX_)
+  FILE* f = ::fdopen(fd_, mode);
+#  else
+  FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
+#  endif
+  if (!f)
+    FMT_THROW(
+        system_error(errno, "cannot associate stream with file descriptor"));
+  buffered_file bf(f);
+  fd_ = -1;
+  return bf;
+}
+
+long getpagesize() {
+#  ifdef _WIN32
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return si.dwPageSize;
+#  else
+  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
+  if (size < 0) FMT_THROW(system_error(errno, "cannot get memory page size"));
+  return size;
+#  endif
+}
+
+FMT_API void ostream::grow(size_t) {
+  if (this->size() == this->capacity()) flush();
+}
+#endif  // FMT_USE_FCNTL
+FMT_END_NAMESPACE
@@ -0,0 +1,369 @@
+//   _____                         _____                     _    _____
+//  / ____|                       / ____|                   | |  / ____|_     _
+// | (___   ___ ___  _ __   ___  | |  __ _   _  __ _ _ __ __| | | |   _| |_ _| |_
+//  \___ \ / __/ _ \| '_ \ / _ \ | | |_ | | | |/ _` | '__/ _` | | |  |_   _|_   _|
+//  ____) | (_| (_) | |_) |  __/ | |__| | |_| | (_| | | | (_| | | |____|_|   |_|
+// |_____/ \___\___/| .__/ \___|  \_____|\__,_|\__,_|_|  \__,_|  \_____|
+//                  | | https://github.com/Neargye/scope_guard
+//                  |_| version 0.9.1
+//
+// Licensed under the MIT License <http://opensource.org/licenses/MIT>.
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2018 - 2021 Daniil Goncharov <neargye@gmail.com>.
+//
+// Permission is hereby  granted, free of charge, to any  person obtaining a copy
+// of this software and associated  documentation files (the "Software"), to deal
+// in the Software  without restriction, including without  limitation the rights
+// to  use, copy,  modify, merge,  publish, distribute,  sublicense, and/or  sell
+// copies  of  the Software,  and  to  permit persons  to  whom  the Software  is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE  IS PROVIDED "AS  IS", WITHOUT WARRANTY  OF ANY KIND,  EXPRESS OR
+// IMPLIED,  INCLUDING BUT  NOT  LIMITED TO  THE  WARRANTIES OF  MERCHANTABILITY,
+// FITNESS FOR  A PARTICULAR PURPOSE AND  NONINFRINGEMENT. IN NO EVENT  SHALL THE
+// AUTHORS  OR COPYRIGHT  HOLDERS  BE  LIABLE FOR  ANY  CLAIM,  DAMAGES OR  OTHER
+// LIABILITY, WHETHER IN AN ACTION OF  CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE  OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+#ifndef NEARGYE_SCOPE_GUARD_HPP
+#define NEARGYE_SCOPE_GUARD_HPP
+
+#define SCOPE_GUARD_VERSION_MAJOR 0
+#define SCOPE_GUARD_VERSION_MINOR 9
+#define SCOPE_GUARD_VERSION_PATCH 1
+
+#include <type_traits>
+#if (defined(_MSC_VER) && _MSC_VER >= 1900) || ((defined(__clang__) || defined(__GNUC__)) && __cplusplus >= 201700L)
+#include <exception>
+#endif
+
+// scope_guard throwable settings:
+// SCOPE_GUARD_NO_THROW_CONSTRUCTIBLE requires nothrow constructible action.
+// SCOPE_GUARD_MAY_THROW_ACTION action may throw exceptions.
+// SCOPE_GUARD_NO_THROW_ACTION requires noexcept action.
+// SCOPE_GUARD_SUPPRESS_THROW_ACTION exceptions during action will be suppressed.
+// SCOPE_GUARD_CATCH_HANDLER exceptions handler. If SCOPE_GUARD_SUPPRESS_THROW_ACTIONS is not defined, it will do nothing.
+
+#if !defined(SCOPE_GUARD_MAY_THROW_ACTION) && !defined(SCOPE_GUARD_NO_THROW_ACTION) && !defined(SCOPE_GUARD_SUPPRESS_THROW_ACTION)
+#  define SCOPE_GUARD_MAY_THROW_ACTION
+#elif (defined(SCOPE_GUARD_MAY_THROW_ACTION) + defined(SCOPE_GUARD_NO_THROW_ACTION) + defined(SCOPE_GUARD_SUPPRESS_THROW_ACTION)) > 1
+#  error Only one of SCOPE_GUARD_MAY_THROW_ACTION and SCOPE_GUARD_NO_THROW_ACTION and SCOPE_GUARD_SUPPRESS_THROW_ACTION may be defined.
+#endif
+
+#if !defined(SCOPE_GUARD_CATCH_HANDLER)
+#  define SCOPE_GUARD_CATCH_HANDLER /* Suppress exception.*/
+#endif
+
+namespace scope_guard {
+
+namespace detail {
+
+#if defined(SCOPE_GUARD_SUPPRESS_THROW_ACTION) && (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || (_HAS_EXCEPTIONS))
+#  define NEARGYE_NOEXCEPT(...) noexcept
+#  define NEARGYE_TRY           try {
+#  define NEARGYE_CATCH         } catch (...) { SCOPE_GUARD_CATCH_HANDLER }
+#else
+#  define NEARGYE_NOEXCEPT(...) noexcept(__VA_ARGS__)
+#  define NEARGYE_TRY
+#  define NEARGYE_CATCH
+#endif
+
+#define NEARGYE_MOV(...) static_cast<typename std::remove_reference<decltype(__VA_ARGS__)>::type&&>(__VA_ARGS__)
+#define NEARGYE_FWD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+
+// NEARGYE_NODISCARD encourages the compiler to issue a warning if the return value is discarded.
+#if !defined(NEARGYE_NODISCARD)
+#  if defined(__clang__)
+#    if (__clang_major__ * 10 + __clang_minor__) >= 39 && __cplusplus >= 201703L
+#      define NEARGYE_NODISCARD [[nodiscard]]
+#    else
+#      define NEARGYE_NODISCARD __attribute__((__warn_unused_result__))
+#    endif
+#  elif defined(__GNUC__)
+#    if __GNUC__ >= 7 && __cplusplus >= 201703L
+#      define NEARGYE_NODISCARD [[nodiscard]]
+#    else
+#      define NEARGYE_NODISCARD __attribute__((__warn_unused_result__))
+#    endif
+#  elif defined(_MSC_VER)
+#    if _MSC_VER >= 1911 && defined(_MSVC_LANG) && _MSVC_LANG >= 201703L
+#      define NEARGYE_NODISCARD [[nodiscard]]
+#    elif defined(_Check_return_)
+#      define NEARGYE_NODISCARD _Check_return_
+#    else
+#      define NEARGYE_NODISCARD
+#    endif
+#  else
+#    define NEARGYE_NODISCARD
+#  endif
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+inline int uncaught_exceptions() noexcept {
+  return *(reinterpret_cast<int*>(static_cast<char*>(static_cast<void*>(_getptd())) + (sizeof(void*) == 8 ? 0x100 : 0x90)));
+}
+#elif (defined(__clang__) || defined(__GNUC__)) && __cplusplus < 201700L
+struct __cxa_eh_globals;
+extern "C" __cxa_eh_globals* __cxa_get_globals() noexcept;
+inline int uncaught_exceptions() noexcept {
+  return static_cast<int>(*(reinterpret_cast<unsigned int*>(static_cast<char*>(static_cast<void*>(__cxa_get_globals())) + sizeof(void*))));
+}
+#else
+inline int uncaught_exceptions() noexcept {
+  return std::uncaught_exceptions();
+}
+#endif
+
+class on_exit_policy {
+  bool execute_;
+
+ public:
+  explicit on_exit_policy(bool execute) noexcept : execute_{execute} {}
+
+  void dismiss() noexcept {
+    execute_ = false;
+  }
+
+  bool should_execute() const noexcept {
+    return execute_;
+  }
+};
+
+class on_fail_policy {
+  int ec_;
+
+ public:
+  explicit on_fail_policy(bool execute) noexcept : ec_{execute ? uncaught_exceptions() : -1} {}
+
+  void dismiss() noexcept {
+    ec_ = -1;
+  }
+
+  bool should_execute() const noexcept {
+    return ec_ != -1 && ec_ < uncaught_exceptions();
+  }
+};
+
+class on_success_policy {
+  int ec_;
+
+ public:
+  explicit on_success_policy(bool execute) noexcept : ec_{execute ? uncaught_exceptions() : -1} {}
+
+  void dismiss() noexcept {
+    ec_ = -1;
+  }
+
+  bool should_execute() const noexcept {
+    return ec_ != -1 && ec_ >= uncaught_exceptions();
+  }
+};
+
+template <typename T, typename = void>
+struct is_noarg_returns_void_action
+    : std::false_type {};
+
+template <typename T>
+struct is_noarg_returns_void_action<T, decltype((std::declval<T>())())>
+    : std::true_type {};
+
+template <typename T, bool = is_noarg_returns_void_action<T>::value>
+struct is_nothrow_invocable_action
+    : std::false_type {};
+
+template <typename T>
+struct is_nothrow_invocable_action<T, true>
+    : std::integral_constant<bool, noexcept((std::declval<T>())())> {};
+
+template <typename F, typename P>
+class scope_guard {
+  using A = typename std::decay<F>::type;
+
+  static_assert(is_noarg_returns_void_action<A>::value,
+                "scope_guard requires no-argument action, that returns void.");
+  static_assert(std::is_same<P, on_exit_policy>::value || std::is_same<P, on_fail_policy>::value || std::is_same<P, on_success_policy>::value,
+                "scope_guard requires on_exit_policy, on_fail_policy or on_success_policy.");
+#if defined(SCOPE_GUARD_NO_THROW_ACTION)
+    static_assert(is_nothrow_invocable_action<A>::value,
+                  "scope_guard requires noexcept invocable action.");
+#endif
+#if defined(SCOPE_GUARD_NO_THROW_CONSTRUCTIBLE)
+  static_assert(std::is_nothrow_move_constructible<A>::value,
+                "scope_guard requires nothrow constructible action.");
+#endif
+
+  P policy_;
+  A action_;
+
+  void* operator new(std::size_t) = delete;
+  void operator delete(void*) = delete;
+
+ public:
+  scope_guard() = delete;
+  scope_guard(const scope_guard&) = delete;
+  scope_guard& operator=(const scope_guard&) = delete;
+  scope_guard& operator=(scope_guard&&) = delete;
+
+  scope_guard(scope_guard&& other) noexcept(std::is_nothrow_move_constructible<A>::value)
+      : policy_{false},
+        action_{NEARGYE_MOV(other.action_)} {
+    policy_ = NEARGYE_MOV(other.policy_);
+    other.policy_.dismiss();
+  }
+
+  scope_guard(const A& action) = delete;
+  scope_guard(A& action) = delete;
+
+  explicit scope_guard(A&& action) noexcept(std::is_nothrow_move_constructible<A>::value)
+      : policy_{true},
+        action_{NEARGYE_MOV(action)} {}
+
+  void dismiss() noexcept {
+    policy_.dismiss();
+  }
+
+  ~scope_guard() NEARGYE_NOEXCEPT(is_nothrow_invocable_action<A>::value) {
+    if (policy_.should_execute()) {
+      NEARGYE_TRY
+        action_();
+      NEARGYE_CATCH
+    }
+  }
+};
+
+template <typename F>
+using scope_exit = scope_guard<F, on_exit_policy>;
+
+template <typename F, typename std::enable_if<is_noarg_returns_void_action<F>::value, int>::type = 0>
+NEARGYE_NODISCARD scope_exit<F> make_scope_exit(F&& action) noexcept(noexcept(scope_exit<F>{NEARGYE_FWD(action)})) {
+  return scope_exit<F>{NEARGYE_FWD(action)};
+}
+
+template <typename F>
+using scope_fail = scope_guard<F, on_fail_policy>;
+
+template <typename F, typename std::enable_if<is_noarg_returns_void_action<F>::value, int>::type = 0>
+NEARGYE_NODISCARD scope_fail<F> make_scope_fail(F&& action) noexcept(noexcept(scope_fail<F>{NEARGYE_FWD(action)})) {
+  return scope_fail<F>{NEARGYE_FWD(action)};
+}
+
+template <typename F>
+using scope_success = scope_guard<F, on_success_policy>;
+
+template <typename F, typename std::enable_if<is_noarg_returns_void_action<F>::value, int>::type = 0>
+NEARGYE_NODISCARD scope_success<F> make_scope_success(F&& action) noexcept(noexcept(scope_success<F>{NEARGYE_FWD(action)})) {
+  return scope_success<F>{NEARGYE_FWD(action)};
+}
+
+struct scope_exit_tag {};
+
+template <typename F, typename std::enable_if<is_noarg_returns_void_action<F>::value, int>::type = 0>
+scope_exit<F> operator<<(scope_exit_tag, F&& action) noexcept(noexcept(scope_exit<F>{NEARGYE_FWD(action)})) {
+  return scope_exit<F>{NEARGYE_FWD(action)};
+}
+
+struct scope_fail_tag {};
+
+template <typename F, typename std::enable_if<is_noarg_returns_void_action<F>::value, int>::type = 0>
+scope_fail<F> operator<<(scope_fail_tag, F&& action) noexcept(noexcept(scope_fail<F>{NEARGYE_FWD(action)})) {
+  return scope_fail<F>{NEARGYE_FWD(action)};
+}
+
+struct scope_success_tag {};
+
+template <typename F, typename std::enable_if<is_noarg_returns_void_action<F>::value, int>::type = 0>
+scope_success<F> operator<<(scope_success_tag, F&& action) noexcept(noexcept(scope_success<F>{NEARGYE_FWD(action)})) {
+  return scope_success<F>{NEARGYE_FWD(action)};
+}
+
+#undef NEARGYE_MOV
+#undef NEARGYE_FWD
+#undef NEARGYE_NOEXCEPT
+#undef NEARGYE_TRY
+#undef NEARGYE_CATCH
+#undef NEARGYE_NODISCARD
+
+} // namespace scope_guard::detail
+
+using detail::make_scope_exit;
+using detail::make_scope_fail;
+using detail::make_scope_success;
+
+} // namespace scope_guard
+
+// NEARGYE_MAYBE_UNUSED suppresses compiler warnings on unused entities, if any.
+#if !defined(NEARGYE_MAYBE_UNUSED)
+#  if defined(__clang__)
+#    if (__clang_major__ * 10 + __clang_minor__) >= 39 && __cplusplus >= 201703L
+#      define NEARGYE_MAYBE_UNUSED [[maybe_unused]]
+#    else
+#      define NEARGYE_MAYBE_UNUSED __attribute__((__unused__))
+#    endif
+#  elif defined(__GNUC__)
+#    if __GNUC__ >= 7 && __cplusplus >= 201703L
+#      define NEARGYE_MAYBE_UNUSED [[maybe_unused]]
+#    else
+#      define NEARGYE_MAYBE_UNUSED __attribute__((__unused__))
+#    endif
+#  elif defined(_MSC_VER)
+#    if _MSC_VER >= 1911 && defined(_MSVC_LANG) && _MSVC_LANG >= 201703L
+#      define NEARGYE_MAYBE_UNUSED [[maybe_unused]]
+#    else
+#      define NEARGYE_MAYBE_UNUSED __pragma(warning(suppress : 4100 4101 4189))
+#    endif
+#  else
+#    define NEARGYE_MAYBE_UNUSED
+#  endif
+#endif
+
+#if !defined(NEARGYE_STR_CONCAT)
+#  define NEARGYE_STR_CONCAT_(s1, s2) s1##s2
+#  define NEARGYE_STR_CONCAT(s1, s2)  NEARGYE_STR_CONCAT_(s1, s2)
+#endif
+
+#if !defined(NEARGYE_COUNTER)
+#  if defined(__COUNTER__)
+#    define NEARGYE_COUNTER __COUNTER__
+#  elif defined(__LINE__)
+#    define NEARGYE_COUNTER __LINE__
+#  endif
+#endif
+
+#if defined(SCOPE_GUARD_NO_THROW_ACTION)
+#  define NEARGYE_MAKE_SCOPE_GUARD_ACTION [&]() noexcept -> void
+#else
+#  define NEARGYE_MAKE_SCOPE_GUARD_ACTION [&]() -> void
+#endif
+
+#define NEARGYE_MAKE_SCOPE_EXIT    ::scope_guard::detail::scope_exit_tag{}    << NEARGYE_MAKE_SCOPE_GUARD_ACTION
+#define NEARGYE_MAKE_SCOPE_FAIL    ::scope_guard::detail::scope_fail_tag{}    << NEARGYE_MAKE_SCOPE_GUARD_ACTION
+#define NEARGYE_MAKE_SCOPE_SUCCESS ::scope_guard::detail::scope_success_tag{} << NEARGYE_MAKE_SCOPE_GUARD_ACTION
+
+#define NEARGYE_SCOPE_GUARD_WITH_(g, i) for (int i = 1; i--; g)
+#define NEARGYE_SCOPE_GUARD_WITH(g)     NEARGYE_SCOPE_GUARD_WITH_(g, NEARGYE_STR_CONCAT(NEARGYE_INTERNAL_OBJECT_, NEARGYE_COUNTER))
+
+// SCOPE_EXIT executing action on scope exit.
+#define MAKE_SCOPE_EXIT(name)  auto name = NEARGYE_MAKE_SCOPE_EXIT
+#define SCOPE_EXIT             NEARGYE_MAYBE_UNUSED const MAKE_SCOPE_EXIT(NEARGYE_STR_CONCAT(NEARGYE_SCOPE_EXIT_, NEARGYE_COUNTER))
+#define WITH_SCOPE_EXIT(guard) NEARGYE_SCOPE_GUARD_WITH(NEARGYE_MAKE_SCOPE_EXIT{ guard })
+
+// SCOPE_FAIL executing action on scope exit when an exception has been thrown before scope exit.
+#define MAKE_SCOPE_FAIL(name)  auto name = NEARGYE_MAKE_SCOPE_FAIL
+#define SCOPE_FAIL             NEARGYE_MAYBE_UNUSED const MAKE_SCOPE_FAIL(NEARGYE_STR_CONCAT(NEARGYE_SCOPE_FAIL_, NEARGYE_COUNTER))
+#define WITH_SCOPE_FAIL(guard) NEARGYE_SCOPE_GUARD_WITH(NEARGYE_MAKE_SCOPE_FAIL{ guard })
+
+// SCOPE_SUCCESS executing action on scope exit when no exceptions have been thrown before scope exit.
+#define MAKE_SCOPE_SUCCESS(name)  auto name = NEARGYE_MAKE_SCOPE_SUCCESS
+#define SCOPE_SUCCESS             NEARGYE_MAYBE_UNUSED const MAKE_SCOPE_SUCCESS(NEARGYE_STR_CONCAT(NEARGYE_SCOPE_SUCCESS_, NEARGYE_COUNTER))
+#define WITH_SCOPE_SUCCESS(guard) NEARGYE_SCOPE_GUARD_WITH(NEARGYE_MAKE_SCOPE_SUCCESS{ guard })
+
+// DEFER executing action on scope exit.
+#define MAKE_DEFER(name)  MAKE_SCOPE_EXIT(name)
+#define DEFER             SCOPE_EXIT
+#define WITH_DEFER(guard) WITH_SCOPE_EXIT(guard)
+
+#endif // NEARGYE_SCOPE_GUARD_HPP
@@ -726,7 +726,6 @@ static int do_mount(const char *mnt, char **typep, mode_t rootmode,
 	char *subtype = NULL;
 	char *source = NULL;
 	char *type = NULL;
-	int check_empty = 1;
 	int blkdev = 0;

 	optbuf = (char *) malloc(strlen(opts) + 128);
@@ -759,8 +758,6 @@ static int do_mount(const char *mnt, char **typep, mode_t rootmode,
 				goto err;
 			}
 			blkdev = 1;
-		} else if (opt_eq(s, len, "nonempty")) {
-			check_empty = 0;
 		} else if (opt_eq(s, len, "auto_unmount")) {
 			auto_unmount = 1;
 		} else if (!begins_with(s, "fd=") &&
@@ -782,9 +779,7 @@ static int do_mount(const char *mnt, char **typep, mode_t rootmode,
 					skip_option = 1;
 				}
 			}
-			if (getuid() != 0 && !user_allow_other &&
-			    (opt_eq(s, len, "allow_other") ||
-			     opt_eq(s, len, "allow_root"))) {
+			if (getuid() != 0 && !user_allow_other && opt_eq(s, len, "allow_other")) {
 				fprintf(stderr, "%s: option %.*s only allowed if 'user_allow_other' is set in /etc/fuse.conf\n", progname, len, s);
 				goto err;
 			}
@@ -813,10 +808,6 @@ static int do_mount(const char *mnt, char **typep, mode_t rootmode,
 	sprintf(d, "fd=%i,rootmode=%o,user_id=%u,group_id=%u",
 		fd, rootmode, getuid(), getgid());

-	if (check_empty &&
-	    fuse_mnt_check_empty(progname, mnt, rootmode, rootsize) == -1)
-		goto err;
-
 	source = malloc((fsname ? strlen(fsname) : 0) +
 			(subtype ? strlen(subtype) : 0) + strlen(dev) + 32);

@@ -312,39 +312,6 @@ char *fuse_mnt_resolve_path(const char *progname, const char *orig)
 	return dst;
 }

-int fuse_mnt_check_empty(const char *progname, const char *mnt,
-			 mode_t rootmode, off_t rootsize)
-{
-	int isempty = 1;
-
-	if (S_ISDIR(rootmode)) {
-		struct dirent *ent;
-		DIR *dp = opendir(mnt);
-		if (dp == NULL) {
-			fprintf(stderr,
-				"%s: failed to open mountpoint for reading: %s\n",
-				progname, strerror(errno));
-			return -1;
-		}
-		while ((ent = readdir(dp)) != NULL) {
-			if (strcmp(ent->d_name, ".") != 0 &&
-			    strcmp(ent->d_name, "..") != 0) {
-				isempty = 0;
-				break;
-			}
-		}
-		closedir(dp);
-	} else if (rootsize)
-		isempty = 0;
-
-	if (!isempty) {
-		fprintf(stderr, "%s: mountpoint is not empty\n", progname);
-		fprintf(stderr, "%s: if you are sure this is safe, use the 'nonempty' mount option\n", progname);
-		return -1;
-	}
-	return 0;
-}
-
 int fuse_mnt_check_fuseblk(void)
 {
 	char buf[256];
@@ -35,6 +35,7 @@ make install PREFIX=%{_prefix} DESTDIR=%{buildroot}
 /usr/bin/mergerfs
 /usr/bin/mergerfs-fusermount
 /sbin/mount.mergerfs
+/usr/lib/mergerfs/preload.so
 %doc %{_mandir}/*

 %changelog
@@ -18,21 +18,8 @@

 #include "branch.hpp"
 #include "ef.hpp"
-#include "from_string.hpp"
-#include "fs_glob.hpp"
-#include "fs_realpathize.hpp"
-#include "nonstd/optional.hpp"
+#include "errno.hpp"
 #include "num.hpp"
-#include "str.hpp"
-
-#include <string>
-
-#include <errno.h>
-#include <fnmatch.h>
-
-using std::string;
-using std::vector;
-using nonstd::optional;


 Branch::Branch(const uint64_t &default_minfreespace_)
@@ -108,354 +95,3 @@ Branch::ro_or_nc(void) const
  return ((mode == Branch::Mode::RO) ||
          (mode == Branch::Mode::NC));
 }
-
-namespace l
-{
-  static
-  void
-  split(const std::string &s_,
-        std::string       *instr_,
-        std::string       *values_)
-  {
-    uint64_t offset;
-
-    offset = s_.find_first_of('/');
-    *instr_ = s_.substr(0,offset);
-    if(offset != std::string::npos)
-      *values_ = s_.substr(offset);
-  }
-}
-
-Branches::Branches(const uint64_t &default_minfreespace_)
-  : default_minfreespace(default_minfreespace_)
-{
-  pthread_rwlock_init(&lock,NULL);
-}
-
-namespace l
-{
-  static
-  int
-  parse_mode(const string &str_,
-             Branch::Mode *mode_)
-  {
-    if(str_ == "RW")
-      *mode_ = Branch::Mode::RW;
-    ef(str_ == "RO")
-      *mode_ = Branch::Mode::RO;
-    ef(str_ == "NC")
-      *mode_ = Branch::Mode::NC;
-    else
-      return -EINVAL;
-
-    return 0;
-  }
-
-  static
-  int
-  parse_minfreespace(const string       &str_,
-                     optional<uint64_t> *minfreespace_)
-  {
-    int rv;
-    uint64_t uint64;
-
-    rv = str::from(str_,&uint64);
-    if(rv < 0)
-      return rv;
-
-    *minfreespace_ = uint64;
-
-    return 0;
-  }
-
-  static
-  int
-  parse_branch(const string       &str_,
-               string             *glob_,
-               Branch::Mode       *mode_,
-               optional<uint64_t> *minfreespace_)
-  {
-    int rv;
-    string options;
-    vector<string> v;
-
-    str::rsplit1(str_,'=',&v);
-    switch(v.size())
-      {
-      case 1:
-        *glob_ = v[0];
-        *mode_ = Branch::Mode::RW;
-        break;
-      case 2:
-        *glob_  = v[0];
-        options = v[1];
-        v.clear();
-        str::split(options,',',&v);
-        switch(v.size())
-          {
-          case 2:
-            rv = l::parse_minfreespace(v[1],minfreespace_);
-            if(rv < 0)
-              return rv;
-          case 1:
-            rv = l::parse_mode(v[0],mode_);
-            if(rv < 0)
-              return rv;
-            break;
-          case 0:
-            return -EINVAL;
-          }
-        break;
-      default:
-        return -EINVAL;
-      }
-
-    return 0;
-  }
-
-  static
-  int
-  parse(const string   &str_,
-        const uint64_t &default_minfreespace_,
-        BranchVec      *branches_)
-  {
-    int rv;
-    string glob;
-    vector<string> globbed;
-    optional<uint64_t> minfreespace;
-    Branch branch(default_minfreespace_);
-
-    rv = l::parse_branch(str_,&glob,&branch.mode,&minfreespace);
-    if(rv < 0)
-      return rv;
-
-    if(minfreespace.has_value())
-      branch.set_minfreespace(minfreespace.value());
-
-    fs::glob(glob,&globbed);
-    fs::realpathize(&globbed);
-    for(size_t i = 0; i < globbed.size(); i++)
-      {
-        branch.path = globbed[i];
-        branches_->push_back(branch);
-      }
-
-    return 0;
-  }
-
-  static
-  int
-  set(const std::string &str_,
-      Branches          *branches_)
-  {
-    int rv;
-    vector<string> paths;
-    BranchVec tmp_branchvec;
-
-    str::split(str_,':',&paths);
-
-    for(size_t i = 0; i < paths.size(); i++)
-      {
-        rv = l::parse(paths[i],branches_->default_minfreespace,&tmp_branchvec);
-        if(rv < 0)
-          return rv;
-      }
-
-    branches_->vec.clear();
-    branches_->vec.insert(branches_->vec.end(),
-                          tmp_branchvec.begin(),
-                          tmp_branchvec.end());
-
-    return 0;
-  }
-
-  static
-  int
-  add_begin(const std::string &str_,
-            Branches          *branches_)
-  {
-    int rv;
-    vector<string> paths;
-    BranchVec tmp_branchvec;
-
-    str::split(str_,':',&paths);
-
-    for(size_t i = 0; i < paths.size(); i++)
-      {
-        rv = l::parse(paths[i],branches_->default_minfreespace,&tmp_branchvec);
-        if(rv < 0)
-          return rv;
-      }
-
-    branches_->vec.insert(branches_->vec.begin(),
-                          tmp_branchvec.begin(),
-                          tmp_branchvec.end());
-
-    return 0;
-  }
-
-  static
-  int
-  add_end(const std::string &str_,
-          Branches          *branches_)
-  {
-    int rv;
-    vector<string> paths;
-    BranchVec tmp_branchvec;
-
-    str::split(str_,':',&paths);
-
-    for(size_t i = 0; i < paths.size(); i++)
-      {
-        rv = l::parse(paths[i],branches_->default_minfreespace,&tmp_branchvec);
-        if(rv < 0)
-          return rv;
-      }
-
-    branches_->vec.insert(branches_->vec.end(),
-                          tmp_branchvec.begin(),
-                          tmp_branchvec.end());
-
-    return 0;
-  }
-
-  static
-  int
-  erase_begin(BranchVec *branches_)
-  {
-    branches_->erase(branches_->begin());
-
-    return 0;
-  }
-
-  static
-  int
-  erase_end(BranchVec *branches_)
-  {
-    branches_->pop_back();
-
-    return 0;
-  }
-
-  static
-  int
-  erase_fnmatch(const std::string &str_,
-                Branches          *branches_)
-  {
-    vector<string> patterns;
-
-    str::split(str_,':',&patterns);
-
-    for(BranchVec::iterator i = branches_->vec.begin();
-        i != branches_->vec.end();)
-      {
-        int match = FNM_NOMATCH;
-
-        for(vector<string>::const_iterator pi = patterns.begin();
-            pi != patterns.end() && match != 0;
-            ++pi)
-          {
-            match = ::fnmatch(pi->c_str(),i->path.c_str(),0);
-          }
-
-        i = ((match == 0) ? branches_->vec.erase(i) : (i+1));
-      }
-
-    return 0;
-  }
-}
-
-int
-Branches::from_string(const std::string &s_)
-{
-  rwlock::WriteGuard guard(lock);
-
-  std::string instr;
-  std::string values;
-
-  l::split(s_,&instr,&values);
-
-  if(instr == "+")
-    return l::add_end(values,this);
-  if(instr == "+<")
-    return l::add_begin(values,this);
-  if(instr == "+>")
-    return l::add_end(values,this);
-  if(instr == "-")
-    return l::erase_fnmatch(values,this);
-  if(instr == "-<")
-    return l::erase_begin(&vec);
-  if(instr == "->")
-    return l::erase_end(&vec);
-  if(instr == "=")
-    return l::set(values,this);
-  if(instr.empty())
-    return l::set(values,this);
-
-  return -EINVAL;
-}
-
-string
-Branches::to_string(void) const
-{
-  rwlock::ReadGuard guard(lock);
-
-  string tmp;
-
-  for(size_t i = 0; i < vec.size(); i++)
-    {
-      const Branch &branch = vec[i];
-
-      tmp += branch.to_string();
-      tmp += ':';
-    }
-
-  if(*tmp.rbegin() == ':')
-    tmp.erase(tmp.size() - 1);
-
-  return tmp;
-}
-
-void
-Branches::to_paths(vector<string> &vec_) const
-{
-  rwlock::ReadGuard guard(lock);
-
-  for(size_t i = 0; i < vec.size(); i++)
-    {
-      const Branch &branch = vec[i];
-
-      vec_.push_back(branch.path);
-    }
-}
-
-SrcMounts::SrcMounts(Branches &b_)
-  : _branches(b_)
-{
-
-}
-
-int
-SrcMounts::from_string(const std::string &s_)
-{
-  return _branches.from_string(s_);
-}
-
-std::string
-SrcMounts::to_string(void) const
-{
-  rwlock::ReadGuard guard(_branches.lock);
-
-  std::string rv;
-
-  for(uint64_t i = 0; i < _branches.vec.size(); i++)
-    {
-      rv += _branches.vec[i].path;
-      rv += ':';
-    }
-
-  if(*rv.rbegin() == ':')
-    rv.erase(rv.size() - 1);
-
-  return rv;
-}
@@ -18,81 +18,50 @@

 #pragma once

-#include "rwlock.hpp"
-#include "tofrom_string.hpp"
 #include "nonstd/optional.hpp"
+#include "strvec.hpp"
+#include "tofrom_string.hpp"

+#include <cstdint>
 #include <string>
 #include <vector>

-#include <stdint.h>
-#include <pthread.h>

-class Branch : public ToFromString
+class Branch final : public ToFromString
 {
 public:
-  Branch(const uint64_t &default_minfreespace);
+  typedef std::vector<Branch> Vector;

 public:
-  int from_string(const std::string &str);
-  std::string to_string(void) const;
+  Branch(const uint64_t &default_minfreespace_);

 public:
  enum class Mode
    {
-      INVALID,
-      RO,
-      RW,
-      NC
+     INVALID,
+     RO,
+     RW,
+     NC
    };

-public:
-  Mode        mode;
-  std::string path;
-  uint64_t    minfreespace() const;
-
-public:
-  void set_minfreespace(const uint64_t minfreespace);
-
 public:
  bool ro(void) const;
  bool nc(void) const;
  bool ro_or_nc(void) const;

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

-#include "config_readdir.hpp"
-#include "ef.hpp"
+#include "category.hpp"
 #include "errno.hpp"
+#include "str.hpp"
+
+#include <string>

-template<>
 int
-ReadDir::from_string(const std::string &s_)
+Category::Base::from_string(const std::string &s_)
 {
-  if(s_ == "posix")
-    _data = ReadDir::ENUM::POSIX;
-  ef(s_ == "linux")
-    _data = ReadDir::ENUM::LINUX;
-  else
-    return -EINVAL;
+  int rv;
+
+  for(auto func : funcs)
+    {
+      rv = func->from_string(s_);
+      if(rv < 0)
+        return rv;
+    }

  return 0;
 }

-template<>
 std::string
-ReadDir::to_string(void) const
+Category::Base::to_string(void) const
 {
-  switch(_data)
-    {
-    case ReadDir::ENUM::POSIX:
-      return "posix";
-    case ReadDir::ENUM::LINUX:
-      return "linux";
-    }
+  std::set<std::string> rv;

-  return "invalid";
+  for(const auto func : funcs)
+    rv.insert(func->to_string());
+
+  return str::join(rv,',');
 }
@@ -1,5 +1,5 @@
 /*
-  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>

  Permission to use, copy, modify, and/or distribute this software for any
  purpose with or without fee is hereby granted, provided that the above
@@ -16,9 +16,92 @@

 #pragma once

-enum class Category
+#include "tofrom_string.hpp"
+#include "funcs.hpp"
+#include "func.hpp"
+
+#include <string>
+
+namespace Category
+{
+  class Base : public ToFromString
  {
-    ACTION,
-    CREATE,
-    SEARCH
+  public:
+    int from_string(const std::string &s) final;
+    std::string to_string() const final;
+
+  protected:
+    std::vector<ToFromString*> funcs;
  };
+
+  class Action final : public Base
+  {
+  private:
+    Action();
+
+  public:
+    Action(Funcs &funcs_)
+    {
+      funcs.push_back(&funcs_.chmod);
+      funcs.push_back(&funcs_.chown);
+      funcs.push_back(&funcs_.link);
+      funcs.push_back(&funcs_.removexattr);
+      funcs.push_back(&funcs_.rename);
+      funcs.push_back(&funcs_.rmdir);
+      funcs.push_back(&funcs_.setxattr);
+      funcs.push_back(&funcs_.truncate);
+      funcs.push_back(&funcs_.unlink);
+      funcs.push_back(&funcs_.utimens);
+    }
+  };
+
+  class Create final : public Base
+  {
+  private:
+    Create();
+
+  public:
+    Create(Funcs &funcs_)
+    {
+      funcs.push_back(&funcs_.create);
+      funcs.push_back(&funcs_.mkdir);
+      funcs.push_back(&funcs_.mknod);
+      funcs.push_back(&funcs_.symlink);
+    }
+  };
+
+  class Search final : public Base
+  {
+  private:
+    Search();
+
+  public:
+    Search(Funcs &funcs_)
+    {
+      funcs.push_back(&funcs_.access);
+      funcs.push_back(&funcs_.getattr);
+      funcs.push_back(&funcs_.getxattr);
+      funcs.push_back(&funcs_.listxattr);
+      funcs.push_back(&funcs_.open);
+      funcs.push_back(&funcs_.readlink);
+    }
+  };
+}
+
+class Categories final
+{
+private:
+  Categories();
+
+public:
+  Categories(Funcs &funcs_)
+    : action(funcs_),
+      create(funcs_),
+      search(funcs_)
+  {}
+
+public:
+  Category::Action action;
+  Category::Create create;
+  Category::Search search;
+};
@@ -20,23 +20,34 @@
 #include "from_string.hpp"
 #include "num.hpp"
 #include "rwlock.hpp"
+#include "str.hpp"
 #include "to_string.hpp"
 #include "version.hpp"

 #include <algorithm>
-#include <string>
+#include <cstdint>
+#include <fstream>
 #include <iostream>
+#include <string>

-#include <stdint.h>
+#include <pthread.h>
+#include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>

 #define MINFREESPACE_DEFAULT (4294967295ULL)

-using std::string;
-
 #define IFERT(S) if(S == s_) return true

+const std::string CONTROLFILE = "/.mergerfs";
+constexpr static const char CACHE_FILES_PROCESS_NAMES_DEFAULT[] =
+  "rtorrent|"
+  "qbittorrent-nox";
+
+
+Config Config::_singleton;
+
+
 namespace l
 {
  static
@@ -44,14 +55,23 @@ namespace l
  readonly(const std::string &s_)
  {
    IFERT("async_read");
+    IFERT("branches-mount-timeout");
    IFERT("cache.symlinks");
    IFERT("cache.writeback");
+    IFERT("direct-io-allow-mmap");
+    IFERT("export-support");
    IFERT("fsname");
    IFERT("fuse_msg_size");
    IFERT("mount");
    IFERT("nullrw");
    IFERT("pid");
+    IFERT("pin-threads");
+    IFERT("process-thread-count");
+    IFERT("process-thread-queue-depth");
+    IFERT("read-thread-count");
    IFERT("readdirplus");
+    IFERT("scheduling-priority");
+    IFERT("srcmounts");
    IFERT("threads");
    IFERT("version");

@@ -60,123 +80,156 @@ namespace l
 }

 Config::Config()
-  :
-  open_cache(),
-
-  controlfile("/.mergerfs"),
-
-  async_read(true),
-  auto_cache(false),
-  branches(minfreespace),
-  cache_attr(1),
-  cache_entry(1),
-  cache_files(CacheFiles::ENUM::LIBFUSE),
-  cache_negative_entry(0),
-  cache_readdir(false),
-  cache_statfs(0),
-  cache_symlinks(false),
-  category(func),
-  direct_io(false),
-  dropcacheonclose(false),
-  fsname(),
-  func(),
-  fuse_msg_size(FUSE_MAX_MAX_PAGES),
-  ignorepponrename(false),
-  inodecalc("hybrid-hash"),
-  link_cow(false),
-  minfreespace(MINFREESPACE_DEFAULT),
-  mount(),
-  moveonenospc(false),
-  nfsopenhack(NFSOpenHack::ENUM::OFF),
-  nullrw(false),
-  pid(::getpid()),
-  posix_acl(false),
-  readdir(ReadDir::ENUM::POSIX),
-  readdirplus(false),
-  security_capability(true),
-  srcmounts(branches),
-  statfs(StatFS::ENUM::BASE),
-  statfs_ignore(StatFSIgnore::ENUM::NONE),
-  symlinkify(false),
-  symlinkify_timeout(3600),
-  threads(0),
-  version(MERGERFS_VERSION),
-  writeback_cache(false),
-  xattr(XAttr::ENUM::PASSTHROUGH)
+  : async_read(true),
+    auto_cache(false),
+    minfreespace(MINFREESPACE_DEFAULT),
+    branches(minfreespace),
+    branches_mount_timeout(0),
+    cache_attr(1),
+    cache_entry(1),
+    cache_files(CacheFiles::ENUM::LIBFUSE),
+    cache_files_process_names(CACHE_FILES_PROCESS_NAMES_DEFAULT),
+    cache_negative_entry(0),
+    cache_readdir(false),
+    cache_statfs(0),
+    cache_symlinks(false),
+    category(func),
+    direct_io(false),
+    direct_io_allow_mmap(true),
+    dropcacheonclose(false),
+    export_support(true),
+    flushonclose(FlushOnClose::ENUM::OPENED_FOR_WRITE),
+    follow_symlinks(FollowSymlinks::ENUM::NEVER),
+    fsname(),
+    func(),
+    fuse_msg_size(FUSE_MAX_MAX_PAGES),
+    ignorepponrename(false),
+    inodecalc("hybrid-hash"),
+    lazy_umount_mountpoint(false),
+    link_cow(false),
+    link_exdev(LinkEXDEV::ENUM::PASSTHROUGH),
+    log_metrics(false),
+    mountpoint(),
+    moveonenospc(false),
+    nfsopenhack(NFSOpenHack::ENUM::OFF),
+    nullrw(false),
+    parallel_direct_writes(false),
+    posix_acl(false),
+    readahead(0),
+    readdir("seq"),
+    readdirplus(false),
+    rename_exdev(RenameEXDEV::ENUM::PASSTHROUGH),
+    scheduling_priority(-10),
+    security_capability(true),
+    srcmounts(branches),
+    statfs(StatFS::ENUM::BASE),
+    statfs_ignore(StatFSIgnore::ENUM::NONE),
+    symlinkify(false),
+    symlinkify_timeout(3600),
+    fuse_read_thread_count(0),
+    fuse_process_thread_count(-1),
+    fuse_process_thread_queue_depth(0),
+    fuse_pin_threads("false"),
+    version(MERGERFS_VERSION),
+    writeback_cache(false),
+    xattr(XAttr::ENUM::PASSTHROUGH),
+    _initialized(false)
 {
-  _map["async_read"]           = &async_read;
-  _map["auto_cache"]           = &auto_cache;
-  _map["branches"]             = &branches;
-  _map["cache.attr"]           = &cache_attr;
-  _map["cache.entry"]          = &cache_entry;
-  _map["cache.files"]          = &cache_files;
-  _map["cache.negative_entry"] = &cache_negative_entry;
-  _map["cache.readdir"]        = &cache_readdir;
-  _map["cache.statfs"]         = &cache_statfs;
-  _map["cache.symlinks"]       = &cache_symlinks;
-  _map["cache.writeback"]      = &writeback_cache;
-  _map["category.action"]      = &category.action;
-  _map["category.create"]      = &category.create;
-  _map["category.search"]      = &category.search;
-  _map["direct_io"]            = &direct_io;
-  _map["dropcacheonclose"]     = &dropcacheonclose;
-  _map["fsname"]               = &fsname;
-  _map["func.access"]          = &func.access;
-  _map["func.chmod"]           = &func.chmod;
-  _map["func.chown"]           = &func.chown;
-  _map["func.create"]          = &func.create;
-  _map["func.getattr"]         = &func.getattr;
-  _map["func.getxattr"]        = &func.getxattr;
-  _map["func.link"]            = &func.link;
-  _map["func.listxattr"]       = &func.listxattr;
-  _map["func.mkdir"]           = &func.mkdir;
-  _map["func.mknod"]           = &func.mknod;
-  _map["func.open"]            = &func.open;
-  _map["func.readlink"]        = &func.readlink;
-  _map["func.removexattr"]     = &func.removexattr;
-  _map["func.rename"]          = &func.rename;
-  _map["func.rmdir"]           = &func.rmdir;
-  _map["func.setxattr"]        = &func.setxattr;
-  _map["func.symlink"]         = &func.symlink;
-  _map["func.truncate"]        = &func.truncate;
-  _map["func.unlink"]          = &func.unlink;
-  _map["func.utimens"]         = &func.utimens;
-  _map["fuse_msg_size"]        = &fuse_msg_size;
-  _map["ignorepponrename"]     = &ignorepponrename;
-  _map["inodecalc"]            = &inodecalc;
-  _map["kernel_cache"]         = &kernel_cache;
-  _map["link_cow"]             = &link_cow;
-  _map["minfreespace"]         = &minfreespace;
-  _map["mount"]                = &mount;
-  _map["moveonenospc"]         = &moveonenospc;
-  _map["nfsopenhack"]          = &nfsopenhack;
-  _map["nullrw"]               = &nullrw;
-  _map["pid"]                  = &pid;
-  _map["posix_acl"]            = &posix_acl;
-  //  _map["readdir"]              = &readdir;
-  _map["readdirplus"]          = &readdirplus;
-  _map["security_capability"]  = &security_capability;
-  _map["srcmounts"]            = &srcmounts;
-  _map["statfs"]               = &statfs;
-  _map["statfs_ignore"]        = &statfs_ignore;
-  _map["symlinkify"]           = &symlinkify;
-  _map["symlinkify_timeout"]   = &symlinkify_timeout;
-  _map["threads"]              = &threads;
-  _map["version"]              = &version;
-  _map["xattr"]                = &xattr;
-}
-
-const
-Config&
-Config::ro(void)
-{
-  return *((Config*)fuse_get_context()->private_data);
+  _map["async_read"]             = &async_read;
+  _map["auto_cache"]             = &auto_cache;
+  _map["branches"]               = &branches;
+  _map["branches-mount-timeout"] = &branches_mount_timeout;
+  _map["cache.attr"]             = &cache_attr;
+  _map["cache.entry"]            = &cache_entry;
+  _map["cache.files"]            = &cache_files;
+  _map["cache.files.process-names"] = &cache_files_process_names;
+  _map["cache.negative_entry"]   = &cache_negative_entry;
+  _map["cache.readdir"]          = &cache_readdir;
+  _map["cache.statfs"]           = &cache_statfs;
+  _map["cache.symlinks"]         = &cache_symlinks;
+  _map["cache.writeback"]        = &writeback_cache;
+  _map["category.action"]        = &category.action;
+  _map["category.create"]        = &category.create;
+  _map["category.search"]        = &category.search;
+  _map["direct_io"]              = &direct_io;
+  _map["direct-io-allow-mmap"]   = &direct_io_allow_mmap;
+  _map["dropcacheonclose"]       = &dropcacheonclose;
+  _map["export-support"]         = &export_support;
+  _map["flush-on-close"]         = &flushonclose;
+  _map["follow-symlinks"]        = &follow_symlinks;
+  _map["fsname"]                 = &fsname;
+  _map["func.access"]            = &func.access;
+  _map["func.chmod"]             = &func.chmod;
+  _map["func.chown"]             = &func.chown;
+  _map["func.create"]            = &func.create;
+  _map["func.getattr"]           = &func.getattr;
+  _map["func.getxattr"]          = &func.getxattr;
+  _map["func.link"]              = &func.link;
+  _map["func.listxattr"]         = &func.listxattr;
+  _map["func.mkdir"]             = &func.mkdir;
+  _map["func.mknod"]             = &func.mknod;
+  _map["func.open"]              = &func.open;
+  _map["func.readdir"]           = &readdir;
+  _map["func.readlink"]          = &func.readlink;
+  _map["func.removexattr"]       = &func.removexattr;
+  _map["func.rename"]            = &func.rename;
+  _map["func.rmdir"]             = &func.rmdir;
+  _map["func.setxattr"]          = &func.setxattr;
+  _map["func.symlink"]           = &func.symlink;
+  _map["func.truncate"]          = &func.truncate;
+  _map["func.unlink"]            = &func.unlink;
+  _map["func.utimens"]           = &func.utimens;
+  _map["fuse_msg_size"]          = &fuse_msg_size;
+  _map["ignorepponrename"]       = &ignorepponrename;
+  _map["inodecalc"]              = &inodecalc;
+  _map["kernel_cache"]           = &kernel_cache;
+  _map["lazy-umount-mountpoint"] = &lazy_umount_mountpoint;
+  _map["link_cow"]               = &link_cow;
+  _map["link-exdev"]             = &link_exdev;
+  _map["log.metrics"]            = &log_metrics;
+  _map["minfreespace"]           = &minfreespace;
+  _map["mount"]                  = &mountpoint;
+  _map["moveonenospc"]           = &moveonenospc;
+  _map["nfsopenhack"]            = &nfsopenhack;
+  _map["nullrw"]                 = &nullrw;
+  _map["pid"]                    = &pid;
+  _map["parallel-direct-writes"] = &parallel_direct_writes;
+  _map["pin-threads"]            = &fuse_pin_threads;
+  _map["posix_acl"]              = &posix_acl;
+  _map["readahead"]              = &readahead;
+  _map["readdirplus"]            = &readdirplus;
+  _map["rename-exdev"]           = &rename_exdev;
+  _map["scheduling-priority"]    = &scheduling_priority;
+  _map["security_capability"]    = &security_capability;
+  _map["srcmounts"]              = &srcmounts;
+  _map["statfs"]                 = &statfs;
+  _map["statfs_ignore"]          = &statfs_ignore;
+  _map["symlinkify"]             = &symlinkify;
+  _map["symlinkify_timeout"]     = &symlinkify_timeout;
+  _map["threads"]                = &fuse_read_thread_count;
+  _map["read-thread-count"]      = &fuse_read_thread_count;
+  _map["process-thread-count"]   = &fuse_process_thread_count;
+  _map["process-thread-queue-depth"] = &fuse_process_thread_queue_depth;
+  _map["version"]                = &version;
+  _map["xattr"]                  = &xattr;
 }

 Config&
-Config::rw(void)
+Config::operator=(const Config &cfg_)
 {
-  return *((Config*)fuse_get_context()->private_data);
+  int rv;
+  std::string val;
+
+  for(auto &kv : _map)
+    {
+      rv = cfg_.get(kv.first,&val);
+      if(rv)
+        continue;
+
+      kv.second->from_string(val);
+    }
+
+  return *this;
 }

 bool
@@ -253,12 +306,87 @@ int
 Config::set(const std::string &key_,
            const std::string &value_)
 {
-  if(l::readonly(key_))
-    return -EINVAL;
+  if(_initialized && l::readonly(key_))
+    return -EROFS;

  return set_raw(key_,value_);
 }

+int
+Config::set(const std::string &kv_)
+{
+  std::string key;
+  std::string val;
+
+  str::splitkv(kv_,'=',&key,&val);
+  key = str::trim(key);
+  val = str::trim(val);
+
+  return set(key,val);
+}
+
+int
+Config::from_stream(std::istream &istrm_,
+                    ErrVec       *errs_)
+{
+  int rv;
+  std::string line;
+  std::string key;
+  std::string val;
+  Config newcfg;
+
+  newcfg = *this;
+
+  while(std::getline(istrm_,line,'\n'))
+    {
+      line = str::trim(line);
+      if(!line.empty() && (line[0] == '#'))
+        continue;
+
+      str::splitkv(line,'=',&key,&val);
+      key = str::trim(key);
+      val = str::trim(val);
+
+      rv = newcfg.set(key,val);
+      if(rv < 0)
+        errs_->push_back({rv,key});
+    }
+
+  if(!errs_->empty())
+    return -EINVAL;
+
+  *this = newcfg;
+
+  return 0;
+}
+
+int
+Config::from_file(const std::string &filepath_,
+                  ErrVec            *errs_)
+{
+  int rv;
+  std::ifstream ifstrm;
+
+  ifstrm.open(filepath_);
+  if(!ifstrm.good())
+    {
+      errs_->push_back({-errno,filepath_});
+      return -errno;
+    }
+
+  rv = from_stream(ifstrm,errs_);
+
+  ifstrm.close();
+
+  return rv;
+}
+
+void
+Config::finish_initializing()
+{
+  _initialized = true;
+}
+
 std::ostream&
 operator<<(std::ostream &os_,
           const Config &c_)
@@ -268,7 +396,47 @@ operator<<(std::ostream &os_,

  for(i = c_._map.begin(), ei = c_._map.end(); i != ei; ++i)
    {
-      os_ << i->first << '=' << i->second << '\n';
+      os_ << i->first << '=' << i->second->to_string() << std::endl;
+    }
+
+  return os_;
+}
+
+
+static
+std::string
+err2str(const int err_)
+{
+  switch(err_)
+    {
+    case 0:
+      return std::string();
+    case -EINVAL:
+      return "invalid value";
+    case -ENOATTR:
+      return "unknown option";
+    case -EROFS:
+      return "read-only option";
+    default:
+      return strerror(-err_);
+    }
+
+  return std::string();
+}
+
+std::ostream&
+operator<<(std::ostream         &os_,
+           const Config::ErrVec &ev_)
+{
+  std::string errstr;
+
+  for(auto &err : ev_)
+    {
+      os_ << "* ERROR: ";
+      errstr = err2str(err.err);
+      if(!errstr.empty())
+        os_ << errstr << " - ";
+      os_ << err.str << std::endl;
    }

  return os_;
@@ -16,29 +16,38 @@

 #pragma once

-#include "branch.hpp"
+#include "branches.hpp"
+#include "category.hpp"
 #include "config_cachefiles.hpp"
+#include "config_flushonclose.hpp"
+#include "config_follow_symlinks.hpp"
+#include "config_pid.hpp"
 #include "config_inodecalc.hpp"
+#include "config_link_exdev.hpp"
+#include "config_log_metrics.hpp"
 #include "config_moveonenospc.hpp"
 #include "config_nfsopenhack.hpp"
-#include "config_readdir.hpp"
+#include "config_rename_exdev.hpp"
+#include "config_set.hpp"
 #include "config_statfs.hpp"
 #include "config_statfsignore.hpp"
 #include "config_xattr.hpp"
 #include "enum.hpp"
 #include "errno.hpp"
-#include "func_category.hpp"
 #include "funcs.hpp"
+#include "fuse_readdir.hpp"
 #include "policy.hpp"
-#include "policy_cache.hpp"
+#include "rwlock.hpp"
 #include "tofrom_wrapper.hpp"

-#include <fuse.h>
+#include "fuse.h"

+#include <cstdint>
+#include <map>
+#include <memory>
 #include <string>
 #include <vector>

-#include <stdint.h>
 #include <sys/stat.h>

 typedef ToFromWrapper<bool>                 ConfigBOOL;
@@ -47,58 +56,114 @@ typedef ToFromWrapper<int>                  ConfigINT;
 typedef ToFromWrapper<std::string>          ConfigSTR;
 typedef std::map<std::string,ToFromString*> Str2TFStrMap;

+extern const std::string CONTROLFILE;
+
 class Config
 {
+public:
+  struct Err
+  {
+    int err;
+    std::string str;
+  };
+
+  typedef std::vector<Err> ErrVec;
+
+public:
+  class Read
+  {
+  public:
+    Read();
+
+  public:
+    inline const Config* operator->() const;
+
+  private:
+    const Config &_cfg;
+  };
+
+public:
+  class Write
+  {
+  public:
+    Write();
+
+  public:
+    Config* operator->();
+
+  private:
+    Config &_cfg;
+  };
+
 public:
  Config();

 public:
-  mutable PolicyCache open_cache;
-
-public:
-  const std::string controlfile;
+  Config& operator=(const Config&);

 public:
  ConfigBOOL     async_read;
  ConfigBOOL     auto_cache;
+  ConfigUINT64   minfreespace;
  Branches       branches;
+  ConfigUINT64   branches_mount_timeout;
  ConfigUINT64   cache_attr;
  ConfigUINT64   cache_entry;
  CacheFiles     cache_files;
+  ConfigSet      cache_files_process_names;
  ConfigUINT64   cache_negative_entry;
  ConfigBOOL     cache_readdir;
  ConfigUINT64   cache_statfs;
  ConfigBOOL     cache_symlinks;
-  FuncCategories category;
+  Categories     category;
  ConfigBOOL     direct_io;
+  ConfigBOOL     direct_io_allow_mmap;
  ConfigBOOL     dropcacheonclose;
+  ConfigBOOL     export_support;
+  FlushOnClose   flushonclose;
+  FollowSymlinks follow_symlinks;
  ConfigSTR      fsname;
  Funcs          func;
  ConfigUINT64   fuse_msg_size;
  ConfigBOOL     ignorepponrename;
  InodeCalc      inodecalc;
  ConfigBOOL     kernel_cache;
+  ConfigBOOL     lazy_umount_mountpoint;
  ConfigBOOL     link_cow;
-  ConfigUINT64   minfreespace;
-  ConfigSTR      mount;
+  LinkEXDEV      link_exdev;
+  LogMetrics     log_metrics;
+  ConfigSTR      mountpoint;
  MoveOnENOSPC   moveonenospc;
  NFSOpenHack    nfsopenhack;
  ConfigBOOL     nullrw;
-  ConfigUINT64   pid;
+  ConfigBOOL     parallel_direct_writes;
+  ConfigGetPid   pid;
  ConfigBOOL     posix_acl;
-  ReadDir        readdir;
+  ConfigUINT64   readahead;
+  FUSE::ReadDir  readdir;
  ConfigBOOL     readdirplus;
+  RenameEXDEV    rename_exdev;
+  ConfigINT      scheduling_priority;
  ConfigBOOL     security_capability;
  SrcMounts      srcmounts;
  StatFS         statfs;
  StatFSIgnore   statfs_ignore;
  ConfigBOOL     symlinkify;
  ConfigUINT64   symlinkify_timeout;
-  ConfigINT      threads;
+  ConfigINT      fuse_read_thread_count;
+  ConfigINT      fuse_process_thread_count;
+  ConfigINT      fuse_process_thread_queue_depth;
+  ConfigSTR      fuse_pin_threads;
  ConfigSTR      version;
  ConfigBOOL     writeback_cache;
  XAttr          xattr;

+private:
+  bool _initialized;
+
+public:
+  void finish_initializing();
+
 public:
  friend std::ostream& operator<<(std::ostream &s,
                                  const Config &c);
@@ -112,11 +177,50 @@ public:
  int get(const std::string &key, std::string *val) const;
  int set_raw(const std::string &key, const std::string &val);
  int set(const std::string &key, const std::string &val);
+  int set(const std::string &kv);

 public:
-  static const Config &ro(void);
-  static Config       &rw(void);
+  int from_stream(std::istream &istrm, ErrVec *errs);
+  int from_file(const std::string &filepath, ErrVec *errs);

 private:
  Str2TFStrMap _map;
+
+private:
+  static Config _singleton;
+
+public:
+  friend class Read;
+  friend class Write;
 };
+
+std::ostream& operator<<(std::ostream &s,const Config::ErrVec &ev);
+
+inline
+Config::Read::Read()
+  : _cfg(Config::_singleton)
+{
+
+}
+
+inline
+const
+Config*
+Config::Read::operator->() const
+{
+  return &_cfg;
+}
+
+inline
+Config::Write::Write()
+  : _cfg(Config::_singleton)
+{
+
+}
+
+inline
+Config*
+Config::Write::operator->()
+{
+  return &_cfg;
+}
@@ -36,6 +36,8 @@ CacheFiles::to_string() const
      return "full";
    case CacheFiles::ENUM::AUTO_FULL:
      return "auto-full";
+    case CacheFiles::ENUM::PER_PROCESS:
+      return "per-process";
    }

  return "invalid";
@@ -55,6 +57,8 @@ CacheFiles::from_string(const std::string &s_)
    _data = CacheFiles::ENUM::FULL;
  ef(s_ == "auto-full")
    _data = CacheFiles::ENUM::AUTO_FULL;
+  ef(s_ == "per-process")
+    _data = CacheFiles::ENUM::PER_PROCESS;
  else
    return -EINVAL;

@@ -20,13 +20,15 @@

 #include "enum.hpp"

+
 enum class CacheFilesEnum
  {
    LIBFUSE,
    OFF,
    PARTIAL,
    FULL,
-    AUTO_FULL
+    AUTO_FULL,
+    PER_PROCESS
  };

 typedef Enum<CacheFilesEnum> CacheFiles;
@@ -1,5 +1,7 @@
 /*
-  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+  ISC License
+
+  Copyright (c) 2023, 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
@@ -14,20 +16,39 @@
  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

+#include "config_flushonclose.hpp"
+#include "ef.hpp"
 #include "errno.hpp"
-#include "policy.hpp"

-#include <string>
-#include <vector>
-
-using std::string;
-using std::vector;
-
-int
-Policy::Func::invalid(const Category  type_,
-                      const Branches &branches_,
-                      const char     *fusepath_,
-                      vector<string> *paths_)
+template<>
+std::string
+FlushOnClose::to_string() const
 {
-  return (errno=EINVAL,-1);
+  switch(_data)
+    {
+    case FlushOnClose::ENUM::NEVER:
+      return "never";
+    case FlushOnClose::ENUM::OPENED_FOR_WRITE:
+      return "opened-for-write";
+    case FlushOnClose::ENUM::ALWAYS:
+      return "always";
+    }
+
+  return {};
+}
+
+template<>
+int
+FlushOnClose::from_string(const std::string &s_)
+{
+  if(s_ == "never")
+    _data = FlushOnClose::ENUM::NEVER;
+  ef(s_ == "opened-for-write")
+    _data = FlushOnClose::ENUM::OPENED_FOR_WRITE;
+  ef(s_ == "always")
+    _data = FlushOnClose::ENUM::ALWAYS;
+  else
+    return -EINVAL;
+
+  return 0;
 }
--- a/Show More
+++ b/Show More