Merge pull request #1321 from trapexit/allowmmap

Add support for 'direct-io-allow-mmap' if supported by kernel

.cirrus.yml

@@ -5,7 +5,7 @@ freebsd_task:
   env:
     ASSUME_ALWAYS_YES: yes
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - gmake -j4
 
 freebsd_task:
@@ -15,7 +15,7 @@ freebsd_task:
   env:
     ASSUME_ALWAYS_YES: yes
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - gmake -j4
 
 freebsd_task:
@@ -25,7 +25,7 @@ freebsd_task:
   env:
     ASSUME_ALWAYS_YES: yes
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - gmake -j4
 
 freebsd_task:
@@ -35,7 +35,7 @@ freebsd_task:
   env:
     ASSUME_ALWAYS_YES: yes
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - gmake -j4
 
 
@@ -43,7 +43,7 @@ freebsd_task:
 #  osx_instance:
 #    image: catalina-base
 #  script:
-#    - tools/install-build-pkgs
+#    - buildtools/install-build-pkgs
 #    - gmake -j4
 
 linux_task:
@@ -54,7 +54,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -65,7 +65,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -76,7 +76,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -87,7 +87,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -98,7 +98,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -109,7 +109,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -120,7 +120,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -131,7 +131,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -142,7 +142,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make STATIC=1 LTO=1
 
 linux_task:
@@ -153,7 +153,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -165,7 +165,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -177,7 +177,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -189,7 +189,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -201,7 +201,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -213,7 +213,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -225,7 +225,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -237,7 +237,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -249,7 +249,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -261,7 +261,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -273,7 +273,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -285,7 +285,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -297,7 +297,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - make
     - make rpm
 
@@ -309,7 +309,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -324,7 +324,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -339,7 +339,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -354,7 +354,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -369,7 +369,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -384,7 +384,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -399,7 +399,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -414,7 +414,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -429,7 +429,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -444,7 +444,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -459,7 +459,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -474,7 +474,22 @@ linux_task:
     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: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
@@ -489,7 +504,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse
@@ -504,7 +519,7 @@ linux_task:
     memory: 4G
   timeout_in: 15m
   script:
-    - tools/install-build-pkgs
+    - buildtools/install-build-pkgs
     - git fetch
     - make deb
     - apt-get -y install fuse

DEPENDENCIES

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

LICENSE

@@ -1,7 +1,7 @@
 /*
   ISC License
 
-  Copyright (c) 2023, 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

Makefile

@@ -1,4 +1,4 @@
-#  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+#  Copyright (c) 2024, Antonio SJ Musumeci <trapexit@spawn.link>
 #
 #  Permission to use, copy, modify, and/or distribute this software for any
 #  purpose with or without fee is hereby granted, provided that the above
@@ -26,7 +26,7 @@ STRIP     = strip
 PANDOC    = pandoc
 SED       = sed
 RPMBUILD  = rpmbuild
-GIT2DEBCL = ./tools/git2debcl
+GIT2DEBCL = ./buildtools/git2debcl
 PKGCONFIG = pkg-config
 
 GIT_REPO = 0
@@ -42,7 +42,7 @@ UGID_USE_RWLOCK = 0
 ifeq ($(DEBUG),1)
 OPT_FLAGS := -O0 -g -fsanitize=undefined
 else
-OPT_FLAGS := -O2
+OPT_FLAGS := -O2 -DNDEBUG
 endif
 
 ifeq ($(STATIC),1)
@@ -68,6 +68,10 @@ 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} \
@@ -92,6 +96,7 @@ LDFLAGS := \
     -pthread \
     -lrt
 
+# https://www.gnu.org/prep/standards/html_node/Directory-Variables.html
 DESTDIR       =
 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
@@ -99,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
@@ -141,7 +148,7 @@ endif
 
 .PHONY: version
 version:
-	tools/update-version
+	./buildtools/update-version
 
 build/stamp:
 	$(MKDIR) -p build/.src build/.tests
@@ -153,6 +160,10 @@ build/.src/%.o: src/%.cpp
 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
@@ -166,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)"
@@ -180,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"
 
@@ -225,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
@@ -250,7 +265,7 @@ rpm: tarball
 
 .PHONY: install-build-pkgs
 install-build-pkgs:
-	tools/install-build-pkgs
+	./buildtools/install-build-pkgs
 
 .PHONY: libfuse
 libfuse:

README.md

@@ -89,7 +89,12 @@ start with one of the following option sets.
 
 #### You need `mmap` (used by rtorrent and many sqlite3 base software)
 
-`cache.files=partial,dropcacheonclose=true,category.create=mfs`
+`cache.files=auto-full,dropcacheonclose=true,category.create=mfs`
+
+or if you are on a Linux kernel >= 6.6.x mergerfs will enable a mode
+that allows shared mmap when `cache.files=off`. To be sure of the best
+performance between `cache.files=off` and `cache.files=auto-full`
+you'll need to do your own benchmarking but often `off` is faster.
 
 #### You don't need `mmap`
 
@@ -97,11 +102,11 @@ start with one of the following option sets.
 
 ### Command Line
 
-`mergerfs -o cache.files=partial,dropcacheonclose=true,category.create=mfs /mnt/hdd0:/mnt/hdd1 /media`
+`mergerfs -o cache.files=auto-full,dropcacheonclose=true,category.create=mfs /mnt/hdd0:/mnt/hdd1 /media`
 
 ### /etc/fstab
 
-`/mnt/hdd0:/mnt/hdd1 /media fuse.mergerfs cache.files=partial,dropcacheonclose=true,category.create=mfs 0 0`
+`/mnt/hdd0:/mnt/hdd1 /media mergerfs cache.files=auto-full,dropcacheonclose=true,category.create=mfs 0 0`
 
 ### systemd mount
 
@@ -116,7 +121,7 @@ Type=simple
 KillMode=none
 ExecStart=/usr/bin/mergerfs \
   -f \
-  -o cache.files=partial \
+  -o cache.files=auto-full \
   -o dropcacheonclose=true \
   -o category.create=mfs \
   /mnt/hdd0:/mnt/hdd1 \
@@ -162,6 +167,11 @@ These options are the same regardless of whether you use them with the
   longer need the data and it can drop its cache. Recommended when
   **cache.files=partial|full|auto-full|per-process** to limit double
   caching. (default: false)
+* **direct-io-allow-mmap=BOOL**: On newer kernels (>= 6.6) it is
+  possible to disable file page caching while still allowing for
+  shared mmap support. mergerfs will enable this feature if available
+  but an option is provided to turn it off for testing and debugging
+  purposes. (default: true)
 * **symlinkify=BOOL**: When enabled and a file is not writable and its
   mtime or ctime is older than **symlinkify_timeout** files will be
   reported as symlinks to the original files. Please read more below
@@ -180,6 +190,9 @@ These options are the same regardless of whether you use them with the
   link to always use the non-path preserving behavior. This means
   files, when renamed or linked, will stay on the same
   filesystem. (default: false)
+* **export-support=BOOL**: Sets a low-level FUSE feature intended to
+  indicate the filesystem can support being exported via
+  NFS. (default: true)
 * **security_capability=BOOL**: If false return ENOATTR when xattr
   security.capability is queried. (default: true)
 * **xattr=passthrough|noattr|nosys**: Runtime control of
@@ -241,8 +254,16 @@ These options are the same regardless of whether you use them with the
   `read-thread-count` refers to the number of threads reading FUSE
   messages which are dispatched to process threads. -1 means disabled
   otherwise acts like `read-thread-count`. (default: -1)
+* **process-thread-queue-depth=UINT**: Sets the number of requests any
+  single process thread can have queued up at one time. Meaning the
+  total memory usage of the queues is queue depth multiplied by the
+  number of process threads plus read thread count. 0 sets the depth
+  to the same as the process thread count. (default: 0)
 * **pin-threads=STR**: Selects a strategy to pin threads to CPUs
   (default: unset)
+* **flush-on-close=never|always|opened-for-write**: Flush data cache
+  on file close. Mostly for when writeback is enabled or merging
+  network filesystems. (default: opened-for-write)
 * **scheduling-priority=INT**: Set mergerfs' scheduling
   priority. Valid values range from -20 to 19. See `setpriority` man
   page for more details. (default: -10)
@@ -251,6 +272,9 @@ These options are the same regardless of whether you use them with the
   concatenated together with the longest common prefix removed.
 * **func.FUNC=POLICY**: Sets the specific FUSE function's policy. See
   below for the list of value types. Example: **func.getattr=newest**
+* **func.readdir=seq|cosr|cor|cosr:INT|cor:INT**: Sets `readdir`
+  policy. INT value sets the number of threads to use for
+  concurrency. (default: seq)
 * **category.action=POLICY**: Sets policy of all FUSE functions in the
   action category. (default: epall)
 * **category.create=POLICY**: Sets policy of all FUSE functions in the
@@ -279,6 +303,10 @@ These options are the same regardless of whether you use them with the
   (default: false)
 * **cache.readdir=BOOL**: Cache readdir (if supported by kernel)
   (default: false)
+* **parallel-direct-writes=BOOL**: Allow the kernel to dispatch
+  multiple, parallel (non-extending) write requests for files opened
+  with `cache.files=per-process` (if the process is not in `process-names`)
+  or `cache.files=off`. (This requires kernel support, and was added in v6.2)
 * **direct_io**: deprecated - Bypass page cache. Use `cache.files=off`
   instead. (default: false)
 * **kernel_cache**: deprecated - Do not invalidate data cache on file
@@ -292,8 +320,8 @@ These options are the same regardless of whether you use them with the
 * **splice_read**: deprecated - Does nothing.
 * **splice_write**: deprecated - Does nothing.
 * **splice_move**: deprecated - Does nothing.
-* **allow_other**: deprecated - mergerfs always sets this FUSE option
-  as normal permissions can be used to limit access.
+* **allow_other**: deprecated - mergerfs v2.35.0 and newer sets this FUSE option
+  automatically if running as root.
 * **use_ino**: deprecated - mergerfs should always control inode
   calculation so this is enabled all the time.
 
@@ -370,8 +398,8 @@ The above line will use all mount points in /mnt prefixed with **hdd** and **ssd
 To have the pool mounted at boot or otherwise accessible from related tools use **/etc/fstab**.
 
 ```
-# <file system>        <mount point>  <type>         <options>             <dump>  <pass>
-/mnt/hdd*:/mnt/ssd    /media          fuse.mergerfs  minfreespace=16G      0       0
+# <file system>        <mount point>  <type>    <options>             <dump>  <pass>
+/mnt/hdd*:/mnt/ssd    /media          mergerfs  minfreespace=16G      0       0
 ```
 
 **NOTE:** the globbing is done at mount or when updated using the
@@ -400,7 +428,7 @@ or file is to be selected or something changes out of band it becomes
 unclear what value should be used. Most software does not to care what
 the values are but those that do often break if a value changes
 unexpectedly. The tool `find` will abort a directory walk if it sees a
-directory inode change. NFS will return stale handle errors if the
+directory inode change. NFS can return stale handle errors if the
 inode changes out of band. File dedup tools will usually leverage
 device ids and inodes as a shortcut in searching for duplicate files
 and would resort to full file comparisons should it find different
@@ -655,10 +683,23 @@ writable.
 Even though it's a more niche situation this hack breaks normal
 security and behavior and as such is `off` by default. If set to `git`
 it will only perform the hack when the path in question includes
-`/.git/`. `all` will result it applying anytime a readonly file which
+`/.git/`. `all` will result it applying anytime a read-only file which
 is empty is opened for writing.
 
 
+### export-support
+
+In theory this flag should not be exposed to the end user. It is a
+low-level FUSE flag which indicates whether or not the kernel can send
+certain kinds of messages to it for the purposes of using with
+NFS. mergerfs does support these messages but due bugs and quirks
+found in the kernel and mergerfs this option is provided just in case
+it is needed for debugging.
+
+Given that this flag is set when the FUSE connection is first
+initiated it is not possible to change during run time.
+
+
 # FUNCTIONS, CATEGORIES and POLICIES
 
 The POSIX filesystem API is made up of a number of
@@ -674,9 +715,8 @@ rather than file paths, which were created by `open` or `create`. That
 said many times the current FUSE kernel driver will not always provide
 the file handle when a client calls `fgetattr`, `fchown`, `fchmod`,
 `futimens`, `ftruncate`, etc. This means it will call the regular,
-path based, versions. `readdir` has no real need for a policy given
-the purpose is merely to return a list of entries in a
-directory. `statfs`'s behavior can be modified via other options.
+path based, versions. `statfs`'s behavior can be modified via other
+options.
 
 When using policies which are based on a branch's available space the
 base path provided is used. Not the full path to the file in
@@ -684,8 +724,8 @@ question. Meaning that mounts in the branch won't be considered in the
 space calculations. The reason is that it doesn't really work for
 non-path preserving policies and can lead to non-obvious behaviors.
 
-NOTE: While any policy can be assigned to a function or category
-though some may not be very useful in practice. For instance: **rand**
+NOTE: While any policy can be assigned to a function or category,
+some may not be very useful in practice. For instance: **rand**
 (random) may be useful for file creation (create) but could lead to
 very odd behavior if used for `chmod` if there were more than one copy
 of the file.
@@ -707,8 +747,7 @@ In cases where something may be searched for (such as a path to clone)
 ### Policies
 
 A policy is the algorithm used to choose a branch or branches for a
-function to work on. Think of them as ways to filter and sort
-branches.
+function to work on or generally how the function behaves.
 
 Any function in the `create` category will clone the relative path if
 needed. Some other functions (`rename`,`link`,`ioctl`) have special
@@ -717,12 +756,11 @@ requirements or behaviors which you can read more about below.
 
 #### Filtering
 
-Policies basically search branches and create a list of files / paths
+Most policies basically search branches and create a list of files / paths
 for functions to work on. The policy is responsible for filtering and
 sorting the branches. Filters include **minfreespace**, whether or not
 a branch is mounted read-only, and the branch tagging
-(RO,NC,RW). These filters are applied across all policies unless
-otherwise noted.
+(RO,NC,RW). These filters are applied across most policies.
 
 * No **search** function policies filter.
 * All **action** function policies filter out branches which are
@@ -739,6 +777,12 @@ If all branches are filtered an error will be returned. Typically
 device) depending on the most recent reason for filtering a
 branch. **ENOENT** will be returned if no eligible branch is found.
 
+If **create**, **mkdir**, **mknod**, or **symlink** fail with `EROFS`
+or other fundimental errors then mergerfs will mark any branch found
+to be read-only as such (IE will set the mode `RO`) and will rerun the
+policy and try again. This is mostly for `ext4` filesystems that can
+suddenly become read-only when it encounters an error.
+
 
 #### Path Preservation
 
@@ -809,6 +853,26 @@ policies is not appropriate.
 | search   | ff     |
 
 
+#### func.readdir
+
+examples: `func.readdir=seq`, `func.readdir=cor:4`
+
+`readdir` has policies to control how it manages reading directory
+content.
+
+| Policy | Description |
+|--------|-------------|
+| seq    | "sequential" : Iterate over branches in the order defined. This is the default and traditional behavior found prior to the readdir policy introduction. |
+| cosr   | "concurrent open, sequential read" : Concurrently open branch directories using a thread pool and process them in order of definition. This keeps memory and CPU usage low while also reducing the time spent waiting on branches to respond. Number of threads defaults to the number of logical cores. Can be overwritten via the syntax `func.readdir=cosr:N` where `N` is the number of threads. |
+| cor    | "concurrent open and read" : Concurrently open branch directories and immediately start reading their contents using a thread pool. This will result in slightly higher memory and CPU usage but reduced latency. Particularly when using higher latency / slower speed network filesystem branches. Unlike `seq` and `cosr` the order of files could change due the async nature of the thread pool. Number of threads defaults to the number of logical cores. Can be overwritten via the syntax `func.readdir=cor:N` where `N` is the number of threads.
+
+Keep in mind that `readdir` mostly just provides a list of file names
+in a directory and possibly some basic metadata about said files. To
+know details about the files, as one would see from commands like
+`find` or `ls`, it is required to call `stat` on the file which is
+controlled by `fuse.getattr`.
+
+
 #### ioctl
 
 When `ioctl` is used with an open file then it will use the file
@@ -877,19 +941,6 @@ returned but it will still be possible.
 **link** uses the same strategy but without the removals.
 
 
-#### readdir ####
-
-[readdir](http://linux.die.net/man/3/readdir) is different from all
-other filesystem functions. While it could have its own set of
-policies to tweak its behavior at this time it provides a simple union
-of files and directories found. Remember that any action or
-information queried about these files and directories come from the
-respective function. For instance: an **ls** is a **readdir** and for
-each file/directory returned **getattr** is called. Meaning the policy
-of **getattr** is responsible for choosing the file/directory which is
-the source of the metadata you see in an **ls**.
-
-
 #### statfs / statvfs ####
 
 [statvfs](http://linux.die.net/man/2/statvfs) normalizes the source
@@ -904,6 +955,27 @@ The options `statfs` and `statfs_ignore` can be used to modify
 `statfs` behavior.
 
 
+#### flush-on-close
+
+https://lkml.kernel.org/linux-fsdevel/20211024132607.1636952-1-amir73il@gmail.com/T/
+
+By default FUSE would issue a flush before the release of a file
+descriptor. This was considered a bit aggressive and a feature added
+to give the FUSE server the ability to choose when that happens.
+
+Options:
+* always
+* never
+* opened-for-write
+
+For now it defaults to "opened-for-write" which is less aggressive
+than the behavior before this feature was added. It should not be a
+problem because the flush is really only relevant when a file is
+written to. Given flush is irrelevant for many filesystems in the
+future a branch specific flag may be added so only files opened on a
+specific branch would be flushed on close.
+
+
 # ERROR HANDLING
 
 POSIX filesystem functions offer a single return code meaning that
@@ -1108,8 +1180,8 @@ mount. If you plan on changing settings with the new mount you should
 ```
 $ sudo mount /mnt/mergerfs
 $ mount | grep mergerfs
-media on /mnt/mergerfs type fuse.mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
-media on /mnt/mergerfs type fuse.mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
+media on /mnt/mergerfs type mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
+media on /mnt/mergerfs type mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
 ```
 
 A problem with this approach is that the underlying instance will
@@ -1120,7 +1192,9 @@ issue: `umount -l <mergerfs_mountpoint>`. Or you can let mergerfs do
 it by setting the option `lazy-umount-mountpoint=true`.
 
 
-# RUNTIME CONFIG
+# RUNTIME INTERFACES
+
+## RUNTIME CONFIG
 
 #### .mergerfs pseudo file ####
 
@@ -1203,8 +1277,139 @@ following:
 * **user.mergerfs.allpaths**: a NUL ('\0') separated list of full paths to all files found
 
 
+## SIGNALS
+
+* USR1: This will cause mergerfs to send invalidation notifications to
+  the kernel for all files. This will cause all unused files to be
+  released from memory.
+* USR2: Trigger a general cleanup of currently unused memory. A more
+  thorough version of what happens every ~15 minutes.
+
+
+## IOCTLS
+
+Found in `fuse_ioctl.cpp`:
+
+```C++
+typedef char IOCTL_BUF[4096];
+#define IOCTL_APP_TYPE  0xDF
+#define IOCTL_FILE_INFO            _IOWR(IOCTL_APP_TYPE,0,IOCTL_BUF)
+#define IOCTL_GC                   _IO(IOCTL_APP_TYPE,1)
+#define IOCTL_GC1                  _IO(IOCTL_APP_TYPE,2)
+#define IOCTL_INVALIDATE_ALL_NODES _IO(IOCTL_APP_TYPE,3)
+```
+
+* IOCTL\_FILE\_INFO: Same as the "file / directory xattrs" mentioned
+  above. Use a buffer size of 4096 bytes. Pass in a string of
+  "basepath", "relpath", "fullpath", or "allpaths". Receive details in
+  same buffer.
+* IOCTL\_GC: Triggers a thorough garbage collection of excess
+  memory. Same as SIGUSR2.
+* IOCTL\_GC1: Triggers a simple garbage collection of excess
+  memory. Same as what happens every 15 minutes normally.
+* IOCTL\_INVALIDATE\_ALL\_NODES: Same as SIGUSR1. Send invalidation
+  notifications to the kernel for all files causing unused files to be
+  released from memory.
+
+
 # TOOLING
 
+## preload.so
+
+EXPERIMENTAL
+
+For some time there has been work to enable passthrough IO in
+FUSE. Passthrough IO would allow for near native performance with
+regards to reads and writes (at the expense of certain mergerfs
+features.) However, there have been several complications which have
+kept the feature from making it into the mainline Linux kernel. Until
+that feature is available there are two methods to provide similar
+functionality. One method is using the LD_PRELOAD feature of the
+dynamic linker. The other leveraging ptrace to intercept
+syscalls. Each has their disadvantages. At the moment only a preload
+based tool is available. A ptrace based tool may be developed later if
+there is a need.
+
+`/usr/lib/mergerfs/preload.so`
+
+This [preloadable
+library](https://man7.org/linux/man-pages/man8/ld.so.8.html#ENVIRONMENT)
+overrides the creation and opening of files in order to simulate
+passthrough file IO. It catches the open/creat/fopen calls, has
+mergerfs do the call, queries mergerfs for the branch the file exists
+on, reopens the file on the underlying filesystem and returns that
+instead. Meaning that you will get native read/write performance
+because mergerfs is no longer part of the workflow. Keep in mind that
+this also means certain mergerfs features that work by interrupting
+the read/write workflow, such as `moveonenospc`, will no longer work.
+
+Also understand that this will only work on dynamically linked
+software. Anything statically compiled will not work. Many GoLang and
+Rust apps are statically compiled.
+
+The library will not interfere with non-mergerfs filesystems. The
+library is written to always fallback to returning the mergerfs opened
+file on error.
+
+While the library was written to account for a number of edgecases
+there could be some yet accounted for so please report any oddities.
+
+Thank you to
+[nohajc](https://github.com/nohajc/mergerfs-io-passthrough) for
+prototyping the idea.
+
+
+### general usage
+
+```sh
+LD_PRELOAD=/usr/lib/mergerfs/preload.so touch /mnt/mergerfs/filename
+```
+
+### Docker usage
+
+Assume `/mnt/fs0` and `/mnt/fs1` are pooled with mergerfs at `/media`.
+
+All mergerfs branch paths *must* be bind mounted into the container at
+the same path as found on the host so the preload library can see them.
+
+```sh
+docker run \
+  -e LD_PRELOAD=/usr/lib/mergerfs/preload.so \
+  -v /usr/lib/mergerfs/preload.so:/usr/lib/mergerfs/preload.so:ro \
+  -v /media:/data \
+  -v /mnt:/mnt \
+  ubuntu:latest \
+  bash
+```
+
+or more explicitly
+
+```sh
+docker run \
+  -e LD_PRELOAD=/usr/lib/mergerfs/preload.so \
+  -v /usr/lib/mergerfs/preload.so:/usr/lib/mergerfs/preload.so:ro \
+  -v /media:/data \
+  -v /mnt/fs0:/mnt/fs0 \
+  -v /mnt/fs1:/mnt/fs1 \
+  ubuntu:latest \
+  bash
+```
+
+### systemd unit
+
+Use the `Environment` option to set the LD_PRELOAD variable.
+
+* https://www.freedesktop.org/software/systemd/man/latest/systemd.service.html#Command%20lines
+* https://serverfault.com/questions/413397/how-to-set-environment-variable-in-systemd-service
+
+```
+[Service]
+Environment=LD_PRELOAD=/usr/lib/mergerfs/preload.so
+```
+
+
+## Misc
+
 * https://github.com/trapexit/mergerfs-tools
   * mergerfs.ctl: A tool to make it easier to query and configure mergerfs at runtime
   * mergerfs.fsck: Provides permissions and ownership auditing and the ability to fix them
@@ -1235,12 +1440,13 @@ https://en.wikipedia.org/wiki/Page_cache
   unchanged since previous open.
 * cache.files=libfuse: follow traditional libfuse `direct_io`,
   `kernel_cache`, and `auto_cache` arguments.
-* cache.files=per-process: Enable page caching only for processes
-  which 'comm' name matches one of the values defined in
-  `cache.files.process-names`.
+* cache.files=per-process: Enable page caching (equivalent to
+  `cache.files=partial`) only for processes whose 'comm' name matches
+  one of the values defined in `cache.files.process-names`. If the
+  name does not match the file open is equivalent to
+  `cache.files=off`.
 
-FUSE, which mergerfs uses, offers a number of page caching
-modes. mergerfs tries to simplify their use via the `cache.files`
+FUSE, which mergerfs uses, offers a number of page caching modes. mergerfs tries to simplify their use via the `cache.files`
 option. It can and should replace usage of `direct_io`,
 `kernel_cache`, and `auto_cache`.
 
@@ -1369,7 +1575,7 @@ placing of usually smaller, faster storage as a transparent cache to
 larger, slower storage. NVMe, SSD, Optane in front of traditional HDDs
 for instance.
 
-MergerFS does not natively support any sort of tiered caching. Most
+mergerfs does not natively support any sort of tiered caching. Most
 users have no use for such a feature and its inclusion would
 complicate the code. However, there are a few situations where a cache
 filesystem could help with a typical mergerfs setup.
@@ -1461,6 +1667,7 @@ understand what behaviors it may impact
 * disable `security_capability` and/or `xattr`
 * increase cache timeouts `cache.attr`, `cache.entry`, `cache.negative_entry`
 * enable (or disable) page caching (`cache.files`)
+* enable `parallel-direct-writes`
 * enable `cache.writeback`
 * enable `cache.statfs`
 * enable `cache.symlinks`
@@ -1664,27 +1871,24 @@ on page caching.
 
 #### NFS clients returning ESTALE / Stale file handle
 
-NFS does not like out of band changes. That is especially true of
-inode values.
-
-Be sure to use the following options:
-
-* noforget
-* inodecalc=path-hash
+NFS generally does not like out of band changes. Take a look at the
+section on NFS in the [#remote-filesystems](#remote-filesystems) for
+more details.
 
 
 #### rtorrent fails with ENODEV (No such device)
 
-Be sure to set `cache.files=partial|full|auto-full|per-processe` or
-turn off `direct_io`. rtorrent and some other applications use
-[mmap](http://linux.die.net/man/2/mmap) to read and write to files and
-offer no fallback to traditional methods. FUSE does not currently
-support mmap while using `direct_io`. There may be a performance
-penalty on writes with `direct_io` off as well as the problem of
-double caching but it's the only way to get such applications to
-work. If the performance loss is too high for other apps you can mount
-mergerfs twice. Once with `direct_io` enabled and one without it. Be
-sure to set `dropcacheonclose=true` if not using `direct_io`.
+Be sure to set
+`cache.files=partial|full|auto-full|per-processe`. rtorrent and some
+other applications use [mmap](http://linux.die.net/man/2/mmap) to read
+and write to files and offer no fallback to traditional methods. FUSE
+does not currently support mmap while using `direct_io`. There may be
+a performance penalty on writes with `direct_io` off as well as the
+problem of double caching but it's the only way to get such
+applications to work. If the performance loss is too high for other
+apps you can mount mergerfs twice. Once with `direct_io` enabled and
+one without it. Be sure to set `dropcacheonclose=true` if not using
+`direct_io`.
 
 
 #### Plex doesn't work with mergerfs
@@ -1820,6 +2024,124 @@ containers or use a standard shared user & groups technology like NIS
 or LDAP.
 
 
+# Remote Filesystems
+
+Many users ask about compatibility with remote filesystems. This
+section is to describe any known issues or quirks when using mergerfs
+with common remote filesystems.
+
+Keep in mind that, like with caching, it is not a good idea to change
+the contents of the remote filesystem
+[out-of-band](https://en.wikipedia.org/wiki/Out-of-band). Meaning that
+you really shouldn't change the contents of the underlying
+filesystems or mergerfs on the server hosting the remote
+filesystem. Doing so can lead to weird behavior, inconsistency,
+errors, and even data corruption should multiple programs try to write
+or read the same data at the same time. This isn't to say you can't do
+it or that data corruption is likely but it *could* happen. It is
+better to always use the remote filesystem. Even on the machine
+serving it.
+
+
+## NFS
+
+[NFS](https://en.wikipedia.org/wiki/Network_File_System) is a common
+remote filesystem on Unix/POSIX systems. Due to how NFS works there
+are some settings which need to be set in order for mergerfs to work
+with it.
+
+It should be noted that NFS and FUSE (the technology mergerfs uses) do
+not work perfectly with one another due to certain design choices in
+FUSE (and mergerfs.) Due to these issues it is generally recommended
+to use SMB when possible till situations change. That said mergerfs
+should generally work as an export of NFS and issues discovered should
+still be reported.
+
+To ensure compatibility between mergerfs and NFS use the following
+settings.
+
+mergerfs settings:
+* noforget
+* inodecalc=path-hash
+
+NFS export settings:
+* fsid=UUID
+* no\_root\_squash
+
+`noforget` is needed because NFS uses the `name_to_handle_at` and
+`open_by_handle_at` functions which allow a program to keep a
+reference to a file without technically having it open in the typical
+sense. The problem is that FUSE has no way to know that NFS has a
+handle that it will later use to open the file again. As a result it
+is possible for the kernel to tell mergerfs to forget about the node
+and should NFS ever ask for that node's details in the future it would
+have nothing to respond with. Keeping nodes around forever is not
+ideal but at the moment the only way to manage the situation.
+
+`inodecalc=path-hash` is needed because NFS is sensitive to
+out-of-band changes. FUSE doesn't care if a file's inode value changes
+but NFS, being stateful, does. So if you used the default inode
+calculation algorithm then it is possible that if you changed a file
+or updated a directory the file mergerfs will use will be on a
+different branch and therefore the inode would change. This isn't an
+ideal solution and others are being considered but it works for most
+situations.
+
+`fsid=UUID` is needed because FUSE filesystems don't have different
+`st_dev` values which can cause issues when exporting. The easiest
+thing to do is set each mergerfs export `fsid` to some random
+value. An easy way to generate a random value is to use the command
+line tool `uuid` or `uuidgen` or through a website such as
+[uuidgenerator.net](https://www.uuidgenerator.net/).
+
+`no_root_squash` is not strictly necessary but can lead to confusing
+permission and ownership issues if root squashing is enabled.
+
+
+## SMB / CIFS
+
+[SMB](https://en.wikipedia.org/wiki/Server_Message_Block) is a
+protocol most used by Microsoft Windows systems to share file shares,
+printers, etc. However, due to the popularity for Windows, it is also
+supported on many other platforms including Linux. The most popular
+way of supporting SMB on Linux is via the software Samba.
+
+[Samba](https://en.wikipedia.org/wiki/Samba_(software)), and other
+ways of serving Linux filesystems, via SMB should work fine with
+mergerfs. The services do not tend to use the same technologies which
+NFS uses and therefore don't have the same issues. There should not be
+an special settings required to use mergerfs with Samba. However,
+[CIFSD](https://en.wikipedia.org/wiki/CIFSD) and other programs have
+not been extensively tested. If you use mergerfs with CIFSD or other
+SMB servers please submit your experiences so these docs can be
+updated.
+
+
+## SSHFS
+
+[SSHFS](https://en.wikipedia.org/wiki/SSHFS) is a FUSE filesystem
+leveraging SSH as the connection and transport layer. While often
+simpler to setup when compared to NFS or Samba the performance can be
+lacking and the project is very much in maintenance mode.
+
+There are no known issues using sshfs with mergerfs. You may want to
+use the following arguments to improve performance but your millage
+may vary.
+
+* `-o Ciphers=arcfour`
+* `-o Compression=no`
+
+More info can be found
+[here](https://ideatrash.net/2016/08/odds-and-ends-optimizing-sshfs-moving.html).
+
+
+## Other
+
+There are other remote filesystems but none popularly used to serve
+mergerfs. If you use something not listed above feel free to reach out
+and I will add it to the list.
+
+
 # FAQ
 
 #### How well does mergerfs scale? Is it "production ready?"
@@ -1841,18 +2163,51 @@ of which are fixed in stable releases.
 
 #### Can mergerfs be used with filesystems which already have data / are in use?
 
-Yes. MergerFS is a proxy and does **NOT** interfere with the normal
-form or function of the filesystems / mounts / paths it manages.
+Yes. mergerfs is really just a proxy and does **NOT** interfere with
+the normal form or function of the filesystems / mounts / paths it
+manages. It is just another userland application that is acting as a
+man-in-the-middle. It can't do anything that any other random piece of
+software can't do.
 
-MergerFS is **not** a traditional filesystem. MergerFS is **not**
-RAID. It does **not** manipulate the data that passes through it. It
-does **not** shard data across filesystems. It merely shards some
-**behavior** and aggregates others.
+mergerfs is **not** a traditional filesystem that takes control over
+the underlying block device. mergerfs is **not** RAID. It does **not**
+manipulate the data that passes through it. It does **not** shard data
+across filesystems. It merely shards some **behavior** and aggregates
+others.
+
+
+#### Can drives/filesystems be removed from the pool at will?
+
+Yes. See previous question's answer.
 
 
 #### Can mergerfs be removed without affecting the data?
 
-See the previous question's answer.
+Yes. See the previous question's answer.
+
+
+#### Can drives/filesystems be moved to another pool?
+
+Yes. See the previous question's answer.
+
+
+#### How do I migrate data into or out of the pool when adding/removing drives/filesystems?
+
+You don't need to. See the previous question's answer.
+
+
+#### How do I remove a drive/filesystem but keep the data in the pool?
+
+Nothing special needs to be done. Remove the branch from mergerfs'
+config and copy (rsync) the data from the removed filesystem into the
+pool. Effectively the same as if it were you transfering data from one
+filesystem to another.
+
+If you wish to continue using the pool while performing the transfer
+simply create another, temporary pool without the filesystem in
+question and then copy the data. It would probably be a good idea to
+set the branch to `RO` prior to doing this to ensure no new content is
+written to the filesystem while performing the copy.
 
 
 #### What policies should I use?
@@ -1921,15 +2276,16 @@ first directory will be placed on the same branch because it is
 preserving paths.
 
 This catches a lot of new users off guard but changing the default
-would break the setup for many existing users. If you do not care
-about path preservation and wish your files to be spread across all
-your filesystems change to `mfs` or similar policy as described
-above. If you do want path preservation you'll need to perform the
-manual act of creating paths on the filesystems you want the data to
-land on before transferring your data. Setting `func.mkdir=epall` can
-simplify managing path preservation for `create`. Or use
-`func.mkdir=rand` if you're interested in just grouping together
-directory content by filesystem.
+would break the setup for many existing users and this policy is the
+safest policy as it will not change the general layout of the existing
+filesystems. If you do not care about path preservation and wish your
+files to be spread across all your filesystems change to `mfs` or
+similar policy as described above. If you do want path preservation
+you'll need to perform the manual act of creating paths on the
+filesystems you want the data to land on before transferring your
+data. Setting `func.mkdir=epall` can simplify managing path
+preservation for `create`. Or use `func.mkdir=rand` if you're
+interested in just grouping together directory content by filesystem.
 
 
 #### Do hardlinks work?
@@ -1951,6 +2307,16 @@ mergerfs pool that includes all the paths you need if you want links
 to work.
 
 
+#### Does FICLONE or FICLONERANGE work?
+
+Unfortunately not. FUSE, the technology mergerfs is based on, does not
+support the `clone_file_range` feature needed for it to work. mergerfs
+won't even know such a request is made. The kernel will simply return
+an error back to the application making the request.
+
+Should FUSE gain the ability mergerfs will be updated to support it.
+
+
 #### Can I use mergerfs without SnapRAID? SnapRAID without mergerfs?
 
 Yes. They are completely unrelated pieces of software.
@@ -2012,8 +2378,8 @@ values are correct and that directories have their executable bit
 set. A common mistake by users new to Linux is to `chmod -R 644` when
 they should have `chmod -R u=rwX,go=rX`.
 
-If using a network filesystem such as NFS, SMB, CIFS (Samba) be sure
-to pay close attention to anything regarding permissioning and
+If using a network filesystem such as NFS or SMB (Samba) be sure to
+pay close attention to anything regarding permissioning and
 users. Root squashing and user translation for instance has bitten a
 few mergerfs users. Some of these also affect the use of mergerfs from
 container platforms such as Docker.
@@ -2069,103 +2435,6 @@ traditional read/write fallback to be provided. The splice code was
 removed to simplify the codebase.
 
 
-#### Why use mergerfs over mhddfs?
-
-mhddfs is no longer maintained and has some known stability and
-security issues (see below). MergerFS provides a superset of mhddfs'
-features and should offer the same or maybe better performance.
-
-Below is an example of mhddfs and mergerfs setup to work similarly.
-
-`mhddfs -o mlimit=4G,allow_other /mnt/drive1,/mnt/drive2 /mnt/pool`
-
-`mergerfs -o minfreespace=4G,category.create=ff /mnt/drive1:/mnt/drive2 /mnt/pool`
-
-
-#### Why use mergerfs over aufs?
-
-aufs is mostly abandoned and no longer available in many distros.
-
-While aufs can offer better peak performance mergerfs provides more
-configurability and is generally easier to use. mergerfs however does
-not offer the overlay / copy-on-write (CoW) features which aufs and
-overlayfs have.
-
-
-#### Why use mergerfs over unionfs?
-
-UnionFS is more like aufs than mergerfs in that it offers overlay /
-CoW features. If you're just looking to create a union of filesystems
-and want flexibility in file/directory placement then mergerfs offers
-that whereas unionfs is more for overlaying RW filesystems over RO
-ones.
-
-
-#### Why use mergerfs over overlayfs?
-
-Same reasons as with unionfs.
-
-
-#### Why use mergerfs over LVM/ZFS/BTRFS/RAID0 drive concatenation / striping?
-
-With simple JBOD / drive concatenation / stripping / RAID0 a single
-drive failure will result in full pool failure. mergerfs performs a
-similar function without the possibility of catastrophic failure and
-the difficulties in recovery. Drives may fail, however, all other data
-will continue to be accessible.
-
-When combined with something like [SnapRaid](http://www.snapraid.it)
-and/or an offsite backup solution you can have the flexibility of JBOD
-without the single point of failure.
-
-
-#### Why use mergerfs over ZFS?
-
-MergerFS is not intended to be a replacement for ZFS. MergerFS is
-intended to provide flexible pooling of arbitrary filesystems (local
-or remote), of arbitrary sizes, and arbitrary filesystems. For `write
-once, read many` usecases such as bulk media storage. Where data
-integrity and backup is managed in other ways. In that situation ZFS
-can introduce a number of costs and limitations as described
-[here](http://louwrentius.com/the-hidden-cost-of-using-zfs-for-your-home-nas.html),
-[here](https://markmcb.com/2020/01/07/five-years-of-btrfs/), and
-[here](https://utcc.utoronto.ca/~cks/space/blog/solaris/ZFSWhyNoRealReshaping).
-
-
-#### Why use mergerfs over UnRAID?
-
-UnRAID is a full OS and its storage layer, as I understand, is
-proprietary and closed source. Users who have experience with both
-have said they prefer the flexibility offered by mergerfs and for some
-the fact it is free and open source is important.
-
-There are a number of UnRAID users who use mergerfs as well though I'm
-not entirely familiar with the use case.
-
-
-#### Why use mergerfs over StableBit's DrivePool?
-
-DrivePool works only on Windows so not as common an alternative as
-other Linux solutions. If you want to use Windows then DrivePool is a
-good option. Functionally the two projects work a bit
-differently. DrivePool always writes to the filesystem with the most
-free space and later rebalances. mergerfs does not offer rebalance but
-chooses a branch at file/directory create time. DrivePool's
-rebalancing can be done differently in any directory and has file
-pattern matching to further customize the behavior. mergerfs, not
-having rebalancing does not have these features, but similar features
-are planned for mergerfs v3. DrivePool has builtin file duplication
-which mergerfs does not natively support (but can be done via an
-external script.)
-
-There are a lot of misc differences between the two projects but most
-features in DrivePool can be replicated with external tools in
-combination with mergerfs.
-
-Additionally DrivePool is a closed source commercial product vs
-mergerfs a ISC licensed OSS project.
-
-
 #### What should mergerfs NOT be used for?
 
 * databases: Even if the database stored data in separate files
@@ -2232,37 +2501,13 @@ it won't show up.
 You can remove the reserve by running: `tune2fs -m 0 <device>`
 
 
-#### Can mergerfs mounts be exported over NFS?
-
-Yes, however if you do anything which may changes files out of band
-(including for example using the `newest` policy) it will result in
-"stale file handle" errors unless properly setup.
-
-Be sure to use the following options:
-
-* noforget
-* inodecalc=path-hash
-
-
-#### Can mergerfs mounts be exported over Samba / SMB?
-
-Yes. While some users have reported problems it appears to always be
-related to how Samba is setup in relation to permissions.
-
-
-#### Can mergerfs mounts be used over SSHFS?
-
-Yes.
-
-
 #### I notice massive slowdowns of writes when enabling cache.files.
 
-When file caching is enabled in any form (`cache.files!=off` or
-`direct_io=false`) it will issue `getxattr` requests for
-`security.capability` prior to *every single write*. This will usually
-result in a performance degradation, especially when using a network
-filesystem (such as NFS or CIFS/SMB/Samba.) Unfortunately at this
-moment the kernel is not caching the response.
+When file caching is enabled in any form (`cache.files!=off`) it will
+issue `getxattr` requests for `security.capability` prior to *every
+single write*. This will usually result in a performance degradation,
+especially when using a network filesystem (such as NFS or SMB.)
+Unfortunately at this moment the kernel is not caching the response.
 
 To work around this situation mergerfs offers a few solutions.
 
@@ -2317,6 +2562,114 @@ used so threads trying to change credentials don't starve. This isn't
 the best solution but should work reasonably well assuming there are
 few users.
 
+# mergerfs versus X
+
+#### mhddfs
+
+mhddfs had not been maintained for some time and has some known
+stability and security issues. mergerfs provides a superset of mhddfs'
+features and should offer the same or better performance.
+
+Below is an example of mhddfs and mergerfs setup to work similarly.
+
+`mhddfs -o mlimit=4G,allow_other /mnt/drive1,/mnt/drive2 /mnt/pool`
+
+`mergerfs -o minfreespace=4G,category.create=ff /mnt/drive1:/mnt/drive2 /mnt/pool`
+
+
+#### aufs
+
+aufs is mostly abandoned and no longer available in most Linux distros.
+
+While aufs can offer better peak performance mergerfs provides more
+configurability and is generally easier to use. mergerfs however does
+not offer the overlay / copy-on-write (CoW) features which aufs has.
+
+
+#### unionfs-fuse
+
+unionfs-fuse is more like aufs than mergerfs in that it offers overlay /
+copy-on-write (CoW) features. If you're just looking to create a union
+of filesystems and want flexibility in file/directory placement then
+mergerfs offers that whereas unionfs is more for overlaying read/write
+filesystems over read-only ones.
+
+
+#### overlayfs
+
+overlayfs is similar to aufs and unionfs-fuse in that it also is
+primarily used to layer a read/write filesystem over one or more
+read-only filesystems. It does not have the ability to spread
+files/directories across numerous filesystems.
+
+
+#### RAID0, JBOD, drive concatenation, striping
+
+With simple JBOD / drive concatenation / stripping / RAID0 a single
+drive failure will result in full pool failure. mergerfs performs a
+similar function without the possibility of catastrophic failure and
+the difficulties in recovery. Drives may fail but all other
+filesystems and their data will continue to be accessible.
+
+The main practical difference with mergerfs is the fact you don't
+actually have contiguous space as large as if you used those other
+technologies. Meaning you can't create a 2TB file on a pool of 2 1TB
+filesystems.
+
+When combined with something like [SnapRaid](http://www.snapraid.it)
+and/or an offsite backup solution you can have the flexibility of JBOD
+without the single point of failure.
+
+
+#### UnRAID
+
+UnRAID is a full OS and its storage layer, as I understand, is
+proprietary and closed source. Users who have experience with both
+have often said they prefer the flexibility offered by mergerfs and
+for some the fact it is open source is important.
+
+There are a number of UnRAID users who use mergerfs as well though I'm
+not entirely familiar with the use case.
+
+For semi-static data mergerfs + [SnapRaid](http://www.snapraid.it)
+provides a similar solution.
+
+
+#### ZFS
+
+mergerfs is very different from ZFS. mergerfs is intended to provide
+flexible pooling of arbitrary filesystems (local or remote), of
+arbitrary sizes, and arbitrary filesystems. For `write once, read
+many` usecases such as bulk media storage. Where data integrity and
+backup is managed in other ways. In those usecases ZFS can introduce a
+number of costs and limitations as described
+[here](http://louwrentius.com/the-hidden-cost-of-using-zfs-for-your-home-nas.html),
+[here](https://markmcb.com/2020/01/07/five-years-of-btrfs/), and
+[here](https://utcc.utoronto.ca/~cks/space/blog/solaris/ZFSWhyNoRealReshaping).
+
+
+#### StableBit's DrivePool
+
+DrivePool works only on Windows so not as common an alternative as
+other Linux solutions. If you want to use Windows then DrivePool is a
+good option. Functionally the two projects work a bit
+differently. DrivePool always writes to the filesystem with the most
+free space and later rebalances. mergerfs does not offer rebalance but
+chooses a branch at file/directory create time. DrivePool's
+rebalancing can be done differently in any directory and has file
+pattern matching to further customize the behavior. mergerfs, not
+having rebalancing does not have these features, but similar features
+are planned for mergerfs v3. DrivePool has builtin file duplication
+which mergerfs does not natively support (but can be done via an
+external script.)
+
+There are a lot of misc differences between the two projects but most
+features in DrivePool can be replicated with external tools in
+combination with mergerfs.
+
+Additionally DrivePool is a closed source commercial product vs
+mergerfs a ISC licensed OSS project.
+
 
 # SUPPORT
 

libfuse/Makefile

@@ -15,6 +15,12 @@ else
 OPT_FLAGS := -O2
 endif
 
+ifeq ($(LTO),1)
+LTO_FLAGS := -flto
+else
+LTO_FLAGS :=
+endif
+
 DESTDIR       =
 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
@@ -38,7 +44,7 @@ SRC_C = \
 	lib/fuse.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 \
@@ -49,7 +55,8 @@ SRC_CPP = \
 	lib/format.cpp \
 	lib/os.cpp \
 	lib/cpu.cpp \
-	lib/fuse_loop_mt.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)
@@ -59,12 +66,14 @@ CFLAGS ?= \
 	$(OPT_FLAGS)
 CFLAGS := \
 	${CFLAGS} \
+	$(LTO_FLAGS) \
 	-std=gnu99 \
 	-Wall \
 	-pipe \
 	-MMD
 CXXFLAGS := \
 	${CXXFLAGS} \
+	$(LTO_FLAGS) \
 	-std=c++11 \
 	-Wall \
 	-pipe \

libfuse/include/fuse.h

@@ -539,6 +539,16 @@ struct fuse_operations
                              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
@@ -629,6 +639,7 @@ void fuse_exit(struct fuse *f);
 
 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);
 
 /**
@@ -764,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_ */

libfuse/include/fuse_common.h

@@ -84,6 +84,10 @@ struct fuse_file_info_t
 
   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;
@@ -104,23 +108,26 @@ struct fuse_file_info_t
  * 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_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_SETXATTR_EXT      (1 << 22)
+#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
@@ -146,56 +153,17 @@ struct fuse_file_info_t
  * 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;

libfuse/include/fuse_config.hpp

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

libfuse/include/fuse_dirents.h

@@ -63,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);

libfuse/include/fuse_kernel.h

@@ -197,6 +197,20 @@
  *
  *  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
@@ -232,7 +246,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 37
+#define FUSE_KERNEL_MINOR_VERSION 39
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -259,6 +273,40 @@ struct fuse_attr {
 	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 {
 	uint64_t	blocks;
 	uint64_t	bfree;
@@ -282,18 +330,18 @@ struct fuse_file_lock {
 /**
  * Bitmasks for fuse_setattr_in.valid
  */
-#define FATTR_MODE         (1 << 0)
-#define FATTR_UID          (1 << 1)
-#define FATTR_GID          (1 << 2)
-#define FATTR_SIZE         (1 << 3)
-#define FATTR_ATIME        (1 << 4)
-#define FATTR_MTIME        (1 << 5)
-#define FATTR_FH           (1 << 6)
-#define FATTR_ATIME_NOW    (1 << 7)
-#define FATTR_MTIME_NOW    (1 << 8)
-#define FATTR_LOCKOWNER    (1 << 9)
-#define FATTR_CTIME        (1 << 10)
-#define FATTR_KILL_SUIDGID (1 << 11)
+#define FATTR_MODE	(1 << 0)
+#define FATTR_UID	(1 << 1)
+#define FATTR_GID	(1 << 2)
+#define FATTR_SIZE	(1 << 3)
+#define FATTR_ATIME	(1 << 4)
+#define FATTR_MTIME	(1 << 5)
+#define FATTR_FH	(1 << 6)
+#define FATTR_ATIME_NOW	(1 << 7)
+#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
@@ -304,6 +352,7 @@ struct fuse_file_lock {
  * 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)
@@ -311,6 +360,7 @@ struct fuse_file_lock {
 #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
@@ -356,6 +406,10 @@ struct fuse_file_lock {
  * 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)
@@ -392,6 +446,12 @@ struct fuse_file_lock {
 /* 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
@@ -491,6 +551,23 @@ struct fuse_file_lock {
  */
 #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 */
@@ -541,6 +618,7 @@ enum fuse_opcode {
 	FUSE_REMOVEMAPPING	= 49,
 	FUSE_SYNCFS		= 50,
 	FUSE_TMPFILE		= 51,
+	FUSE_STATX		= 52,
 
 	/* CUSE specific operations */
 	CUSE_INIT		= 4096,
@@ -605,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 {
@@ -874,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 {
@@ -919,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 {
@@ -1035,4 +1130,27 @@ struct fuse_secctx_header {
 	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 */

libfuse/include/fuse_lowlevel.h

@@ -1007,6 +1007,15 @@ struct fuse_lowlevel_ops
    */
   void (*copy_file_range)(fuse_req_t                   req,
                           const struct fuse_in_header *hdr);
+
+  void (*setupmapping)(fuse_req_t                   req,
+                       const struct fuse_in_header *hdr);
+  void (*removemapping)(fuse_req_t                   req,
+                        const struct fuse_in_header *hdr);
+  void (*syncfs)(fuse_req_t                   req,
+                 const struct fuse_in_header *hdr);
+  void (*tmpfile)(fuse_req_t                   req,
+                  const struct fuse_in_header *hdr);
 };
 
 /**
@@ -1460,6 +1469,7 @@ void fuse_session_process(struct fuse_session *se,
 int fuse_session_loop_mt(struct fuse_session *se,
                          const int            read_thread_count,
                          const int            process_thread_count,
+                         const int            process_thread_queue_depth,
                          const char          *pin_threads_type);
 
 /* ----------------------------------------------------------- *

libfuse/include/fuse_msgbuf.h

@@ -5,7 +5,6 @@
 typedef struct fuse_msgbuf_t fuse_msgbuf_t;
 struct fuse_msgbuf_t
 {
-  char     *mem;
   uint32_t  size;
-  uint32_t  used;
+  char     *mem;
 };

libfuse/include/linux_dirent64.h

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

libfuse/include/moodycamel/blockingconcurrentqueue.h

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

libfuse/include/moodycamel/lightweightsemaphore.h

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

libfuse/include/thread_pool.hpp

@@ -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;
+};

libfuse/lib/bounded_queue.hpp

@@ -1,165 +0,0 @@
-#pragma once
-
-#include <condition_variable>
-#include <mutex>
-#include <queue>
-#include <utility>
-
-
-template<typename T>
-class BoundedQueue
-{
-public:
-  explicit
-  BoundedQueue(std::size_t max_size_,
-               bool        block_ = true)
-    : _block(block),
-      _max_size(max_size_)
-  {
-    if(_max_size == 0)
-      _max_size = 1;
-  }
-
-  bool
-  push(const T& item_)
-  {
-    {
-      std::unique_lock guard(_queue_lock);
-
-      _condition_push.wait(guard, [&]() { return _queue.size() < _max_size || !_block; });
-
-      if(_queue.size() == _max_size)
-        return false;
-
-      _queue.push(item);
-    }
-
-    _condition_pop.notify_one();
-
-    return true;
-  }
-
-  bool
-  push(T&& item_)
-  {
-    {
-      std::unique_lock guard(_queue_lock);
-
-      _condition_push.wait(guard, [&]() { return _queue.size() < _max_size || !_block; });
-
-      if(_queue.size() == _max_size)
-        return false;
-
-      _queue.push(std::move(item_));
-    }
-    _condition_pop.notify_one();
-    return true;
-  }
-
-  template<typename... Args>
-  bool
-  emplace(Args&&... args_)
-  {
-    {
-      std::unique_lock guard(_queue_lock);
-
-      _condition_push.wait(guard, [&]() { return _queue.size() < _max_size || !_block; });
-
-      if(_queue.size() == _max_size)
-        return false;
-
-      _queue.emplace(std::forward<Args>(args_)...);
-    }
-
-    _condition_pop.notify_one();
-
-    return true;
-  }
-
-  bool
-  pop(T& item_)
-  {
-    {
-      std::unique_lock guard(_queue_lock);
-
-      _condition_pop.wait(guard, [&]() { return !_queue.empty() || !_block; });
-      if(_queue.empty())
-        return false;
-
-      item_ = std::move(_queue.front());
-
-      _queue.pop();
-    }
-
-    _condition_push.notify_one();
-
-    return true;
-  }
-
-  std::size_t
-  size() const
-  {
-    std::lock_guard guard(_queue_lock);
-
-    return _queue.size();
-  }
-
-  std::size_t
-  capacity() const
-  {
-    return _max_size;
-  }
-
-  bool
-  empty() const
-  {
-    std::lock_guard guard(_queue_lock);
-
-    return _queue.empty();
-  }
-
-  bool
-  full() const
-  {
-    std::lock_guard lock(_queue_lock);
-
-    return (_queue.size() == capacity());
-  }
-
-  void
-  block()
-  {
-    std::lock_guard guard(_queue_lock);
-    _block = true;
-  }
-
-  void
-  unblock()
-  {
-    {
-      std::lock_guard guard(_queue_lock);
-      _block = false;
-    }
-
-    _condition_push.notify_all();
-    _condition_pop.notify_all();
-  }
-
-  bool
-  blocking() const
-  {
-    std::lock_guard guard(_queue_lock);
-
-    return _block;
-  }
-
-private:
-  mutable std::mutex _queue_lock;
-
-private:
-  bool _block;
-  std::queue<T> _queue;
-  const std::size_t _max_size;
-  std::condition_variable _condition_push;
-  std::condition_variable _condition_pop;
-};

libfuse/lib/debug.c

@@ -158,9 +158,9 @@ open_flag_to_str(const uint64_t offset_)
 static
 const
 char*
-fuse_flag_to_str(const uint32_t offset_)
+fuse_flag_to_str(const uint64_t offset_)
 {
-  switch(1 << offset_)
+  switch(1ULL << offset_)
     {
       FUSE_INIT_FLAG_CASE(ASYNC_READ);
       FUSE_INIT_FLAG_CASE(POSIX_LOCKS);
@@ -189,6 +189,16 @@ fuse_flag_to_str(const uint32_t offset_)
       FUSE_INIT_FLAG_CASE(NO_OPENDIR_SUPPORT);
       FUSE_INIT_FLAG_CASE(EXPLICIT_INVAL_DATA);
       FUSE_INIT_FLAG_CASE(MAP_ALIGNMENT);
+      FUSE_INIT_FLAG_CASE(SUBMOUNTS);
+      FUSE_INIT_FLAG_CASE(HANDLE_KILLPRIV_V2);
+      FUSE_INIT_FLAG_CASE(SETXATTR_EXT);
+      FUSE_INIT_FLAG_CASE(INIT_EXT);
+      FUSE_INIT_FLAG_CASE(INIT_RESERVED);
+      FUSE_INIT_FLAG_CASE(SECURITY_CTX);
+      FUSE_INIT_FLAG_CASE(HAS_INODE_DAX);
+      FUSE_INIT_FLAG_CASE(CREATE_SUPP_GROUP);
+      FUSE_INIT_FLAG_CASE(HAS_EXPIRE_ONLY);
+      FUSE_INIT_FLAG_CASE(DIRECT_IO_ALLOW_MMAP);
     }
 
   return NULL;
@@ -200,7 +210,7 @@ static
 void
 debug_open_flags(const uint32_t flags_)
 {
-  fprintf(stderr,"%s,",open_accmode_to_str(flags_));
+  fprintf(stderr,"%s, ",open_accmode_to_str(flags_));
   for(int i = 0; i < (sizeof(flags_) * 8); i++)
     {
       const char *str;
@@ -212,7 +222,7 @@ debug_open_flags(const uint32_t flags_)
       if(str == NULL)
         continue;
 
-      fprintf(stderr,"%s,",str);
+      fprintf(stderr,"%s, ",str);
     }
 }
 
@@ -717,28 +727,31 @@ debug_fuse_fallocate_in(const void *arg_)
 void
 debug_fuse_init_in(const struct fuse_init_in *arg_)
 {
+  uint64_t flags;
+
+  flags = (((uint64_t)arg_->flags) | ((uint64_t)arg_->flags2) << 32);
   fprintf(g_OUTPUT,
           "FUSE_INIT_IN: "
           " major=%u;"
           " minor=%u;"
           " max_readahead=%u;"
-          " flags=0x%08X (",
+          " flags=0x%016lx (",
           arg_->major,
           arg_->minor,
           arg_->max_readahead,
-          arg_->flags);
-  for(uint64_t i = 0; i < (sizeof(arg_->flags)*8); i++)
+          flags);
+  for(uint64_t i = 0; i < (sizeof(flags)*8); i++)
     {
       const char *str;
 
-      if(!(arg_->flags & (1ULL << i)))
+      if(!(flags & (1ULL << i)))
         continue;
 
       str = fuse_flag_to_str(i);
       if(str == NULL)
         continue;
 
-      fprintf(g_OUTPUT,"%s,",str);
+      fprintf(g_OUTPUT,"%s, ",str);
     }
   fprintf(g_OUTPUT,")\n");
 }
@@ -748,7 +761,10 @@ debug_fuse_init_out(const uint64_t              unique_,
                     const struct fuse_init_out *arg_,
                     const uint64_t              argsize_)
 {
+  uint64_t flags;
   const struct fuse_init_out *arg = arg_;
+
+  flags = (((uint64_t)arg->flags) | ((uint64_t)arg->flags2) << 32);
   fprintf(g_OUTPUT,
           /* "unique=0x%016"PRIx64";" */
           /* " opcode=RESPONSE;" */
@@ -758,27 +774,27 @@ debug_fuse_init_out(const uint64_t              unique_,
           " major=%u;"
           " minor=%u;"
           " max_readahead=%u;"
-          " flags=0x%08X ("
+          " flags=0x%016lx ("
           ,
           /* unique_, */
           /* sizeof(struct fuse_out_header) + argsize_, */
           arg->major,
           arg->minor,
           arg->max_readahead,
-          arg->flags);
+          flags);
 
-  for(uint64_t i = 0; i < (sizeof(arg->flags)*8); i++)
+  for(uint64_t i = 0; i < (sizeof(flags)*8); i++)
     {
       const char *str;
 
-      if(!(arg->flags & (1ULL << i)))
+      if(!(flags & (1ULL << i)))
         continue;
 
       str = fuse_flag_to_str(i);
       if(str == NULL)
         continue;
 
-      fprintf(g_OUTPUT,"%s,",str);
+      fprintf(g_OUTPUT,"%s, ",str);
     }
 
   fprintf(g_OUTPUT,

libfuse/lib/fuse_config.cpp

@@ -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_;
+}

libfuse/lib/fuse_dirents.c

@@ -304,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;
 
@@ -336,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;
 

libfuse/lib/fuse_loop.cpp

@@ -2,15 +2,18 @@
 #define _GNU_SOURCE
 #endif
 
-#include "thread_pool.hpp"
 #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"
 
@@ -22,38 +25,12 @@
 #include <stdlib.h>
 #include <string.h>
 #include <sys/time.h>
+#include <syslog.h>
 #include <unistd.h>
 
 #include <cassert>
 #include <vector>
 
-
-struct fuse_worker_data_t
-{
-  struct fuse_session *se;
-  sem_t finished;
-  std::function<void(fuse_worker_data_t*,fuse_msgbuf_t*)> msgbuf_processor;
-  std::shared_ptr<ThreadPool> tp;
-};
-
-class WorkerCleanup
-{
-public:
-  WorkerCleanup(fuse_worker_data_t *wd_)
-    : _wd(wd_)
-  {
-  }
-
-  ~WorkerCleanup()
-  {
-    fuse_session_exit(_wd->se);
-    sem_post(&_wd->finished);
-  }
-
-private:
-  fuse_worker_data_t *_wd;
-};
-
 static
 bool
 retriable_receive_error(const int err_)
@@ -77,54 +54,117 @@ fatal_receive_error(const int err_)
 }
 
 static
-void*
+void
 handle_receive_error(const int      rv_,
                      fuse_msgbuf_t *msgbuf_)
 {
   msgbuf_free(msgbuf_);
 
-  fprintf(stderr,
-          "mergerfs: error reading from /dev/fuse - %s (%d)\n",
-          strerror(-rv_),
-          -rv_);
-
-  return NULL;
+  fmt::print(stderr,
+             "mergerfs: error reading from /dev/fuse - {} ({})\n",
+             strerror(-rv_),
+             -rv_);
 }
 
-static
-void*
-fuse_do_work(void *data)
+struct AsyncWorker
 {
-  fuse_worker_data_t *wd = (fuse_worker_data_t*)data;
-  fuse_session       *se = wd->se;
-  auto               &process_msgbuf = wd->msgbuf_processor;
-  WorkerCleanup       workercleanup(wd);
+  fuse_session *_se;
+  sem_t *_finished;
+  std::shared_ptr<ThreadPool> _process_tp;
 
-  while(!fuse_session_exited(se))
-    {
-      int rv;
-      fuse_msgbuf_t *msgbuf;
+  AsyncWorker(fuse_session                       *se_,
+              sem_t                              *finished_,
+              std::shared_ptr<ThreadPool>  process_tp_)
+    : _se(se_),
+      _finished(finished_),
+      _process_tp(process_tp_)
+  {
+  }
 
-      msgbuf = msgbuf_alloc();
+  inline
+  void
+  operator()() const
+  {
+    DEFER{ fuse_session_exit(_se); };
+    DEFER{ sem_post(_finished); };
 
-      do
+    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 = [=]
         {
-          pthread_setcancelstate(PTHREAD_CANCEL_ENABLE,NULL);
-          rv = se->receive_buf(se,msgbuf);
-          pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,NULL);
-          if(rv == 0)
-            return NULL;
-          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);
+        };
 
-      process_msgbuf(wd,msgbuf);
-    }
+        _process_tp->enqueue_work(ptok,func);
+      }
+  }
+};
 
-  return NULL;
-}
+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,
@@ -174,7 +214,8 @@ calculate_thread_count(const int raw_thread_count_)
 static
 void
 calculate_thread_counts(int *read_thread_count_,
-                        int *process_thread_count_)
+                        int *process_thread_count_,
+                        int *process_thread_queue_depth_)
 {
   if((*read_thread_count_ == -1) && (*process_thread_count_ == -1))
     {
@@ -190,27 +231,9 @@ calculate_thread_counts(int *read_thread_count_,
       if(*process_thread_count_ != -1)
         *process_thread_count_ = ::calculate_thread_count(*process_thread_count_);
     }
-}
 
-static
-void
-process_msgbuf_sync(fuse_worker_data_t *wd_,
-                    fuse_msgbuf_t      *msgbuf_)
-{
-  wd_->se->process_buf(wd_->se,msgbuf_);
-  msgbuf_free(msgbuf_);
-}
-
-static
-void
-process_msgbuf_async(fuse_worker_data_t *wd_,
-                     fuse_msgbuf_t      *msgbuf_)
-{
-  const auto func = [=] {
-    process_msgbuf_sync(wd_,msgbuf_);
-  };
-
-  wd_->tp->enqueue_work(func);
+  if(*process_thread_queue_depth_ <= 0)
+    *process_thread_queue_depth_ = *process_thread_count_;
 }
 
 static
@@ -401,10 +424,12 @@ pin_threads_R1PPSP(const std::vector<pthread_t> read_threads_,
 
 static
 void
-pin_threads(const std::vector<pthread_t>  read_threads_,
-            const std::vector<pthread_t>  process_threads_,
-            const std::string             type_)
+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")
@@ -423,65 +448,108 @@ pin_threads(const std::vector<pthread_t>  read_threads_,
     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 char          *pin_threads_type_)
+                     const int            raw_process_thread_queue_depth_,
+                     const std::string    pin_threads_type_)
 {
-  int err;
+  sem_t finished;
   int read_thread_count;
   int process_thread_count;
-  fuse_worker_data_t wd = {0};
+  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;
 
-  read_thread_count    = raw_read_thread_count_;
-  process_thread_count = raw_process_thread_count_;
-  ::calculate_thread_counts(&read_thread_count,&process_thread_count);
+  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)
     {
-      wd.tp = std::make_shared<ThreadPool>(process_thread_count);
-      wd.msgbuf_processor = process_msgbuf_async;
-      process_threads = wd.tp->threads();
+      for(auto i = 0; i < read_thread_count; i++)
+        read_tp->enqueue_work(AsyncWorker(se_,&finished,process_tp));
     }
   else
     {
-      wd.msgbuf_processor = process_msgbuf_sync;
+      for(auto i = 0; i < read_thread_count; i++)
+        read_tp->enqueue_work(SyncWorker(se_,&finished));
     }
 
-  wd.se = se_;
-  sem_init(&wd.finished,0,0);
+  if(read_tp)
+    read_threads = read_tp->threads();
+  if(process_tp)
+    process_threads = process_tp->threads();
 
-  err = 0;
-  for(int i = 0; i < read_thread_count; i++)
-    {
-      pthread_t thread_id;
-      err = fuse_start_thread(&thread_id,fuse_do_work,&wd);
-      assert(err == 0);
-      read_threads.push_back(thread_id);
-    }
+  ::pin_threads(read_threads,process_threads,pin_threads_type_);
 
-  if(pin_threads_type_ != NULL)
-    ::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());
 
-  if(!err)
-    {
-      /* sem_wait() is interruptible */
-      while(!fuse_session_exited(se_))
-        sem_wait(&wd.finished);
+  ::wait(se_,&finished);
 
-      for(const auto &thread_id : read_threads)
-        pthread_cancel(thread_id);
+  sem_destroy(&finished);
 
-      for(const auto &thread_id : read_threads)
-        pthread_join(thread_id,NULL);
-    }
+  return 0;
+}
 
-  sem_destroy(&wd.finished);
+int
+fuse_loop_mt(struct fuse *f)
+{
+  if(f == NULL)
+    return -1;
 
-  return err;
+  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;
 }

libfuse/lib/fuse_lowlevel.c

@@ -261,18 +261,22 @@ fill_entry(struct fuse_entry_out         *arg,
 
 static
 void
-fill_open(struct fuse_open_out   *arg,
-          const fuse_file_info_t *f)
+fill_open(struct fuse_open_out   *arg_,
+          const fuse_file_info_t *ffi_)
 {
-  arg->fh = f->fh;
-  if(f->direct_io)
-    arg->open_flags |= FOPEN_DIRECT_IO;
-  if(f->keep_cache)
-    arg->open_flags |= FOPEN_KEEP_CACHE;
-  if(f->nonseekable)
-    arg->open_flags |= FOPEN_NONSEEKABLE;
-  if(f->cache_readdir)
-    arg->open_flags |= FOPEN_CACHE_DIR;
+  arg_->fh = ffi_->fh;
+  if(ffi_->direct_io)
+    arg_->open_flags |= FOPEN_DIRECT_IO;
+  if(ffi_->keep_cache)
+    arg_->open_flags |= FOPEN_KEEP_CACHE;
+  if(ffi_->nonseekable)
+    arg_->open_flags |= FOPEN_NONSEEKABLE;
+  if(ffi_->cache_readdir)
+    arg_->open_flags |= FOPEN_CACHE_DIR;
+  if(ffi_->parallel_direct_writes)
+    arg_->open_flags |= FOPEN_PARALLEL_DIRECT_WRITES;
+  if(ffi_->noflush)
+    arg_->open_flags |= FOPEN_NOFLUSH;
 }
 
 int
@@ -290,6 +294,11 @@ fuse_reply_entry(fuse_req_t                     req,
 
   fill_entry(&arg, e);
 
+#ifdef NDEBUG
+  // TODO: Add checks for cases where a node could be marked bad by
+  // the kernel.
+#endif
+
   return send_reply_ok(req, &arg, size);
 }
 
@@ -1088,6 +1097,11 @@ do_init(fuse_req_t             req,
   struct fuse_init_in *arg = (struct fuse_init_in *) &hdr_[1];
   struct fuse_ll *f = req->f;
   size_t bufsize = fuse_chan_bufsize(req->ch);
+  uint64_t inargflags;
+  uint64_t outargflags;
+
+  inargflags = 0;
+  outargflags = 0;
 
   if(f->debug)
     debug_fuse_init_in(arg);
@@ -1118,40 +1132,49 @@ do_init(fuse_req_t             req,
 
   if(arg->minor >= 6)
     {
+      inargflags = arg->flags;
+      if(inargflags & FUSE_INIT_EXT)
+        inargflags |= (((uint64_t)arg->flags2) << 32);
+
       if(arg->max_readahead < f->conn.max_readahead)
         f->conn.max_readahead = arg->max_readahead;
-      if(arg->flags & FUSE_ASYNC_READ)
+
+      if(inargflags & FUSE_ASYNC_READ)
         f->conn.capable |= FUSE_CAP_ASYNC_READ;
-      if(arg->flags & FUSE_POSIX_LOCKS)
+      if(inargflags & FUSE_POSIX_LOCKS)
         f->conn.capable |= FUSE_CAP_POSIX_LOCKS;
-      if(arg->flags & FUSE_ATOMIC_O_TRUNC)
+      if(inargflags & FUSE_ATOMIC_O_TRUNC)
         f->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
-      if(arg->flags & FUSE_EXPORT_SUPPORT)
+      if(inargflags & FUSE_EXPORT_SUPPORT)
         f->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
-      if(arg->flags & FUSE_BIG_WRITES)
+      if(inargflags & FUSE_BIG_WRITES)
         f->conn.capable |= FUSE_CAP_BIG_WRITES;
-      if(arg->flags & FUSE_DONT_MASK)
+      if(inargflags & FUSE_DONT_MASK)
         f->conn.capable |= FUSE_CAP_DONT_MASK;
-      if(arg->flags & FUSE_FLOCK_LOCKS)
+      if(inargflags & FUSE_FLOCK_LOCKS)
         f->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
-      if(arg->flags & FUSE_POSIX_ACL)
+      if(inargflags & FUSE_POSIX_ACL)
         f->conn.capable |= FUSE_CAP_POSIX_ACL;
-      if(arg->flags & FUSE_CACHE_SYMLINKS)
+      if(inargflags & FUSE_CACHE_SYMLINKS)
         f->conn.capable |= FUSE_CAP_CACHE_SYMLINKS;
-      if(arg->flags & FUSE_ASYNC_DIO)
+      if(inargflags & FUSE_ASYNC_DIO)
         f->conn.capable |= FUSE_CAP_ASYNC_DIO;
-      if(arg->flags & FUSE_PARALLEL_DIROPS)
+      if(inargflags & FUSE_PARALLEL_DIROPS)
         f->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
-      if(arg->flags & FUSE_MAX_PAGES)
+      if(inargflags & FUSE_MAX_PAGES)
         f->conn.capable |= FUSE_CAP_MAX_PAGES;
-      if(arg->flags & FUSE_WRITEBACK_CACHE)
+      if(inargflags & FUSE_WRITEBACK_CACHE)
         f->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
-      if(arg->flags & FUSE_DO_READDIRPLUS)
+      if(inargflags & FUSE_DO_READDIRPLUS)
         f->conn.capable |= FUSE_CAP_READDIR_PLUS;
-      if(arg->flags & FUSE_READDIRPLUS_AUTO)
+      if(inargflags & FUSE_READDIRPLUS_AUTO)
         f->conn.capable |= FUSE_CAP_READDIR_PLUS_AUTO;
-      if(arg->flags & FUSE_SETXATTR_EXT)
+      if(inargflags & FUSE_SETXATTR_EXT)
         f->conn.capable |= FUSE_CAP_SETXATTR_EXT;
+      if(inargflags & FUSE_DIRECT_IO_ALLOW_MMAP)
+        f->conn.capable |= FUSE_CAP_DIRECT_IO_ALLOW_MMAP;
+      if(inargflags & FUSE_CREATE_SUPP_GROUP)
+        f->conn.capable |= FUSE_CAP_CREATE_SUPP_GROUP;
     }
   else
     {
@@ -1182,44 +1205,57 @@ do_init(fuse_req_t             req,
   if(f->op.init)
     f->op.init(f->userdata, &f->conn);
 
-  if((arg->flags & FUSE_MAX_PAGES) && (f->conn.want & FUSE_CAP_MAX_PAGES))
+  outargflags = outarg.flags;
+  if((inargflags & FUSE_MAX_PAGES) && (f->conn.want & FUSE_CAP_MAX_PAGES))
     {
-      outarg.flags     |= FUSE_MAX_PAGES;
+      outargflags     |= FUSE_MAX_PAGES;
       outarg.max_pages  = f->conn.max_pages;
 
       msgbuf_set_bufsize(outarg.max_pages + 1);
     }
 
   if(f->conn.want & FUSE_CAP_ASYNC_READ)
-    outarg.flags |= FUSE_ASYNC_READ;
+    outargflags |= FUSE_ASYNC_READ;
   if(f->conn.want & FUSE_CAP_POSIX_LOCKS)
-    outarg.flags |= FUSE_POSIX_LOCKS;
+    outargflags |= FUSE_POSIX_LOCKS;
   if(f->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
-    outarg.flags |= FUSE_ATOMIC_O_TRUNC;
+    outargflags |= FUSE_ATOMIC_O_TRUNC;
   if(f->conn.want & FUSE_CAP_EXPORT_SUPPORT)
-    outarg.flags |= FUSE_EXPORT_SUPPORT;
+    outargflags |= FUSE_EXPORT_SUPPORT;
   if(f->conn.want & FUSE_CAP_BIG_WRITES)
-    outarg.flags |= FUSE_BIG_WRITES;
+    outargflags |= FUSE_BIG_WRITES;
   if(f->conn.want & FUSE_CAP_DONT_MASK)
-    outarg.flags |= FUSE_DONT_MASK;
+    outargflags |= FUSE_DONT_MASK;
   if(f->conn.want & FUSE_CAP_FLOCK_LOCKS)
-    outarg.flags |= FUSE_FLOCK_LOCKS;
+    outargflags |= FUSE_FLOCK_LOCKS;
   if(f->conn.want & FUSE_CAP_POSIX_ACL)
-    outarg.flags |= FUSE_POSIX_ACL;
+    outargflags |= FUSE_POSIX_ACL;
   if(f->conn.want & FUSE_CAP_CACHE_SYMLINKS)
-    outarg.flags |= FUSE_CACHE_SYMLINKS;
+    outargflags |= FUSE_CACHE_SYMLINKS;
   if(f->conn.want & FUSE_CAP_ASYNC_DIO)
-    outarg.flags |= FUSE_ASYNC_DIO;
+    outargflags |= FUSE_ASYNC_DIO;
   if(f->conn.want & FUSE_CAP_PARALLEL_DIROPS)
-    outarg.flags |= FUSE_PARALLEL_DIROPS;
+    outargflags |= FUSE_PARALLEL_DIROPS;
   if(f->conn.want & FUSE_CAP_WRITEBACK_CACHE)
-    outarg.flags |= FUSE_WRITEBACK_CACHE;
+    outargflags |= FUSE_WRITEBACK_CACHE;
   if(f->conn.want & FUSE_CAP_READDIR_PLUS)
-    outarg.flags |= FUSE_DO_READDIRPLUS;
+    outargflags |= FUSE_DO_READDIRPLUS;
   if(f->conn.want & FUSE_CAP_READDIR_PLUS_AUTO)
-    outarg.flags |= FUSE_READDIRPLUS_AUTO;
+    outargflags |= FUSE_READDIRPLUS_AUTO;
   if(f->conn.want & FUSE_CAP_SETXATTR_EXT)
-    outarg.flags |= FUSE_SETXATTR_EXT;
+    outargflags |= FUSE_SETXATTR_EXT;
+  if(f->conn.want & FUSE_CAP_CREATE_SUPP_GROUP)
+    outargflags |= FUSE_CREATE_SUPP_GROUP;
+  if(f->conn.want & FUSE_CAP_DIRECT_IO_ALLOW_MMAP)
+    outargflags |= FUSE_DIRECT_IO_ALLOW_MMAP;
+
+  if(inargflags & FUSE_INIT_EXT)
+    {
+      outargflags |= FUSE_INIT_EXT;
+      outarg.flags2 = (outargflags >> 32);
+    }
+
+  outarg.flags = outargflags;
 
   outarg.max_readahead = f->conn.max_readahead;
   outarg.max_write = f->conn.max_write;
@@ -1238,6 +1274,9 @@ do_init(fuse_req_t             req,
       outarg.congestion_threshold = f->conn.congestion_threshold;
     }
 
+  if(f->conn.proto_minor >= 23)
+    outarg.time_gran = 1;
+
   size_t outargsize;
   if(arg->minor < 5)
     outargsize = FUSE_COMPAT_INIT_OUT_SIZE;
@@ -1328,6 +1367,42 @@ do_copy_file_range(fuse_req_t             req_,
   req_->f->op.copy_file_range(req_,hdr_);
 }
 
+static
+void
+do_setupmapping(fuse_req_t                req_,
+                   struct fuse_in_header *hdr_)
+{
+  printf("setupmapping\n");
+  req_->f->op.setupmapping(req_,hdr_);
+}
+
+static
+void
+do_removemapping(fuse_req_t             req_,
+                 struct fuse_in_header *hdr_)
+{
+  printf("removemapping\n");
+  req_->f->op.removemapping(req_,hdr_);
+}
+
+static
+void
+do_syncfs(fuse_req_t             req_,
+          struct fuse_in_header *hdr_)
+{
+  printf("syncfs\n");
+  req_->f->op.syncfs(req_,hdr_);
+}
+
+static
+void
+do_tmpfile(fuse_req_t             req_,
+           struct fuse_in_header *hdr_)
+{
+  printf("tmpfile\n");
+  req_->f->op.tmpfile(req_,hdr_);
+}
+
 static
 int
 send_notify_iov(struct fuse_ll   *f,
@@ -1414,9 +1489,10 @@ fuse_lowlevel_notify_inval_entry(struct fuse_chan *ch,
   if(!f)
     return -ENODEV;
 
-  outarg.parent = parent;
+  outarg.parent  = parent;
   outarg.namelen = namelen;
-  outarg.padding = 0;
+  // TODO: Add ability to set `flags`
+  outarg.flags   = 0;
 
   iov[1].iov_base = &outarg;
   iov[1].iov_len = sizeof(outarg);
@@ -1640,6 +1716,10 @@ static struct {
     [FUSE_NOTIFY_REPLY]    = { do_notify_reply,    "NOTIFY_REPLY"    },
     [FUSE_BATCH_FORGET]    = { do_batch_forget,    "BATCH_FORGET"    },
     [FUSE_COPY_FILE_RANGE] = { do_copy_file_range, "COPY_FILE_RANGE" },
+    [FUSE_SETUPMAPPING]    = { do_setupmapping,    "SETUPMAPPING"    },
+    [FUSE_REMOVEMAPPING]   = { do_removemapping,   "REMOVEMAPPING"   },
+    [FUSE_SYNCFS]          = { do_syncfs,          "SYNCFS"          },
+    [FUSE_TMPFILE]         = { do_tmpfile,         "TMPFILE"         }
   };
 
 #define FUSE_MAXOP (sizeof(fuse_ll_ops) / sizeof(fuse_ll_ops[0]))
@@ -1812,6 +1892,8 @@ fuse_ll_buf_process_read(struct fuse_session *se_,
 
   in = (struct fuse_in_header*)msgbuf_->mem;
 
+  //  printf("%d\n",in->opcode);
+
   req = fuse_ll_alloc_req(se_->f);
   if(req == NULL)
     return fuse_send_enomem(se_->f,se_->ch,in->unique);

libfuse/lib/fuse_msgbuf.cpp

@@ -17,39 +17,26 @@
 
 #include "fuse_msgbuf.hpp"
 #include "fuse.h"
+#include "fuse_kernel.h"
 
 #include <unistd.h>
 
+#include <atomic>
 #include <cstdint>
 #include <cstdlib>
 #include <mutex>
-#include <stack>
+#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::stack<fuse_msgbuf_t*> g_MSGBUF_STACK;
+static std::vector<fuse_msgbuf_t*> g_MSGBUF_STACK;
 
-static
-__attribute__((constructor))
-void
-msgbuf_constructor()
-{
-  g_PAGESIZE = sysconf(_SC_PAGESIZE);
-  g_BUFSIZE  = (g_PAGESIZE * (FUSE_MAX_MAX_PAGES + 2));
-}
-
-static
-__attribute__((destructor))
-void
-msgbuf_destroy()
-{
-  // TODO: cleanup?
-}
-
-uint32_t
+uint64_t
 msgbuf_get_bufsize()
 {
   return g_BUFSIZE;
@@ -58,7 +45,43 @@ msgbuf_get_bufsize()
 void
 msgbuf_set_bufsize(const uint32_t size_in_pages_)
 {
-  g_BUFSIZE = (size_in_pages_ * g_PAGESIZE);
+  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
@@ -75,8 +98,11 @@ page_aligned_malloc(const uint64_t size_)
   return buf;
 }
 
+typedef void (*msgbuf_setup_func_t)(fuse_msgbuf_t*);
+
+static
 fuse_msgbuf_t*
-msgbuf_alloc()
+_msgbuf_alloc(msgbuf_setup_func_t setup_func_)
 {
   fuse_msgbuf_t *msgbuf;
 
@@ -85,40 +111,118 @@ msgbuf_alloc()
     {
       g_MUTEX.unlock();
 
-      msgbuf = (fuse_msgbuf_t*)malloc(sizeof(fuse_msgbuf_t));
+      msgbuf = (fuse_msgbuf_t*)page_aligned_malloc(g_BUFSIZE);
       if(msgbuf == NULL)
         return NULL;
 
-      msgbuf->mem = (char*)page_aligned_malloc(g_BUFSIZE);
-      if(msgbuf->mem == NULL)
-        {
-          free(msgbuf);
-          return NULL;
-        }
-
-      msgbuf->size = g_BUFSIZE;
+      g_MSGBUF_ALLOC_COUNT.fetch_add(1,std::memory_order_relaxed);
     }
   else
     {
-      msgbuf = g_MSGBUF_STACK.top();
-      g_MSGBUF_STACK.pop();
+      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)
+  if(msgbuf_->size != (g_BUFSIZE - g_PAGESIZE))
     {
-      free(msgbuf_->mem);
-      free(msgbuf_);
+      msgbuf_destroy(msgbuf_);
+      g_MSGBUF_ALLOC_COUNT.fetch_sub(1,std::memory_order_relaxed);
       return;
     }
 
-  g_MSGBUF_STACK.push(msgbuf_);
+  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);
+    }
 }

libfuse/lib/fuse_msgbuf.hpp

@@ -24,10 +24,19 @@
 EXTERN_C_BEGIN
 
 void     msgbuf_set_bufsize(const uint32_t size);
-uint32_t msgbuf_get_bufsize();
+uint64_t msgbuf_get_bufsize();
 
-fuse_msgbuf_t* msgbuf_alloc();
-fuse_msgbuf_t* msgbuf_alloc_memonly();
+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

libfuse/lib/fuse_mt.c

@@ -1,37 +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>
-
-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_read_thread_count(f),
-                             fuse_config_process_thread_count(f),
-                             fuse_config_pin_threads(f));
-
-  fuse_stop_maintenance_thread(f);
-
-  return res;
-}

libfuse/lib/fuse_signals.c

@@ -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);
 }

libfuse/lib/lock.h

@@ -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;
+};

libfuse/lib/make_unique.hpp

@@ -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;
+}

libfuse/lib/mount_generic.c

@@ -61,6 +61,7 @@ enum {
 };
 
 struct mount_opts {
+  int allow_other;
   int ishelp;
   int flags;
   int auto_unmount;
@@ -76,13 +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("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("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),
@@ -98,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
@@ -549,8 +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;
 
-  fuse_opt_add_opt(&mo.kernel_opts,"allow_other");
-
   res = 0;
   if (mo.ishelp)
     goto out;

libfuse/lib/node.c

@@ -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;
+}

libfuse/lib/node.h

@@ -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();

libfuse/lib/scope_guard.hpp

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

libfuse/lib/thread_pool.hpp

@@ -1,124 +0,0 @@
-#pragma once
-
-#include "unbounded_queue.hpp"
-
-#include <tuple>
-#include <atomic>
-#include <vector>
-#include <thread>
-#include <memory>
-#include <future>
-#include <utility>
-#include <functional>
-#include <type_traits>
-
-
-class ThreadPool
-{
-public:
-  explicit
-  ThreadPool(const std::size_t thread_count_ = std::thread::hardware_concurrency())
-    : _queues(thread_count_),
-      _count(thread_count_)
-  {
-    auto worker = [this](std::size_t i)
-    {
-      while(true)
-        {
-          Proc f;
-
-          for(std::size_t n = 0; n < (_count * K); ++n)
-            {
-              if(_queues[(i + n) % _count].try_pop(f))
-                break;
-            }
-
-          if(!f && !_queues[i].pop(f))
-            break;
-
-          f();
-        }
-    };
-
-    _threads.reserve(thread_count_);
-    for(std::size_t i = 0; i < thread_count_; ++i)
-      _threads.emplace_back(worker, i);
-  }
-
-  ~ThreadPool()
-  {
-    for(auto& queue : _queues)
-      queue.unblock();
-    for(auto& thread : _threads)
-      thread.join();
-  }
-
-  template<typename F>
-  void
-  enqueue_work(F&& f_)
-  {
-    auto i = _index++;
-
-    for(std::size_t n = 0; n < (_count * K); ++n)
-      {
-        if(_queues[(i + n) % _count].try_push(f_))
-          return;
-      }
-
-    _queues[i % _count].push(std::move(f_));
-  }
-
-  template<typename F>
-  [[nodiscard]]
-  std::future<typename std::result_of<F()>::type>
-  enqueue_task(F&& f_)
-  {
-    using TaskReturnType = typename std::result_of<F()>::type;
-    using Promise        = std::promise<TaskReturnType>;
-
-    auto i       = _index++;
-    auto promise = std::make_shared<Promise>();
-    auto future  = promise->get_future();
-    auto work    = [=]() {
-      auto rv = f_();
-      promise->set_value(rv);
-    };
-
-    for(std::size_t n = 0; n < (_count * K); ++n)
-      {
-        if(_queues[(i + n) % _count].try_push(work))
-          return future;
-      }
-
-    _queues[i % _count].push(std::move(work));
-
-    return future;
-  }
-
-public:
-  std::vector<pthread_t>
-  threads()
-  {
-    std::vector<pthread_t> rv;
-
-    for(auto &thread : _threads)
-      rv.push_back(thread.native_handle());
-
-    return rv;
-  }
-
-private:
-  using Proc   = std::function<void(void)>;
-  using Queue  = UnboundedQueue<Proc>;
-  using Queues = std::vector<Queue>;
-  Queues _queues;
-
-private:
-  std::vector<std::thread> _threads;
-
-private:
-  const std::size_t _count;
-  std::atomic_uint _index;
-
-  static const unsigned int K = 2;
-};

libfuse/lib/unbounded_queue.hpp

@@ -1,161 +0,0 @@
-#pragma once
-
-#include <condition_variable>
-#include <mutex>
-#include <queue>
-#include <utility>
-
-
-template<typename T>
-class UnboundedQueue
-{
-public:
-  explicit
-  UnboundedQueue(bool block_ = true)
-    : _block(block_)
-  {
-  }
-
-  void
-  push(const T& item_)
-  {
-    {
-      std::lock_guard<std::mutex> guard(_queue_lock);
-      _queue.push(item_);
-    }
-    _condition.notify_one();
-  }
-
-  void
-  push(T&& item_)
-  {
-    {
-      std::lock_guard<std::mutex> guard(_queue_lock);
-      _queue.push(std::move(item_));
-    }
-
-    _condition.notify_one();
-  }
-
-  template<typename... Args>
-  void
-  emplace(Args&&... args_)
-  {
-    {
-      std::lock_guard<std::mutex> guard(_queue_lock);
-      _queue.emplace(std::forward<Args>(args_)...);
-    }
-
-    _condition.notify_one();
-  }
-
-  bool
-  try_push(const T& item_)
-  {
-    {
-      std::unique_lock<std::mutex> lock(_queue_lock, std::try_to_lock);
-      if(!lock)
-        return false;
-      _queue.push(item_);
-    }
-
-    _condition.notify_one();
-
-    return true;
-  }
-
-  bool
-  try_push(T&& item_)
-  {
-    {
-      std::unique_lock<std::mutex> lock(_queue_lock, std::try_to_lock);
-      if(!lock)
-        return false;
-      _queue.push(std::move(item_));
-    }
-
-    _condition.notify_one();
-
-    return true;
-  }
-
-  //TODO: push multiple T at once
-
-  bool
-  pop(T& item_)
-  {
-    std::unique_lock<std::mutex> guard(_queue_lock);
-
-    _condition.wait(guard, [&]() { return !_queue.empty() || !_block; });
-    if(_queue.empty())
-      return false;
-
-    item_ = std::move(_queue.front());
-    _queue.pop();
-
-    return true;
-  }
-
-  bool
-  try_pop(T& item_)
-  {
-    std::unique_lock<std::mutex> lock(_queue_lock, std::try_to_lock);
-    if(!lock || _queue.empty())
-      return false;
-
-    item_ = std::move(_queue.front());
-    _queue.pop();
-
-    return true;
-  }
-
-  std::size_t
-  size() const
-  {
-    std::lock_guard<std::mutex> guard(_queue_lock);
-
-    return _queue.size();
-  }
-
-  bool
-  empty() const
-  {
-    std::lock_guard<std::mutex> guard(_queue_lock);
-
-    return _queue.empty();
-  }
-
-  void
-  block()
-  {
-    std::lock_guard<std::mutex> guard(_queue_lock);
-    _block = true;
-  }
-
-  void
-  unblock()
-  {
-    {
-      std::lock_guard<std::mutex> guard(_queue_lock);
-      _block = false;
-    }
-
-    _condition.notify_all();
-  }
-
-  bool
-  blocking() const
-  {
-    std::lock_guard<std::mutex> guard(_queue_lock);
-
-    return _block;
-  }
-
-private:
-  mutable std::mutex _queue_lock;
-
-private:
-  bool _block;
-  std::queue<T> _queue;
-  std::condition_variable _condition;
-};

man/mergerfs.1

@@ -106,16 +106,22 @@ If you don\[cq]t already know that you have a special use case then just
 start with one of the following option sets.
 .SS You need \f[C]mmap\f[R] (used by rtorrent and many sqlite3 base software)
 .PP
-\f[C]cache.files=partial,dropcacheonclose=true,category.create=mfs\f[R]
+\f[C]cache.files=auto-full,dropcacheonclose=true,category.create=mfs\f[R]
+.PP
+or if you are on a Linux kernel >= 6.6.x mergerfs will enable a mode
+that allows shared mmap when \f[C]cache.files=off\f[R].
+To be sure of the best performance between \f[C]cache.files=off\f[R] and
+\f[C]cache.files=auto-full\f[R] you\[cq]ll need to do your own
+benchmarking but often \f[C]off\f[R] is faster.
 .SS You don\[cq]t need \f[C]mmap\f[R]
 .PP
 \f[C]cache.files=off,dropcacheonclose=true,category.create=mfs\f[R]
 .SS Command Line
 .PP
-\f[C]mergerfs -o cache.files=partial,dropcacheonclose=true,category.create=mfs /mnt/hdd0:/mnt/hdd1 /media\f[R]
+\f[C]mergerfs -o cache.files=auto-full,dropcacheonclose=true,category.create=mfs /mnt/hdd0:/mnt/hdd1 /media\f[R]
 .SS /etc/fstab
 .PP
-\f[C]/mnt/hdd0:/mnt/hdd1 /media fuse.mergerfs cache.files=partial,dropcacheonclose=true,category.create=mfs 0 0\f[R]
+\f[C]/mnt/hdd0:/mnt/hdd1 /media mergerfs cache.files=auto-full,dropcacheonclose=true,category.create=mfs 0 0\f[R]
 .SS systemd mount
 .PP
 https://github.com/trapexit/mergerfs/wiki/systemd
@@ -130,7 +136,7 @@ Type=simple
 KillMode=none
 ExecStart=/usr/bin/mergerfs \[rs]
   -f \[rs]
-  -o cache.files=partial \[rs]
+  -o cache.files=auto-full \[rs]
   -o dropcacheonclose=true \[rs]
   -o category.create=mfs \[rs]
   /mnt/hdd0:/mnt/hdd1 \[rs]
@@ -185,6 +191,13 @@ Recommended when
 caching.
 (default: false)
 .IP \[bu] 2
+\f[B]direct-io-allow-mmap=BOOL\f[R]: On newer kernels (>= 6.6) it is
+possible to disable file page caching while still allowing for shared
+mmap support.
+mergerfs will enable this feature if available but an option is provided
+to turn it off for testing and debugging purposes.
+(default: true)
+.IP \[bu] 2
 \f[B]symlinkify=BOOL\f[R]: When enabled and a file is not writable and
 its mtime or ctime is older than \f[B]symlinkify_timeout\f[R] files will
 be reported as symlinks to the original files.
@@ -214,6 +227,10 @@ This means files, when renamed or linked, will stay on the same
 filesystem.
 (default: false)
 .IP \[bu] 2
+\f[B]export-support=BOOL\f[R]: Sets a low-level FUSE feature intended to
+indicate the filesystem can support being exported via NFS.
+(default: true)
+.IP \[bu] 2
 \f[B]security_capability=BOOL\f[R]: If false return ENOATTR when xattr
 security.capability is queried.
 (default: true)
@@ -311,9 +328,21 @@ reading FUSE messages which are dispatched to process threads.
 -1 means disabled otherwise acts like \f[C]read-thread-count\f[R].
 (default: -1)
 .IP \[bu] 2
+\f[B]process-thread-queue-depth=UINT\f[R]: Sets the number of requests
+any single process thread can have queued up at one time.
+Meaning the total memory usage of the queues is queue depth multiplied
+by the number of process threads plus read thread count.
+0 sets the depth to the same as the process thread count.
+(default: 0)
+.IP \[bu] 2
 \f[B]pin-threads=STR\f[R]: Selects a strategy to pin threads to CPUs
 (default: unset)
 .IP \[bu] 2
+\f[B]flush-on-close=never|always|opened-for-write\f[R]: Flush data cache
+on file close.
+Mostly for when writeback is enabled or merging network filesystems.
+(default: opened-for-write)
+.IP \[bu] 2
 \f[B]scheduling-priority=INT\f[R]: Set mergerfs\[cq] scheduling
 priority.
 Valid values range from -20 to 19.
@@ -330,6 +359,11 @@ policy.
 See below for the list of value types.
 Example: \f[B]func.getattr=newest\f[R]
 .IP \[bu] 2
+\f[B]func.readdir=seq|cosr|cor|cosr:INT|cor:INT\f[R]: Sets
+\f[C]readdir\f[R] policy.
+INT value sets the number of threads to use for concurrency.
+(default: seq)
+.IP \[bu] 2
 \f[B]category.action=POLICY\f[R]: Sets policy of all FUSE functions in
 the action category.
 (default: epall)
@@ -377,6 +411,12 @@ to enable page caching for when \f[C]cache.files=per-process\f[R].
 \f[B]cache.readdir=BOOL\f[R]: Cache readdir (if supported by kernel)
 (default: false)
 .IP \[bu] 2
+\f[B]parallel-direct-writes=BOOL\f[R]: Allow the kernel to dispatch
+multiple, parallel (non-extending) write requests for files opened with
+\f[C]cache.files=per-process\f[R] (if the process is not in
+\f[C]process-names\f[R]) or \f[C]cache.files=off\f[R].
+(This requires kernel support, and was added in v6.2)
+.IP \[bu] 2
 \f[B]direct_io\f[R]: deprecated - Bypass page cache.
 Use \f[C]cache.files=off\f[R] instead.
 (default: false)
@@ -403,8 +443,8 @@ Use \f[C]async_read=false\f[R] instead.
 .IP \[bu] 2
 \f[B]splice_move\f[R]: deprecated - Does nothing.
 .IP \[bu] 2
-\f[B]allow_other\f[R]: deprecated - mergerfs always sets this FUSE
-option as normal permissions can be used to limit access.
+\f[B]allow_other\f[R]: deprecated - mergerfs v2.35.0 and newer sets this
+FUSE option automatically if running as root.
 .IP \[bu] 2
 \f[B]use_ino\f[R]: deprecated - mergerfs should always control inode
 calculation so this is enabled all the time.
@@ -489,8 +529,8 @@ tools use \f[B]/etc/fstab\f[R].
 .IP
 .nf
 \f[C]
-# <file system>        <mount point>  <type>         <options>             <dump>  <pass>
-/mnt/hdd*:/mnt/ssd    /media          fuse.mergerfs  minfreespace=16G      0       0
+# <file system>        <mount point>  <type>    <options>             <dump>  <pass>
+/mnt/hdd*:/mnt/ssd    /media          mergerfs  minfreespace=16G      0       0
 \f[R]
 .fi
 .PP
@@ -524,7 +564,7 @@ Most software does not to care what the values are but those that do
 often break if a value changes unexpectedly.
 The tool \f[C]find\f[R] will abort a directory walk if it sees a
 directory inode change.
-NFS will return stale handle errors if the inode changes out of band.
+NFS can return stale handle errors if the inode changes out of band.
 File dedup tools will usually leverage device ids and inodes as a
 shortcut in searching for duplicate files and would resort to full file
 comparisons should it find different inode values.
@@ -812,8 +852,20 @@ Even though it\[cq]s a more niche situation this hack breaks normal
 security and behavior and as such is \f[C]off\f[R] by default.
 If set to \f[C]git\f[R] it will only perform the hack when the path in
 question includes \f[C]/.git/\f[R].
-\f[C]all\f[R] will result it applying anytime a readonly file which is
+\f[C]all\f[R] will result it applying anytime a read-only file which is
 empty is opened for writing.
+.SS export-support
+.PP
+In theory this flag should not be exposed to the end user.
+It is a low-level FUSE flag which indicates whether or not the kernel
+can send certain kinds of messages to it for the purposes of using with
+NFS.
+mergerfs does support these messages but due bugs and quirks found in
+the kernel and mergerfs this option is provided just in case it is
+needed for debugging.
+.PP
+Given that this flag is set when the FUSE connection is first initiated
+it is not possible to change during run time.
 .SH FUNCTIONS, CATEGORIES and POLICIES
 .PP
 The POSIX filesystem API is made up of a number of functions.
@@ -833,8 +885,6 @@ provide the file handle when a client calls \f[C]fgetattr\f[R],
 \f[C]fchown\f[R], \f[C]fchmod\f[R], \f[C]futimens\f[R],
 \f[C]ftruncate\f[R], etc.
 This means it will call the regular, path based, versions.
-\f[C]readdir\f[R] has no real need for a policy given the purpose is
-merely to return a list of entries in a directory.
 \f[C]statfs\f[R]\[cq]s behavior can be modified via other options.
 .PP
 When using policies which are based on a branch\[cq]s available space
@@ -845,8 +895,8 @@ calculations.
 The reason is that it doesn\[cq]t really work for non-path preserving
 policies and can lead to non-obvious behaviors.
 .PP
-NOTE: While any policy can be assigned to a function or category though
-some may not be very useful in practice.
+NOTE: While any policy can be assigned to a function or category, some
+may not be very useful in practice.
 For instance: \f[B]rand\f[R] (random) may be useful for file creation
 (create) but could lead to very odd behavior if used for \f[C]chmod\f[R]
 if there were more than one copy of the file.
@@ -891,8 +941,7 @@ In cases where something may be searched for (such as a path to clone)
 .SS Policies
 .PP
 A policy is the algorithm used to choose a branch or branches for a
-function to work on.
-Think of them as ways to filter and sort branches.
+function to work on or generally how the function behaves.
 .PP
 Any function in the \f[C]create\f[R] category will clone the relative
 path if needed.
@@ -901,12 +950,12 @@ have special requirements or behaviors which you can read more about
 below.
 .SS Filtering
 .PP
-Policies basically search branches and create a list of files / paths
-for functions to work on.
+Most policies basically search branches and create a list of files /
+paths for functions to work on.
 The policy is responsible for filtering and sorting the branches.
 Filters include \f[B]minfreespace\f[R], whether or not a branch is
 mounted read-only, and the branch tagging (RO,NC,RW).
-These filters are applied across all policies unless otherwise noted.
+These filters are applied across most policies.
 .IP \[bu] 2
 No \f[B]search\f[R] function policies filter.
 .IP \[bu] 2
@@ -926,6 +975,13 @@ Typically \f[B]EROFS\f[R] (read-only filesystem) or \f[B]ENOSPC\f[R] (no
 space left on device) depending on the most recent reason for filtering
 a branch.
 \f[B]ENOENT\f[R] will be returned if no eligible branch is found.
+.PP
+If \f[B]create\f[R], \f[B]mkdir\f[R], \f[B]mknod\f[R], or
+\f[B]symlink\f[R] fail with \f[C]EROFS\f[R] or other fundimental errors
+then mergerfs will mark any branch found to be read-only as such (IE
+will set the mode \f[C]RO\f[R]) and will rerun the policy and try again.
+This is mostly for \f[C]ext4\f[R] filesystems that can suddenly become
+read-only when it encounters an error.
 .SS Path Preservation
 .PP
 Policies, as described below, are of two basic classifications.
@@ -1116,6 +1172,63 @@ T}@T{
 ff
 T}
 .TE
+.SS func.readdir
+.PP
+examples: \f[C]func.readdir=seq\f[R], \f[C]func.readdir=cor:4\f[R]
+.PP
+\f[C]readdir\f[R] has policies to control how it manages reading
+directory content.
+.PP
+.TS
+tab(@);
+lw(26.7n) lw(43.3n).
+T{
+Policy
+T}@T{
+Description
+T}
+_
+T{
+seq
+T}@T{
+\[lq]sequential\[rq] : Iterate over branches in the order defined.
+This is the default and traditional behavior found prior to the readdir
+policy introduction.
+T}
+T{
+cosr
+T}@T{
+\[lq]concurrent open, sequential read\[rq] : Concurrently open branch
+directories using a thread pool and process them in order of definition.
+This keeps memory and CPU usage low while also reducing the time spent
+waiting on branches to respond.
+Number of threads defaults to the number of logical cores.
+Can be overwritten via the syntax \f[C]func.readdir=cosr:N\f[R] where
+\f[C]N\f[R] is the number of threads.
+T}
+T{
+cor
+T}@T{
+\[lq]concurrent open and read\[rq] : Concurrently open branch
+directories and immediately start reading their contents using a thread
+pool.
+This will result in slightly higher memory and CPU usage but reduced
+latency.
+Particularly when using higher latency / slower speed network filesystem
+branches.
+Unlike \f[C]seq\f[R] and \f[C]cosr\f[R] the order of files could change
+due the async nature of the thread pool.
+Number of threads defaults to the number of logical cores.
+Can be overwritten via the syntax \f[C]func.readdir=cor:N\f[R] where
+\f[C]N\f[R] is the number of threads.
+T}
+.TE
+.PP
+Keep in mind that \f[C]readdir\f[R] mostly just provides a list of file
+names in a directory and possibly some basic metadata about said files.
+To know details about the files, as one would see from commands like
+\f[C]find\f[R] or \f[C]ls\f[R], it is required to call \f[C]stat\f[R] on
+the file which is controlled by \f[C]fuse.getattr\f[R].
 .SS ioctl
 .PP
 When \f[C]ioctl\f[R] is used with an open file then it will use the file
@@ -1228,19 +1341,6 @@ The above behavior will help minimize the likelihood of EXDEV being
 returned but it will still be possible.
 .PP
 \f[B]link\f[R] uses the same strategy but without the removals.
-.SS readdir
-.PP
-readdir (http://linux.die.net/man/3/readdir) is different from all other
-filesystem functions.
-While it could have its own set of policies to tweak its behavior at
-this time it provides a simple union of files and directories found.
-Remember that any action or information queried about these files and
-directories come from the respective function.
-For instance: an \f[B]ls\f[R] is a \f[B]readdir\f[R] and for each
-file/directory returned \f[B]getattr\f[R] is called.
-Meaning the policy of \f[B]getattr\f[R] is responsible for choosing the
-file/directory which is the source of the metadata you see in an
-\f[B]ls\f[R].
 .SS statfs / statvfs
 .PP
 statvfs (http://linux.die.net/man/2/statvfs) normalizes the source
@@ -1255,6 +1355,24 @@ be included when checking the mount\[cq]s stats.
 .PP
 The options \f[C]statfs\f[R] and \f[C]statfs_ignore\f[R] can be used to
 modify \f[C]statfs\f[R] behavior.
+.SS flush-on-close
+.PP
+https://lkml.kernel.org/linux-fsdevel/20211024132607.1636952-1-amir73il\[at]gmail.com/T/
+.PP
+By default FUSE would issue a flush before the release of a file
+descriptor.
+This was considered a bit aggressive and a feature added to give the
+FUSE server the ability to choose when that happens.
+.PP
+Options: * always * never * opened-for-write
+.PP
+For now it defaults to \[lq]opened-for-write\[rq] which is less
+aggressive than the behavior before this feature was added.
+It should not be a problem because the flush is really only relevant
+when a file is written to.
+Given flush is irrelevant for many filesystems in the future a branch
+specific flag may be added so only files opened on a specific branch
+would be flushed on close.
 .SH ERROR HANDLING
 .PP
 POSIX filesystem functions offer a single return code meaning that there
@@ -1464,8 +1582,8 @@ apply those before mounting the new version.
 \f[C]
 $ sudo mount /mnt/mergerfs
 $ mount | grep mergerfs
-media on /mnt/mergerfs type fuse.mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
-media on /mnt/mergerfs type fuse.mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
+media on /mnt/mergerfs type mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
+media on /mnt/mergerfs type mergerfs (rw,relatime,user_id=0,group_id=0,default_permissions,allow_other)
 \f[R]
 .fi
 .PP
@@ -1476,7 +1594,8 @@ Before mounting over top the mount point with the new instance of
 mergerfs issue: \f[C]umount -l <mergerfs_mountpoint>\f[R].
 Or you can let mergerfs do it by setting the option
 \f[C]lazy-umount-mountpoint=true\f[R].
-.SH RUNTIME CONFIG
+.SH RUNTIME INTERFACES
+.SS RUNTIME CONFIG
 .SS .mergerfs pseudo file
 .IP
 .nf
@@ -1592,7 +1711,148 @@ given the getattr policy
 .IP \[bu] 2
 \f[B]user.mergerfs.allpaths\f[R]: a NUL (`\[rs]0') separated list of
 full paths to all files found
+.SS SIGNALS
+.IP \[bu] 2
+USR1: This will cause mergerfs to send invalidation notifications to the
+kernel for all files.
+This will cause all unused files to be released from memory.
+.IP \[bu] 2
+USR2: Trigger a general cleanup of currently unused memory.
+A more thorough version of what happens every \[ti]15 minutes.
+.SS IOCTLS
+.PP
+Found in \f[C]fuse_ioctl.cpp\f[R]:
+.IP
+.nf
+\f[C]
+typedef char IOCTL_BUF[4096];
+#define IOCTL_APP_TYPE  0xDF
+#define IOCTL_FILE_INFO            _IOWR(IOCTL_APP_TYPE,0,IOCTL_BUF)
+#define IOCTL_GC                   _IO(IOCTL_APP_TYPE,1)
+#define IOCTL_GC1                  _IO(IOCTL_APP_TYPE,2)
+#define IOCTL_INVALIDATE_ALL_NODES _IO(IOCTL_APP_TYPE,3)
+\f[R]
+.fi
+.IP \[bu] 2
+IOCTL_FILE_INFO: Same as the \[lq]file / directory xattrs\[rq] mentioned
+above.
+Use a buffer size of 4096 bytes.
+Pass in a string of \[lq]basepath\[rq], \[lq]relpath\[rq],
+\[lq]fullpath\[rq], or \[lq]allpaths\[rq].
+Receive details in same buffer.
+.IP \[bu] 2
+IOCTL_GC: Triggers a thorough garbage collection of excess memory.
+Same as SIGUSR2.
+.IP \[bu] 2
+IOCTL_GC1: Triggers a simple garbage collection of excess memory.
+Same as what happens every 15 minutes normally.
+.IP \[bu] 2
+IOCTL_INVALIDATE_ALL_NODES: Same as SIGUSR1.
+Send invalidation notifications to the kernel for all files causing
+unused files to be released from memory.
 .SH TOOLING
+.SS preload.so
+.PP
+EXPERIMENTAL
+.PP
+For some time there has been work to enable passthrough IO in FUSE.
+Passthrough IO would allow for near native performance with regards to
+reads and writes (at the expense of certain mergerfs features.) However,
+there have been several complications which have kept the feature from
+making it into the mainline Linux kernel.
+Until that feature is available there are two methods to provide similar
+functionality.
+One method is using the LD_PRELOAD feature of the dynamic linker.
+The other leveraging ptrace to intercept syscalls.
+Each has their disadvantages.
+At the moment only a preload based tool is available.
+A ptrace based tool may be developed later if there is a need.
+.PP
+\f[C]/usr/lib/mergerfs/preload.so\f[R]
+.PP
+This preloadable
+library (https://man7.org/linux/man-pages/man8/ld.so.8.html#ENVIRONMENT)
+overrides the creation and opening of files in order to simulate
+passthrough file IO.
+It catches the open/creat/fopen calls, has mergerfs do the call, queries
+mergerfs for the branch the file exists on, reopens the file on the
+underlying filesystem and returns that instead.
+Meaning that you will get native read/write performance because mergerfs
+is no longer part of the workflow.
+Keep in mind that this also means certain mergerfs features that work by
+interrupting the read/write workflow, such as \f[C]moveonenospc\f[R],
+will no longer work.
+.PP
+Also understand that this will only work on dynamically linked software.
+Anything statically compiled will not work.
+Many GoLang and Rust apps are statically compiled.
+.PP
+The library will not interfere with non-mergerfs filesystems.
+The library is written to always fallback to returning the mergerfs
+opened file on error.
+.PP
+While the library was written to account for a number of edgecases there
+could be some yet accounted for so please report any oddities.
+.PP
+Thank you to nohajc (https://github.com/nohajc/mergerfs-io-passthrough)
+for prototyping the idea.
+.SS general usage
+.IP
+.nf
+\f[C]
+LD_PRELOAD=/usr/lib/mergerfs/preload.so touch /mnt/mergerfs/filename
+\f[R]
+.fi
+.SS Docker usage
+.PP
+Assume \f[C]/mnt/fs0\f[R] and \f[C]/mnt/fs1\f[R] are pooled with
+mergerfs at \f[C]/media\f[R].
+.PP
+All mergerfs branch paths \f[I]must\f[R] be bind mounted into the
+container at the same path as found on the host so the preload library
+can see them.
+.IP
+.nf
+\f[C]
+docker run \[rs]
+  -e LD_PRELOAD=/usr/lib/mergerfs/preload.so \[rs]
+  -v /usr/lib/mergerfs/preload.so:/usr/lib/mergerfs/preload.so:ro \[rs]
+  -v /media:/data \[rs]
+  -v /mnt:/mnt \[rs]
+  ubuntu:latest \[rs]
+  bash
+\f[R]
+.fi
+.PP
+or more explicitly
+.IP
+.nf
+\f[C]
+docker run \[rs]
+  -e LD_PRELOAD=/usr/lib/mergerfs/preload.so \[rs]
+  -v /usr/lib/mergerfs/preload.so:/usr/lib/mergerfs/preload.so:ro \[rs]
+  -v /media:/data \[rs]
+  -v /mnt/fs0:/mnt/fs0 \[rs]
+  -v /mnt/fs1:/mnt/fs1 \[rs]
+  ubuntu:latest \[rs]
+  bash
+\f[R]
+.fi
+.SS systemd unit
+.PP
+Use the \f[C]Environment\f[R] option to set the LD_PRELOAD variable.
+.IP \[bu] 2
+https://www.freedesktop.org/software/systemd/man/latest/systemd.service.html#Command%20lines
+.IP \[bu] 2
+https://serverfault.com/questions/413397/how-to-set-environment-variable-in-systemd-service
+.IP
+.nf
+\f[C]
+[Service]
+Environment=LD_PRELOAD=/usr/lib/mergerfs/preload.so
+\f[R]
+.fi
+.SS Misc
 .IP \[bu] 2
 https://github.com/trapexit/mergerfs-tools
 .RS 2
@@ -1649,9 +1909,12 @@ size are unchanged since previous open.
 cache.files=libfuse: follow traditional libfuse \f[C]direct_io\f[R],
 \f[C]kernel_cache\f[R], and \f[C]auto_cache\f[R] arguments.
 .IP \[bu] 2
-cache.files=per-process: Enable page caching only for processes which
-`comm' name matches one of the values defined in
+cache.files=per-process: Enable page caching (equivalent to
+\f[C]cache.files=partial\f[R]) only for processes whose `comm' name
+matches one of the values defined in
 \f[C]cache.files.process-names\f[R].
+If the name does not match the file open is equivalent to
+\f[C]cache.files=off\f[R].
 .PP
 FUSE, which mergerfs uses, offers a number of page caching modes.
 mergerfs tries to simplify their use via the \f[C]cache.files\f[R]
@@ -1790,7 +2053,7 @@ The placing of usually smaller, faster storage as a transparent cache to
 larger, slower storage.
 NVMe, SSD, Optane in front of traditional HDDs for instance.
 .PP
-MergerFS does not natively support any sort of tiered caching.
+mergerfs does not natively support any sort of tiered caching.
 Most users have no use for such a feature and its inclusion would
 complicate the code.
 However, there are a few situations where a cache filesystem could help
@@ -1902,6 +2165,8 @@ increase cache timeouts \f[C]cache.attr\f[R], \f[C]cache.entry\f[R],
 .IP \[bu] 2
 enable (or disable) page caching (\f[C]cache.files\f[R])
 .IP \[bu] 2
+enable \f[C]parallel-direct-writes\f[R]
+.IP \[bu] 2
 enable \f[C]cache.writeback\f[R]
 .IP \[bu] 2
 enable \f[C]cache.statfs\f[R]
@@ -2139,18 +2404,13 @@ Use \f[C]cache.files=off\f[R] and/or \f[C]dropcacheonclose=true\f[R].
 See the section on page caching.
 .SS NFS clients returning ESTALE / Stale file handle
 .PP
-NFS does not like out of band changes.
-That is especially true of inode values.
-.PP
-Be sure to use the following options:
-.IP \[bu] 2
-noforget
-.IP \[bu] 2
-inodecalc=path-hash
+NFS generally does not like out of band changes.
+Take a look at the section on NFS in the #remote-filesystems for more
+details.
 .SS rtorrent fails with ENODEV (No such device)
 .PP
-Be sure to set \f[C]cache.files=partial|full|auto-full|per-processe\f[R]
-or turn off \f[C]direct_io\f[R].
+Be sure to set
+\f[C]cache.files=partial|full|auto-full|per-processe\f[R].
 rtorrent and some other applications use
 mmap (http://linux.die.net/man/2/mmap) to read and write to files and
 offer no fallback to traditional methods.
@@ -2303,6 +2563,123 @@ There might be a hack to work around this (make mergerfs read the
 would be limited to Linux and the /etc/group DB.
 Preferably users would mount in the host group file into the containers
 or use a standard shared user & groups technology like NIS or LDAP.
+.SH Remote Filesystems
+.PP
+Many users ask about compatibility with remote filesystems.
+This section is to describe any known issues or quirks when using
+mergerfs with common remote filesystems.
+.PP
+Keep in mind that, like with caching, it is not a good idea to change
+the contents of the remote filesystem
+out-of-band (https://en.wikipedia.org/wiki/Out-of-band).
+Meaning that you really shouldn\[cq]t change the contents of the
+underlying filesystems or mergerfs on the server hosting the remote
+filesystem.
+Doing so can lead to weird behavior, inconsistency, errors, and even
+data corruption should multiple programs try to write or read the same
+data at the same time.
+This isn\[cq]t to say you can\[cq]t do it or that data corruption is
+likely but it \f[I]could\f[R] happen.
+It is better to always use the remote filesystem.
+Even on the machine serving it.
+.SS NFS
+.PP
+NFS (https://en.wikipedia.org/wiki/Network_File_System) is a common
+remote filesystem on Unix/POSIX systems.
+Due to how NFS works there are some settings which need to be set in
+order for mergerfs to work with it.
+.PP
+It should be noted that NFS and FUSE (the technology mergerfs uses) do
+not work perfectly with one another due to certain design choices in
+FUSE (and mergerfs.) Due to these issues it is generally recommended to
+use SMB when possible till situations change.
+That said mergerfs should generally work as an export of NFS and issues
+discovered should still be reported.
+.PP
+To ensure compatibility between mergerfs and NFS use the following
+settings.
+.PP
+mergerfs settings: * noforget * inodecalc=path-hash
+.PP
+NFS export settings: * fsid=UUID * no_root_squash
+.PP
+\f[C]noforget\f[R] is needed because NFS uses the
+\f[C]name_to_handle_at\f[R] and \f[C]open_by_handle_at\f[R] functions
+which allow a program to keep a reference to a file without technically
+having it open in the typical sense.
+The problem is that FUSE has no way to know that NFS has a handle that
+it will later use to open the file again.
+As a result it is possible for the kernel to tell mergerfs to forget
+about the node and should NFS ever ask for that node\[cq]s details in
+the future it would have nothing to respond with.
+Keeping nodes around forever is not ideal but at the moment the only way
+to manage the situation.
+.PP
+\f[C]inodecalc=path-hash\f[R] is needed because NFS is sensitive to
+out-of-band changes.
+FUSE doesn\[cq]t care if a file\[cq]s inode value changes but NFS, being
+stateful, does.
+So if you used the default inode calculation algorithm then it is
+possible that if you changed a file or updated a directory the file
+mergerfs will use will be on a different branch and therefore the inode
+would change.
+This isn\[cq]t an ideal solution and others are being considered but it
+works for most situations.
+.PP
+\f[C]fsid=UUID\f[R] is needed because FUSE filesystems don\[cq]t have
+different \f[C]st_dev\f[R] values which can cause issues when exporting.
+The easiest thing to do is set each mergerfs export \f[C]fsid\f[R] to
+some random value.
+An easy way to generate a random value is to use the command line tool
+\f[C]uuid\f[R] or \f[C]uuidgen\f[R] or through a website such as
+uuidgenerator.net (https://www.uuidgenerator.net/).
+.PP
+\f[C]no_root_squash\f[R] is not strictly necessary but can lead to
+confusing permission and ownership issues if root squashing is enabled.
+.SS SMB / CIFS
+.PP
+SMB (https://en.wikipedia.org/wiki/Server_Message_Block) is a protocol
+most used by Microsoft Windows systems to share file shares, printers,
+etc.
+However, due to the popularity for Windows, it is also supported on many
+other platforms including Linux.
+The most popular way of supporting SMB on Linux is via the software
+Samba.
+.PP
+Samba (https://en.wikipedia.org/wiki/Samba_(software)), and other ways
+of serving Linux filesystems, via SMB should work fine with mergerfs.
+The services do not tend to use the same technologies which NFS uses and
+therefore don\[cq]t have the same issues.
+There should not be an special settings required to use mergerfs with
+Samba.
+However, CIFSD (https://en.wikipedia.org/wiki/CIFSD) and other programs
+have not been extensively tested.
+If you use mergerfs with CIFSD or other SMB servers please submit your
+experiences so these docs can be updated.
+.SS SSHFS
+.PP
+SSHFS (https://en.wikipedia.org/wiki/SSHFS) is a FUSE filesystem
+leveraging SSH as the connection and transport layer.
+While often simpler to setup when compared to NFS or Samba the
+performance can be lacking and the project is very much in maintenance
+mode.
+.PP
+There are no known issues using sshfs with mergerfs.
+You may want to use the following arguments to improve performance but
+your millage may vary.
+.IP \[bu] 2
+\f[C]-o Ciphers=arcfour\f[R]
+.IP \[bu] 2
+\f[C]-o Compression=no\f[R]
+.PP
+More info can be found
+here (https://ideatrash.net/2016/08/odds-and-ends-optimizing-sshfs-moving.html).
+.SS Other
+.PP
+There are other remote filesystems but none popularly used to serve
+mergerfs.
+If you use something not listed above feel free to reach out and I will
+add it to the list.
 .SH FAQ
 .SS How well does mergerfs scale? Is it \[lq]production ready?\[rq]
 .PP
@@ -2322,17 +2699,50 @@ All of which are fixed in stable releases.
 .SS Can mergerfs be used with filesystems which already have data / are in use?
 .PP
 Yes.
-MergerFS is a proxy and does \f[B]NOT\f[R] interfere with the normal
-form or function of the filesystems / mounts / paths it manages.
+mergerfs is really just a proxy and does \f[B]NOT\f[R] interfere with
+the normal form or function of the filesystems / mounts / paths it
+manages.
+It is just another userland application that is acting as a
+man-in-the-middle.
+It can\[cq]t do anything that any other random piece of software
+can\[cq]t do.
 .PP
-MergerFS is \f[B]not\f[R] a traditional filesystem.
-MergerFS is \f[B]not\f[R] RAID.
+mergerfs is \f[B]not\f[R] a traditional filesystem that takes control
+over the underlying block device.
+mergerfs is \f[B]not\f[R] RAID.
 It does \f[B]not\f[R] manipulate the data that passes through it.
 It does \f[B]not\f[R] shard data across filesystems.
 It merely shards some \f[B]behavior\f[R] and aggregates others.
+.SS Can drives/filesystems be removed from the pool at will?
+.PP
+Yes.
+See previous question\[cq]s answer.
 .SS Can mergerfs be removed without affecting the data?
 .PP
+Yes.
 See the previous question\[cq]s answer.
+.SS Can drives/filesystems be moved to another pool?
+.PP
+Yes.
+See the previous question\[cq]s answer.
+.SS How do I migrate data into or out of the pool when adding/removing drives/filesystems?
+.PP
+You don\[cq]t need to.
+See the previous question\[cq]s answer.
+.SS How do I remove a drive/filesystem but keep the data in the pool?
+.PP
+Nothing special needs to be done.
+Remove the branch from mergerfs\[cq] config and copy (rsync) the data
+from the removed filesystem into the pool.
+Effectively the same as if it were you transfering data from one
+filesystem to another.
+.PP
+If you wish to continue using the pool while performing the transfer
+simply create another, temporary pool without the filesystem in question
+and then copy the data.
+It would probably be a good idea to set the branch to \f[C]RO\f[R] prior
+to doing this to ensure no new content is written to the filesystem
+while performing the copy.
 .SS What policies should I use?
 .PP
 Unless you\[cq]re doing something more niche the average user is
@@ -2406,7 +2816,9 @@ Anything, files or directories, created in that first directory will be
 placed on the same branch because it is preserving paths.
 .PP
 This catches a lot of new users off guard but changing the default would
-break the setup for many existing users.
+break the setup for many existing users and this policy is the safest
+policy as it will not change the general layout of the existing
+filesystems.
 If you do not care about path preservation and wish your files to be
 spread across all your filesystems change to \f[C]mfs\f[R] or similar
 policy as described above.
@@ -2436,6 +2848,16 @@ considered different devices.
 There is no way to link between them.
 You should mount in the highest directory in the mergerfs pool that
 includes all the paths you need if you want links to work.
+.SS Does FICLONE or FICLONERANGE work?
+.PP
+Unfortunately not.
+FUSE, the technology mergerfs is based on, does not support the
+\f[C]clone_file_range\f[R] feature needed for it to work.
+mergerfs won\[cq]t even know such a request is made.
+The kernel will simply return an error back to the application making
+the request.
+.PP
+Should FUSE gain the ability mergerfs will be updated to support it.
 .SS Can I use mergerfs without SnapRAID? SnapRAID without mergerfs?
 .PP
 Yes.
@@ -2499,8 +2921,8 @@ executable bit set.
 A common mistake by users new to Linux is to \f[C]chmod -R 644\f[R] when
 they should have \f[C]chmod -R u=rwX,go=rX\f[R].
 .PP
-If using a network filesystem such as NFS, SMB, CIFS (Samba) be sure to
-pay close attention to anything regarding permissioning and users.
+If using a network filesystem such as NFS or SMB (Samba) be sure to pay
+close attention to anything regarding permissioning and users.
 Root squashing and user translation for instance has bitten a few
 mergerfs users.
 Some of these also affect the use of mergerfs from container platforms
@@ -2559,93 +2981,6 @@ best provide equivalent performance and in cases worse performance.
 Splice is not supported on other platforms forcing a traditional
 read/write fallback to be provided.
 The splice code was removed to simplify the codebase.
-.SS Why use mergerfs over mhddfs?
-.PP
-mhddfs is no longer maintained and has some known stability and security
-issues (see below).
-MergerFS provides a superset of mhddfs\[cq] features and should offer
-the same or maybe better performance.
-.PP
-Below is an example of mhddfs and mergerfs setup to work similarly.
-.PP
-\f[C]mhddfs -o mlimit=4G,allow_other /mnt/drive1,/mnt/drive2 /mnt/pool\f[R]
-.PP
-\f[C]mergerfs -o minfreespace=4G,category.create=ff /mnt/drive1:/mnt/drive2 /mnt/pool\f[R]
-.SS Why use mergerfs over aufs?
-.PP
-aufs is mostly abandoned and no longer available in many distros.
-.PP
-While aufs can offer better peak performance mergerfs provides more
-configurability and is generally easier to use.
-mergerfs however does not offer the overlay / copy-on-write (CoW)
-features which aufs and overlayfs have.
-.SS Why use mergerfs over unionfs?
-.PP
-UnionFS is more like aufs than mergerfs in that it offers overlay / CoW
-features.
-If you\[cq]re just looking to create a union of filesystems and want
-flexibility in file/directory placement then mergerfs offers that
-whereas unionfs is more for overlaying RW filesystems over RO ones.
-.SS Why use mergerfs over overlayfs?
-.PP
-Same reasons as with unionfs.
-.SS Why use mergerfs over LVM/ZFS/BTRFS/RAID0 drive concatenation / striping?
-.PP
-With simple JBOD / drive concatenation / stripping / RAID0 a single
-drive failure will result in full pool failure.
-mergerfs performs a similar function without the possibility of
-catastrophic failure and the difficulties in recovery.
-Drives may fail, however, all other data will continue to be accessible.
-.PP
-When combined with something like SnapRaid (http://www.snapraid.it)
-and/or an offsite backup solution you can have the flexibility of JBOD
-without the single point of failure.
-.SS Why use mergerfs over ZFS?
-.PP
-MergerFS is not intended to be a replacement for ZFS.
-MergerFS is intended to provide flexible pooling of arbitrary
-filesystems (local or remote), of arbitrary sizes, and arbitrary
-filesystems.
-For \f[C]write once, read many\f[R] usecases such as bulk media storage.
-Where data integrity and backup is managed in other ways.
-In that situation ZFS can introduce a number of costs and limitations as
-described
-here (http://louwrentius.com/the-hidden-cost-of-using-zfs-for-your-home-nas.html),
-here (https://markmcb.com/2020/01/07/five-years-of-btrfs/), and
-here (https://utcc.utoronto.ca/~cks/space/blog/solaris/ZFSWhyNoRealReshaping).
-.SS Why use mergerfs over UnRAID?
-.PP
-UnRAID is a full OS and its storage layer, as I understand, is
-proprietary and closed source.
-Users who have experience with both have said they prefer the
-flexibility offered by mergerfs and for some the fact it is free and
-open source is important.
-.PP
-There are a number of UnRAID users who use mergerfs as well though
-I\[cq]m not entirely familiar with the use case.
-.SS Why use mergerfs over StableBit\[cq]s DrivePool?
-.PP
-DrivePool works only on Windows so not as common an alternative as other
-Linux solutions.
-If you want to use Windows then DrivePool is a good option.
-Functionally the two projects work a bit differently.
-DrivePool always writes to the filesystem with the most free space and
-later rebalances.
-mergerfs does not offer rebalance but chooses a branch at file/directory
-create time.
-DrivePool\[cq]s rebalancing can be done differently in any directory and
-has file pattern matching to further customize the behavior.
-mergerfs, not having rebalancing does not have these features, but
-similar features are planned for mergerfs v3.
-DrivePool has builtin file duplication which mergerfs does not natively
-support (but can be done via an external script.)
-.PP
-There are a lot of misc differences between the two projects but most
-features in DrivePool can be replicated with external tools in
-combination with mergerfs.
-.PP
-Additionally DrivePool is a closed source commercial product vs mergerfs
-a ISC licensed OSS project.
 .SS What should mergerfs NOT be used for?
 .IP \[bu] 2
 databases: Even if the database stored data in separate files (mergerfs
@@ -2712,33 +3047,14 @@ mergerfs uses available space for statfs calculations.
 If you\[cq]ve reserved space for root then it won\[cq]t show up.
 .PP
 You can remove the reserve by running: \f[C]tune2fs -m 0 <device>\f[R]
-.SS Can mergerfs mounts be exported over NFS?
-.PP
-Yes, however if you do anything which may changes files out of band
-(including for example using the \f[C]newest\f[R] policy) it will result
-in \[lq]stale file handle\[rq] errors unless properly setup.
-.PP
-Be sure to use the following options:
-.IP \[bu] 2
-noforget
-.IP \[bu] 2
-inodecalc=path-hash
-.SS Can mergerfs mounts be exported over Samba / SMB?
-.PP
-Yes.
-While some users have reported problems it appears to always be related
-to how Samba is setup in relation to permissions.
-.SS Can mergerfs mounts be used over SSHFS?
-.PP
-Yes.
 .SS I notice massive slowdowns of writes when enabling cache.files.
 .PP
-When file caching is enabled in any form (\f[C]cache.files!=off\f[R] or
-\f[C]direct_io=false\f[R]) it will issue \f[C]getxattr\f[R] requests for
-\f[C]security.capability\f[R] prior to \f[I]every single write\f[R].
+When file caching is enabled in any form (\f[C]cache.files!=off\f[R]) it
+will issue \f[C]getxattr\f[R] requests for \f[C]security.capability\f[R]
+prior to \f[I]every single write\f[R].
 This will usually result in a performance degradation, especially when
-using a network filesystem (such as NFS or CIFS/SMB/Samba.)
-Unfortunately at this moment the kernel is not caching the response.
+using a network filesystem (such as NFS or SMB.) Unfortunately at this
+moment the kernel is not caching the response.
 .PP
 To work around this situation mergerfs offers a few solutions.
 .IP "1." 3
@@ -2801,6 +3117,108 @@ If the ability to give writers priority is supported then that flag will
 be used so threads trying to change credentials don\[cq]t starve.
 This isn\[cq]t the best solution but should work reasonably well
 assuming there are few users.
+.SH mergerfs versus X
+.SS mhddfs
+.PP
+mhddfs had not been maintained for some time and has some known
+stability and security issues.
+mergerfs provides a superset of mhddfs\[cq] features and should offer
+the same or better performance.
+.PP
+Below is an example of mhddfs and mergerfs setup to work similarly.
+.PP
+\f[C]mhddfs -o mlimit=4G,allow_other /mnt/drive1,/mnt/drive2 /mnt/pool\f[R]
+.PP
+\f[C]mergerfs -o minfreespace=4G,category.create=ff /mnt/drive1:/mnt/drive2 /mnt/pool\f[R]
+.SS aufs
+.PP
+aufs is mostly abandoned and no longer available in most Linux distros.
+.PP
+While aufs can offer better peak performance mergerfs provides more
+configurability and is generally easier to use.
+mergerfs however does not offer the overlay / copy-on-write (CoW)
+features which aufs has.
+.SS unionfs-fuse
+.PP
+unionfs-fuse is more like aufs than mergerfs in that it offers overlay /
+copy-on-write (CoW) features.
+If you\[cq]re just looking to create a union of filesystems and want
+flexibility in file/directory placement then mergerfs offers that
+whereas unionfs is more for overlaying read/write filesystems over
+read-only ones.
+.SS overlayfs
+.PP
+overlayfs is similar to aufs and unionfs-fuse in that it also is
+primarily used to layer a read/write filesystem over one or more
+read-only filesystems.
+It does not have the ability to spread files/directories across numerous
+filesystems.
+.SS RAID0, JBOD, drive concatenation, striping
+.PP
+With simple JBOD / drive concatenation / stripping / RAID0 a single
+drive failure will result in full pool failure.
+mergerfs performs a similar function without the possibility of
+catastrophic failure and the difficulties in recovery.
+Drives may fail but all other filesystems and their data will continue
+to be accessible.
+.PP
+The main practical difference with mergerfs is the fact you don\[cq]t
+actually have contiguous space as large as if you used those other
+technologies.
+Meaning you can\[cq]t create a 2TB file on a pool of 2 1TB filesystems.
+.PP
+When combined with something like SnapRaid (http://www.snapraid.it)
+and/or an offsite backup solution you can have the flexibility of JBOD
+without the single point of failure.
+.SS UnRAID
+.PP
+UnRAID is a full OS and its storage layer, as I understand, is
+proprietary and closed source.
+Users who have experience with both have often said they prefer the
+flexibility offered by mergerfs and for some the fact it is open source
+is important.
+.PP
+There are a number of UnRAID users who use mergerfs as well though
+I\[cq]m not entirely familiar with the use case.
+.PP
+For semi-static data mergerfs + SnapRaid (http://www.snapraid.it)
+provides a similar solution.
+.SS ZFS
+.PP
+mergerfs is very different from ZFS.
+mergerfs is intended to provide flexible pooling of arbitrary
+filesystems (local or remote), of arbitrary sizes, and arbitrary
+filesystems.
+For \f[C]write once, read many\f[R] usecases such as bulk media storage.
+Where data integrity and backup is managed in other ways.
+In those usecases ZFS can introduce a number of costs and limitations as
+described
+here (http://louwrentius.com/the-hidden-cost-of-using-zfs-for-your-home-nas.html),
+here (https://markmcb.com/2020/01/07/five-years-of-btrfs/), and
+here (https://utcc.utoronto.ca/~cks/space/blog/solaris/ZFSWhyNoRealReshaping).
+.SS StableBit\[cq]s DrivePool
+.PP
+DrivePool works only on Windows so not as common an alternative as other
+Linux solutions.
+If you want to use Windows then DrivePool is a good option.
+Functionally the two projects work a bit differently.
+DrivePool always writes to the filesystem with the most free space and
+later rebalances.
+mergerfs does not offer rebalance but chooses a branch at file/directory
+create time.
+DrivePool\[cq]s rebalancing can be done differently in any directory and
+has file pattern matching to further customize the behavior.
+mergerfs, not having rebalancing does not have these features, but
+similar features are planned for mergerfs v3.
+DrivePool has builtin file duplication which mergerfs does not natively
+support (but can be done via an external script.)
+.PP
+There are a lot of misc differences between the two projects but most
+features in DrivePool can be replicated with external tools in
+combination with mergerfs.
+.PP
+Additionally DrivePool is a closed source commercial product vs mergerfs
+a ISC licensed OSS project.
 .SH SUPPORT
 .PP
 Filesystems are complex and difficult to debug.

mergerfs.spec

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

src/branches.cpp

@@ -21,10 +21,12 @@
 #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>
 
@@ -415,6 +417,24 @@ Branches::to_string(void) const
   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_)
 {
@@ -424,7 +444,8 @@ SrcMounts::SrcMounts(Branches &b_)
 int
 SrcMounts::from_string(const std::string &s_)
 {
-  return _branches.from_string(s_);
+  //  return _branches.from_string(s_);
+  return 0;
 }
 
 std::string

src/branches.hpp

@@ -76,6 +76,9 @@ 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;

src/config.cpp

@@ -58,6 +58,8 @@ namespace l
     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");
@@ -65,9 +67,11 @@ namespace l
     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");
 
@@ -91,9 +95,12 @@ Config::Config()
     cache_symlinks(false),
     category(func),
     direct_io(false),
+    direct_io_allow_mmap(true),
     dropcacheonclose(false),
-    fsname(),
+    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),
@@ -106,10 +113,10 @@ Config::Config()
     moveonenospc(false),
     nfsopenhack(NFSOpenHack::ENUM::OFF),
     nullrw(false),
-    pid(::getpid()),
+    parallel_direct_writes(false),
     posix_acl(false),
     readahead(0),
-    readdir(ReadDir::ENUM::POSIX),
+    readdir("seq"),
     readdirplus(false),
     rename_exdev(RenameEXDEV::ENUM::PASSTHROUGH),
     scheduling_priority(-10),
@@ -121,6 +128,7 @@ Config::Config()
     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),
@@ -144,7 +152,10 @@ Config::Config()
   _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;
@@ -158,6 +169,7 @@ Config::Config()
   _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;
@@ -181,10 +193,10 @@ Config::Config()
   _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["readdir"]            = &readdir;
   _map["readdirplus"]            = &readdirplus;
   _map["rename-exdev"]           = &rename_exdev;
   _map["scheduling-priority"]    = &scheduling_priority;
@@ -197,6 +209,7 @@ Config::Config()
   _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;
 }

src/config.hpp

@@ -19,21 +19,23 @@
 #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 "config_set.hpp"
 #include "enum.hpp"
 #include "errno.hpp"
 #include "funcs.hpp"
+#include "fuse_readdir.hpp"
 #include "policy.hpp"
 #include "rwlock.hpp"
 #include "tofrom_wrapper.hpp"
@@ -115,9 +117,12 @@ public:
   ConfigBOOL     cache_symlinks;
   Categories     category;
   ConfigBOOL     direct_io;
+  ConfigBOOL     direct_io_allow_mmap;
   ConfigBOOL     dropcacheonclose;
-  ConfigSTR      fsname;
+  ConfigBOOL     export_support;
+  FlushOnClose   flushonclose;
   FollowSymlinks follow_symlinks;
+  ConfigSTR      fsname;
   Funcs          func;
   ConfigUINT64   fuse_msg_size;
   ConfigBOOL     ignorepponrename;
@@ -131,10 +136,11 @@ public:
   MoveOnENOSPC   moveonenospc;
   NFSOpenHack    nfsopenhack;
   ConfigBOOL     nullrw;
-  ConfigUINT64   pid;
+  ConfigBOOL     parallel_direct_writes;
+  ConfigGetPid   pid;
   ConfigBOOL     posix_acl;
   ConfigUINT64   readahead;
-  ReadDir        readdir;
+  FUSE::ReadDir  readdir;
   ConfigBOOL     readdirplus;
   RenameEXDEV    rename_exdev;
   ConfigINT      scheduling_priority;
@@ -146,12 +152,12 @@ public:
   ConfigUINT64   symlinkify_timeout;
   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;
 

src/config_flushonclose.cpp

@@ -1,7 +1,7 @@
 /*
   ISC License
 
-  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+  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
@@ -16,36 +16,39 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#include "config_readdir.hpp"
+#include "config_flushonclose.hpp"
 #include "ef.hpp"
 #include "errno.hpp"
 
+template<>
+std::string
+FlushOnClose::to_string() const
+{
+  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
-ReadDir::from_string(const std::string &s_)
+FlushOnClose::from_string(const std::string &s_)
 {
-  if(s_ == "posix")
-    _data = ReadDir::ENUM::POSIX;
-  ef(s_ == "linux")
-    _data = ReadDir::ENUM::LINUX;
+  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;
 }
-
-template<>
-std::string
-ReadDir::to_string(void) const
-{
-  switch(_data)
-    {
-    case ReadDir::ENUM::POSIX:
-      return "posix";
-    case ReadDir::ENUM::LINUX:
-      return "linux";
-    }
-
-  return "invalid";
-}

src/config_flushonclose.hpp

@@ -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 "enum.hpp"
+
+
+enum class FlushOnCloseEnum
+  {
+    NEVER,
+    OPENED_FOR_WRITE,
+    ALWAYS
+  };
+
+typedef Enum<FlushOnCloseEnum> FlushOnClose;

src/config_pid.hpp

@@ -0,0 +1,42 @@
+/*
+  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 "tofrom_string.hpp"
+#include "fmt/core.h"
+
+#include <sys/types.h>
+#include <unistd.h>
+
+
+class ConfigGetPid : public ToFromString
+{
+public:
+  std::string
+  to_string() const final
+  {
+    return fmt::format("{}",::getpid());
+  }
+
+  int
+  from_string(const std::string &) final
+  {
+    return -EROFS;
+  }
+};

src/fileinfo.hpp

@@ -18,19 +18,25 @@
 
 #include "fh.hpp"
 
+#include <cstdint>
 #include <string>
+#include <mutex>
 
 
 class FileInfo : public FH
 {
 public:
-  FileInfo(const int   fd_,
-           const char *fusepath_)
+  FileInfo(int const   fd_,
+           char const *fusepath_,
+           bool const  direct_io_)
     : FH(fusepath_),
-      fd(fd_)
+      fd(fd_),
+      direct_io(direct_io_)
   {
   }
 
 public:
   int fd;
+  uint32_t direct_io:1;
+  std::mutex mutex;
 };

src/fmt/args.h

@@ -1,4 +1,4 @@
-// Formatting library for C++ - dynamic format arguments
+// Formatting library for C++ - dynamic argument lists
 //
 // Copyright (c) 2012 - present, Victor Zverovich
 // All rights reserved.
@@ -22,8 +22,9 @@ 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) {
+template <typename T> auto unwrap(const T& v) -> const T& { return v; }
+template <typename T>
+auto unwrap(const std::reference_wrapper<T>& v) -> const T& {
   return static_cast<const T&>(v);
 }
 
@@ -50,7 +51,7 @@ class dynamic_arg_list {
   std::unique_ptr<node<>> head_;
 
  public:
-  template <typename T, typename Arg> const T& push(const Arg& arg) {
+  template <typename T, typename Arg> auto push(const Arg& arg) -> const T& {
     auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
     auto& value = new_node->value;
     new_node->next = std::move(head_);
@@ -110,14 +111,14 @@ class dynamic_format_arg_store
 
   friend class basic_format_args<Context>;
 
-  unsigned long long get_types() const {
+  auto get_types() const -> unsigned long long {
     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 {
+  auto data() const -> const basic_format_arg<Context>* {
     return named_info_.empty() ? data_.data() : data_.data() + 1;
   }
 

src/fmt/color.h

@@ -11,7 +11,7 @@
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
 enum class color : uint32_t {
   alice_blue = 0xF0F8FF,               // rgb(240,248,255)
@@ -203,7 +203,7 @@ struct rgb {
   uint8_t b;
 };
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 
 // color is a struct of either a rgb color or a terminal color.
 struct color_type {
@@ -225,8 +225,7 @@ struct color_type {
     uint32_t rgb_color;
   } value;
 };
-
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 
 /** A text style consisting of foreground and background colors and emphasis. */
 class text_style {
@@ -234,7 +233,7 @@ class text_style {
   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) {
+  FMT_CONSTEXPR auto operator|=(const text_style& rhs) -> text_style& {
     if (!set_foreground_color) {
       set_foreground_color = rhs.set_foreground_color;
       foreground_color = rhs.foreground_color;
@@ -258,29 +257,29 @@ class text_style {
     return *this;
   }
 
-  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
-                                            const text_style& rhs) {
+  friend FMT_CONSTEXPR auto operator|(text_style lhs, const text_style& rhs)
+      -> text_style {
     return lhs |= rhs;
   }
 
-  FMT_CONSTEXPR bool has_foreground() const noexcept {
+  FMT_CONSTEXPR auto has_foreground() const noexcept -> bool {
     return set_foreground_color;
   }
-  FMT_CONSTEXPR bool has_background() const noexcept {
+  FMT_CONSTEXPR auto has_background() const noexcept -> bool {
     return set_background_color;
   }
-  FMT_CONSTEXPR bool has_emphasis() const noexcept {
+  FMT_CONSTEXPR auto has_emphasis() const noexcept -> bool {
     return static_cast<uint8_t>(ems) != 0;
   }
-  FMT_CONSTEXPR detail::color_type get_foreground() const noexcept {
+  FMT_CONSTEXPR auto get_foreground() const noexcept -> detail::color_type {
     FMT_ASSERT(has_foreground(), "no foreground specified for this style");
     return foreground_color;
   }
-  FMT_CONSTEXPR detail::color_type get_background() const noexcept {
+  FMT_CONSTEXPR auto get_background() const noexcept -> detail::color_type {
     FMT_ASSERT(has_background(), "no background specified for this style");
     return background_color;
   }
-  FMT_CONSTEXPR emphasis get_emphasis() const noexcept {
+  FMT_CONSTEXPR auto get_emphasis() const noexcept -> emphasis {
     FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
     return ems;
   }
@@ -298,9 +297,11 @@ class text_style {
     }
   }
 
-  friend FMT_CONSTEXPR text_style fg(detail::color_type foreground) noexcept;
+  friend FMT_CONSTEXPR auto fg(detail::color_type foreground) noexcept
+      -> text_style;
 
-  friend FMT_CONSTEXPR text_style bg(detail::color_type background) noexcept;
+  friend FMT_CONSTEXPR auto bg(detail::color_type background) noexcept
+      -> text_style;
 
   detail::color_type foreground_color;
   detail::color_type background_color;
@@ -310,20 +311,23 @@ class text_style {
 };
 
 /** Creates a text style from the foreground (text) color. */
-FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) noexcept {
+FMT_CONSTEXPR inline auto fg(detail::color_type foreground) noexcept
+    -> text_style {
   return text_style(true, foreground);
 }
 
 /** Creates a text style from the background color. */
-FMT_CONSTEXPR inline text_style bg(detail::color_type background) noexcept {
+FMT_CONSTEXPR inline auto bg(detail::color_type background) noexcept
+    -> text_style {
   return text_style(false, background);
 }
 
-FMT_CONSTEXPR inline text_style operator|(emphasis lhs, emphasis rhs) noexcept {
+FMT_CONSTEXPR inline auto operator|(emphasis lhs, emphasis rhs) noexcept
+    -> text_style {
   return text_style(lhs) | rhs;
 }
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 
 template <typename Char> struct ansi_color_escape {
   FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
@@ -385,8 +389,8 @@ template <typename Char> struct ansi_color_escape {
   }
   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 {
+  FMT_CONSTEXPR auto begin() const noexcept -> const Char* { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS auto end() const noexcept -> const Char* {
     return buffer + std::char_traits<Char>::length(buffer);
   }
 
@@ -401,56 +405,39 @@ template <typename Char> struct ansi_color_escape {
     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 {
+  static FMT_CONSTEXPR auto has_emphasis(emphasis em, emphasis mask) noexcept
+      -> bool {
     return static_cast<uint8_t>(em) & static_cast<uint8_t>(mask);
   }
 };
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
-    detail::color_type foreground) noexcept {
+FMT_CONSTEXPR auto make_foreground_color(detail::color_type foreground) noexcept
+    -> ansi_color_escape<Char> {
   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 {
+FMT_CONSTEXPR auto make_background_color(detail::color_type background) noexcept
+    -> ansi_color_escape<Char> {
   return ansi_color_escape<Char>(background, "\x1b[48;2;");
 }
 
 template <typename Char>
-FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) noexcept {
+FMT_CONSTEXPR auto make_emphasis(emphasis em) noexcept
+    -> ansi_color_escape<Char> {
   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 {
+template <typename T> struct styled_arg : detail::view {
   const T& value;
   text_style style;
+  styled_arg(const T& v, text_style s) : value(v), style(s) {}
 };
 
 template <typename Char>
@@ -477,19 +464,21 @@ void vformat_to(buffer<Char>& buf, const text_style& ts,
   if (has_style) detail::reset_color<Char>(buf);
 }
 
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 
-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);
+inline void vprint(std::FILE* f, const text_style& ts, string_view fmt,
+                   format_args args) {
+  // Legacy wide streams are not supported.
+  auto buf = memory_buffer();
+  detail::vformat_to(buf, ts, fmt, 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);
+    detail::print(f, string_view(buf.begin(), buf.size()));
+    return;
   }
+  buf.push_back('\0');
+  int result = std::fputs(buf.data(), f);
+  if (result < 0)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
 /**
@@ -529,9 +518,10 @@ void print(const text_style& ts, const S& format_str, const Args&... args) {
 }
 
 template <typename S, typename Char = char_t<S>>
-inline std::basic_string<Char> vformat(
+inline auto vformat(
     const text_style& ts, const S& format_str,
-    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
   basic_memory_buffer<Char> buf;
   detail::vformat_to(buf, ts, detail::to_string_view(format_str), args);
   return fmt::to_string(buf);
@@ -550,8 +540,8 @@ inline std::basic_string<Char> vformat(
   \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) {
+inline auto format(const text_style& ts, const S& format_str,
+                   const Args&... args) -> std::basic_string<Char> {
   return fmt::vformat(ts, detail::to_string_view(format_str),
                       fmt::make_format_args<buffer_context<Char>>(args...));
 }
@@ -561,12 +551,13 @@ inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
  */
 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 vformat_to(OutputIt out, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
   detail::vformat_to(buf, ts, format_str, args);
-  return detail::get_iterator(buf);
+  return detail::get_iterator(buf, out);
 }
 
 /**
@@ -581,9 +572,10 @@ OutputIt vformat_to(
                    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>
+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 {
@@ -645,7 +637,7 @@ FMT_CONSTEXPR auto styled(const T& value, text_style ts)
   return detail::styled_arg<remove_cvref_t<T>>{value, ts};
 }
 
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_COLOR_H_

src/fmt/compile.h

@@ -14,89 +14,11 @@ FMT_BEGIN_NAMESPACE
 namespace detail {
 
 template <typename Char, typename InputIt>
-FMT_CONSTEXPR inline counting_iterator copy_str(InputIt begin, InputIt end,
-                                                counting_iterator it) {
+FMT_CONSTEXPR inline auto copy_str(InputIt begin, InputIt end,
+                                   counting_iterator it) -> counting_iterator {
   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 {};
 
@@ -135,7 +57,7 @@ struct udl_compiled_string : compiled_string {
 #endif
 
 template <typename T, typename... Tail>
-const T& first(const T& value, const Tail&...) {
+auto first(const T& value, const Tail&...) -> const T& {
   return value;
 }
 
@@ -196,7 +118,8 @@ template <typename Char> struct code_unit {
 
   template <typename OutputIt, typename... Args>
   constexpr OutputIt format(OutputIt out, const Args&...) const {
-    return write<Char>(out, value);
+    *out++ = value;
+    return out;
   }
 };
 
@@ -220,7 +143,12 @@ template <typename Char, typename T, int N> struct field {
 
   template <typename OutputIt, typename... Args>
   constexpr OutputIt format(OutputIt out, const Args&... args) const {
-    return write<Char>(out, get_arg_checked<T, N>(args...));
+    const T& arg = get_arg_checked<T, N>(args...);
+    if constexpr (std::is_convertible_v<T, basic_string_view<Char>>) {
+      auto s = basic_string_view<Char>(arg);
+      return copy_str<Char>(s.begin(), s.end(), out);
+    }
+    return write<Char>(out, arg);
   }
 };
 
@@ -331,14 +259,14 @@ template <typename T, typename Char> struct parse_specs_result {
   int next_arg_id;
 };
 
-constexpr int manual_indexing_id = -1;
+enum { manual_indexing_id = -1 };
 
 template <typename T, typename Char>
 constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
                                                   size_t pos, int next_arg_id) {
   str.remove_prefix(pos);
-  auto ctx = compile_parse_context<Char>(str, max_value<int>(), nullptr, {},
-                                         next_arg_id);
+  auto 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()),
@@ -348,22 +276,18 @@ constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
 template <typename Char> struct arg_id_handler {
   arg_ref<Char> arg_id;
 
-  constexpr int operator()() {
+  constexpr int on_auto() {
     FMT_ASSERT(false, "handler cannot be used with automatic indexing");
     return 0;
   }
-  constexpr int operator()(int id) {
+  constexpr int on_index(int id) {
     arg_id = arg_ref<Char>(id);
     return 0;
   }
-  constexpr int operator()(basic_string_view<Char> id) {
+  constexpr int on_name(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 {
@@ -452,20 +376,18 @@ constexpr auto compile_format_string(S 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) {
+        if constexpr (arg_index >= 0) {
           constexpr auto next_id =
               ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
           return parse_replacement_field_then_tail<
               decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
               arg_index, next_id>(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 (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
         }
       }
     }
@@ -501,7 +423,7 @@ constexpr auto compile(S format_str) {
 #endif  // defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 }  // namespace detail
 
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
 #if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction)
 
@@ -566,17 +488,19 @@ FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
 
 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()};
+auto format_to_n(OutputIt out, size_t n, const S& format_str, Args&&... args)
+    -> format_to_n_result<OutputIt> {
+  using traits = detail::fixed_buffer_traits;
+  auto buf = detail::iterator_buffer<OutputIt, char, traits>(out, n);
+  fmt::format_to(std::back_inserter(buf), format_str,
+                 std::forward<Args>(args)...);
+  return {buf.out(), buf.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) {
+FMT_CONSTEXPR20 auto formatted_size(const S& format_str, const Args&... args)
+    -> size_t {
   return fmt::format_to(detail::counting_iterator(), format_str, args...)
       .count();
 }
@@ -605,7 +529,7 @@ template <detail_exported::fixed_string Str> constexpr auto operator""_cf() {
 }  // namespace literals
 #endif
 
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_COMPILE_H_

src/fmt/format-inl.h

@@ -9,20 +9,16 @@
 #define FMT_FORMAT_INL_H_
 
 #include <algorithm>
-#include <cctype>
 #include <cerrno>  // errno
 #include <climits>
 #include <cmath>
-#include <cstdarg>
-#include <cstring>  // std::memmove
-#include <cwchar>
 #include <exception>
 
 #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
 #  include <locale>
 #endif
 
-#ifdef _WIN32
+#if defined(_WIN32) && !defined(FMT_WINDOWS_NO_WCHAR)
 #  include <io.h>  // _isatty
 #endif
 
@@ -62,8 +58,8 @@ FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
   error_code_size += detail::to_unsigned(detail::count_digits(abs_value));
   auto it = buffer_appender<char>(out);
   if (message.size() <= inline_buffer_size - error_code_size)
-    format_to(it, FMT_STRING("{}{}"), message, SEP);
-  format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
+    fmt::format_to(it, FMT_STRING("{}{}"), message, SEP);
+  fmt::format_to(it, FMT_STRING("{}{}"), ERROR_STR, error_code);
   FMT_ASSERT(out.size() <= inline_buffer_size, "");
 }
 
@@ -77,9 +73,8 @@ FMT_FUNC void report_error(format_func func, int error_code,
 }
 
 // A wrapper around fwrite that throws on error.
-inline void fwrite_fully(const void* ptr, size_t size, size_t count,
-                         FILE* stream) {
-  size_t written = std::fwrite(ptr, size, count, stream);
+inline void fwrite_fully(const void* ptr, size_t count, FILE* stream) {
+  size_t written = std::fwrite(ptr, 1, count, stream);
   if (written < count)
     FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
@@ -90,7 +85,7 @@ locale_ref::locale_ref(const Locale& loc) : locale_(&loc) {
   static_assert(std::is_same<Locale, std::locale>::value, "");
 }
 
-template <typename Locale> Locale locale_ref::get() const {
+template <typename Locale> auto locale_ref::get() const -> Locale {
   static_assert(std::is_same<Locale, std::locale>::value, "");
   return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
 }
@@ -102,7 +97,8 @@ FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
   auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
   return {std::move(grouping), thousands_sep};
 }
-template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref loc) {
+template <typename Char>
+FMT_FUNC auto decimal_point_impl(locale_ref loc) -> Char {
   return std::use_facet<std::numpunct<Char>>(loc.get<std::locale>())
       .decimal_point();
 }
@@ -115,96 +111,74 @@ template <typename Char> FMT_FUNC Char decimal_point_impl(locale_ref) {
   return '.';
 }
 #endif
+
+FMT_FUNC auto write_loc(appender out, loc_value value,
+                        const format_specs<>& specs, locale_ref loc) -> bool {
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+  auto locale = loc.get<std::locale>();
+  // We cannot use the num_put<char> facet because it may produce output in
+  // a wrong encoding.
+  using facet = format_facet<std::locale>;
+  if (std::has_facet<facet>(locale))
+    return std::use_facet<facet>(locale).put(out, value, specs);
+  return facet(locale).put(out, value, specs);
+#endif
+  return false;
+}
 }  // namespace detail
 
-#if !FMT_MSC_VERSION
-FMT_API FMT_FUNC format_error::~format_error() noexcept = default;
+template <typename Locale> typename Locale::id format_facet<Locale>::id;
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template <typename Locale> format_facet<Locale>::format_facet(Locale& loc) {
+  auto& numpunct = std::use_facet<std::numpunct<char>>(loc);
+  grouping_ = numpunct.grouping();
+  if (!grouping_.empty()) separator_ = std::string(1, numpunct.thousands_sep());
+}
+
+template <>
+FMT_API FMT_FUNC auto format_facet<std::locale>::do_put(
+    appender out, loc_value val, const format_specs<>& specs) const -> bool {
+  return val.visit(
+      detail::loc_writer<>{out, specs, separator_, grouping_, decimal_point_});
+}
 #endif
 
-FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
-                                         format_args args) {
+FMT_FUNC auto vsystem_error(int error_code, string_view fmt, format_args args)
+    -> std::system_error {
   auto ec = std::error_code(error_code, std::generic_category());
-  return std::system_error(ec, vformat(format_str, args));
+  return std::system_error(ec, vformat(fmt, args));
 }
 
 namespace detail {
 
-template <typename F> inline bool operator==(basic_fp<F> x, basic_fp<F> y) {
+template <typename F>
+inline auto operator==(basic_fp<F> x, basic_fp<F> y) -> bool {
   return x.f == y.f && x.e == y.e;
 }
 
 // Compilers should be able to optimize this into the ror instruction.
-FMT_CONSTEXPR inline uint32_t rotr(uint32_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint32_t n, uint32_t r) noexcept -> uint32_t {
   r &= 31;
   return (n >> r) | (n << (32 - r));
 }
-FMT_CONSTEXPR inline uint64_t rotr(uint64_t n, uint32_t r) noexcept {
+FMT_CONSTEXPR inline auto rotr(uint64_t n, uint32_t r) noexcept -> uint64_t {
   r &= 63;
   return (n >> r) | (n << (64 - r));
 }
 
-// Computes 128-bit result of multiplication of two 64-bit unsigned integers.
-inline uint128_fallback umul128(uint64_t x, uint64_t y) noexcept {
-#if FMT_USE_INT128
-  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
-  return {static_cast<uint64_t>(p >> 64), static_cast<uint64_t>(p)};
-#elif defined(_MSC_VER) && defined(_M_X64)
-  auto result = uint128_fallback();
-  result.lo_ = _umul128(x, y, &result.hi_);
-  return result;
-#else
-  const uint64_t mask = static_cast<uint64_t>(max_value<uint32_t>());
-
-  uint64_t a = x >> 32;
-  uint64_t b = x & mask;
-  uint64_t c = y >> 32;
-  uint64_t d = y & mask;
-
-  uint64_t ac = a * c;
-  uint64_t bc = b * c;
-  uint64_t ad = a * d;
-  uint64_t bd = b * d;
-
-  uint64_t intermediate = (bd >> 32) + (ad & mask) + (bc & mask);
-
-  return {ac + (intermediate >> 32) + (ad >> 32) + (bc >> 32),
-          (intermediate << 32) + (bd & mask)};
-#endif
-}
-
 // Implementation of Dragonbox algorithm: https://github.com/jk-jeon/dragonbox.
 namespace dragonbox {
-// Computes upper 64 bits of multiplication of two 64-bit unsigned integers.
-inline uint64_t umul128_upper64(uint64_t x, uint64_t y) noexcept {
-#if FMT_USE_INT128
-  auto p = static_cast<uint128_opt>(x) * static_cast<uint128_opt>(y);
-  return static_cast<uint64_t>(p >> 64);
-#elif defined(_MSC_VER) && defined(_M_X64)
-  return __umulh(x, y);
-#else
-  return umul128(x, y).high();
-#endif
-}
-
-// Computes upper 128 bits of multiplication of a 64-bit unsigned integer and a
-// 128-bit unsigned integer.
-inline uint128_fallback umul192_upper128(uint64_t x,
-                                         uint128_fallback y) noexcept {
-  uint128_fallback r = umul128(x, y.high());
-  r += umul128_upper64(x, y.low());
-  return r;
-}
-
 // Computes upper 64 bits of multiplication of a 32-bit unsigned integer and a
 // 64-bit unsigned integer.
-inline uint64_t umul96_upper64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_upper64(uint32_t x, uint64_t y) noexcept -> uint64_t {
   return umul128_upper64(static_cast<uint64_t>(x) << 32, y);
 }
 
 // Computes lower 128 bits of multiplication of a 64-bit unsigned integer and a
 // 128-bit unsigned integer.
-inline uint128_fallback umul192_lower128(uint64_t x,
-                                         uint128_fallback y) noexcept {
+inline auto umul192_lower128(uint64_t x, uint128_fallback y) noexcept
+    -> uint128_fallback {
   uint64_t high = x * y.high();
   uint128_fallback high_low = umul128(x, y.low());
   return {high + high_low.high(), high_low.low()};
@@ -212,29 +186,17 @@ inline uint128_fallback umul192_lower128(uint64_t x,
 
 // Computes lower 64 bits of multiplication of a 32-bit unsigned integer and a
 // 64-bit unsigned integer.
-inline uint64_t umul96_lower64(uint32_t x, uint64_t y) noexcept {
+inline auto umul96_lower64(uint32_t x, uint64_t y) noexcept -> uint64_t {
   return x * y;
 }
 
-// Computes floor(log10(pow(2, e))) for e in [-2620, 2620] using the method from
-// https://fmt.dev/papers/Dragonbox.pdf#page=28, section 6.1.
-inline int floor_log10_pow2(int e) noexcept {
-  FMT_ASSERT(e <= 2620 && e >= -2620, "too large exponent");
-  static_assert((-1 >> 1) == -1, "right shift is not arithmetic");
-  return (e * 315653) >> 20;
-}
-
 // Various fast log computations.
-inline int floor_log2_pow10(int e) noexcept {
-  FMT_ASSERT(e <= 1233 && e >= -1233, "too large exponent");
-  return (e * 1741647) >> 19;
-}
-inline int floor_log10_pow2_minus_log10_4_over_3(int e) noexcept {
+inline auto floor_log10_pow2_minus_log10_4_over_3(int e) noexcept -> int {
   FMT_ASSERT(e <= 2936 && e >= -2985, "too large exponent");
   return (e * 631305 - 261663) >> 21;
 }
 
-static constexpr struct {
+FMT_INLINE_VARIABLE constexpr struct {
   uint32_t divisor;
   int shift_amount;
 } div_small_pow10_infos[] = {{10, 16}, {100, 16}};
@@ -243,7 +205,7 @@ static constexpr struct {
 // divisible by pow(10, N).
 // Precondition: n <= pow(10, N + 1).
 template <int N>
-bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
+auto check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept -> bool {
   // The numbers below are chosen such that:
   //   1. floor(n/d) = floor(nm / 2^k) where d=10 or d=100,
   //   2. nm mod 2^k < m if and only if n is divisible by d,
@@ -268,7 +230,7 @@ bool check_divisibility_and_divide_by_pow10(uint32_t& n) noexcept {
 
 // Computes floor(n / pow(10, N)) for small n and N.
 // Precondition: n <= pow(10, N + 1).
-template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
+template <int N> auto small_division_by_pow10(uint32_t n) noexcept -> uint32_t {
   constexpr auto info = div_small_pow10_infos[N - 1];
   FMT_ASSERT(n <= info.divisor * 10, "n is too large");
   constexpr uint32_t magic_number =
@@ -277,24 +239,24 @@ template <int N> uint32_t small_division_by_pow10(uint32_t n) noexcept {
 }
 
 // Computes floor(n / 10^(kappa + 1)) (float)
-inline uint32_t divide_by_10_to_kappa_plus_1(uint32_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint32_t n) noexcept -> uint32_t {
   // 1374389535 = ceil(2^37/100)
   return static_cast<uint32_t>((static_cast<uint64_t>(n) * 1374389535) >> 37);
 }
 // Computes floor(n / 10^(kappa + 1)) (double)
-inline uint64_t divide_by_10_to_kappa_plus_1(uint64_t n) noexcept {
+inline auto divide_by_10_to_kappa_plus_1(uint64_t n) noexcept -> uint64_t {
   // 2361183241434822607 = ceil(2^(64+7)/1000)
   return umul128_upper64(n, 2361183241434822607ull) >> 7;
 }
 
 // Various subroutines using pow10 cache
-template <class T> struct cache_accessor;
+template <typename T> struct cache_accessor;
 
 template <> struct cache_accessor<float> {
   using carrier_uint = float_info<float>::carrier_uint;
   using cache_entry_type = uint64_t;
 
-  static uint64_t get_cached_power(int k) noexcept {
+  static auto get_cached_power(int k) noexcept -> uint64_t {
     FMT_ASSERT(k >= float_info<float>::min_k && k <= float_info<float>::max_k,
                "k is out of range");
     static constexpr const uint64_t pow10_significands[] = {
@@ -336,20 +298,23 @@ template <> struct cache_accessor<float> {
     bool is_integer;
   };
 
-  static compute_mul_result compute_mul(
-      carrier_uint u, const cache_entry_type& cache) noexcept {
+  static auto compute_mul(carrier_uint u,
+                          const cache_entry_type& cache) noexcept
+      -> compute_mul_result {
     auto r = umul96_upper64(u, cache);
     return {static_cast<carrier_uint>(r >> 32),
             static_cast<carrier_uint>(r) == 0};
   }
 
-  static uint32_t compute_delta(const cache_entry_type& cache,
-                                int beta) noexcept {
+  static auto compute_delta(const cache_entry_type& cache, int beta) noexcept
+      -> uint32_t {
     return static_cast<uint32_t>(cache >> (64 - 1 - beta));
   }
 
-  static compute_mul_parity_result compute_mul_parity(
-      carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_mul_parity(carrier_uint two_f,
+                                 const cache_entry_type& cache,
+                                 int beta) noexcept
+      -> compute_mul_parity_result {
     FMT_ASSERT(beta >= 1, "");
     FMT_ASSERT(beta < 64, "");
 
@@ -358,22 +323,22 @@ template <> struct cache_accessor<float> {
             static_cast<uint32_t>(r >> (32 - beta)) == 0};
   }
 
-  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return static_cast<carrier_uint>(
         (cache - (cache >> (num_significand_bits<float>() + 2))) >>
         (64 - num_significand_bits<float>() - 1 - beta));
   }
 
-  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return static_cast<carrier_uint>(
         (cache + (cache >> (num_significand_bits<float>() + 1))) >>
         (64 - num_significand_bits<float>() - 1 - beta));
   }
 
-  static carrier_uint compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (static_cast<carrier_uint>(
                 cache >> (64 - num_significand_bits<float>() - 2 - beta)) +
             1) /
@@ -385,7 +350,7 @@ template <> struct cache_accessor<double> {
   using carrier_uint = float_info<double>::carrier_uint;
   using cache_entry_type = uint128_fallback;
 
-  static uint128_fallback get_cached_power(int k) noexcept {
+  static auto get_cached_power(int k) noexcept -> uint128_fallback {
     FMT_ASSERT(k >= float_info<double>::min_k && k <= float_info<double>::max_k,
                "k is out of range");
 
@@ -1009,8 +974,22 @@ template <> struct cache_accessor<double> {
       {0xfcf62c1dee382c42, 0x46729e03dd9ed7b6},
       {0x9e19db92b4e31ba9, 0x6c07a2c26a8346d2},
       {0xc5a05277621be293, 0xc7098b7305241886},
-      { 0xf70867153aa2db38,
-        0xb8cbee4fc66d1ea8 }
+      {0xf70867153aa2db38, 0xb8cbee4fc66d1ea8},
+      {0x9a65406d44a5c903, 0x737f74f1dc043329},
+      {0xc0fe908895cf3b44, 0x505f522e53053ff3},
+      {0xf13e34aabb430a15, 0x647726b9e7c68ff0},
+      {0x96c6e0eab509e64d, 0x5eca783430dc19f6},
+      {0xbc789925624c5fe0, 0xb67d16413d132073},
+      {0xeb96bf6ebadf77d8, 0xe41c5bd18c57e890},
+      {0x933e37a534cbaae7, 0x8e91b962f7b6f15a},
+      {0xb80dc58e81fe95a1, 0x723627bbb5a4adb1},
+      {0xe61136f2227e3b09, 0xcec3b1aaa30dd91d},
+      {0x8fcac257558ee4e6, 0x213a4f0aa5e8a7b2},
+      {0xb3bd72ed2af29e1f, 0xa988e2cd4f62d19e},
+      {0xe0accfa875af45a7, 0x93eb1b80a33b8606},
+      {0x8c6c01c9498d8b88, 0xbc72f130660533c4},
+      {0xaf87023b9bf0ee6a, 0xeb8fad7c7f8680b5},
+      {0xdb68c2ca82ed2a05, 0xa67398db9f6820e2},
 #else
       {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b},
       {0xce5d73ff402d98e3, 0xfb0a3d212dc81290},
@@ -1034,8 +1013,8 @@ template <> struct cache_accessor<double> {
       {0x8da471a9de737e24, 0x5ceaecfed289e5d3},
       {0xe4d5e82392a40515, 0x0fabaf3feaa5334b},
       {0xb8da1662e7b00a17, 0x3d6a751f3b936244},
-      { 0x95527a5202df0ccb,
-        0x0f37801e0c43ebc9 }
+      {0x95527a5202df0ccb, 0x0f37801e0c43ebc9},
+      {0xf13e34aabb430a15, 0x647726b9e7c68ff0}
 #endif
     };
 
@@ -1095,19 +1074,22 @@ template <> struct cache_accessor<double> {
     bool is_integer;
   };
 
-  static compute_mul_result compute_mul(
-      carrier_uint u, const cache_entry_type& cache) noexcept {
+  static auto compute_mul(carrier_uint u,
+                          const cache_entry_type& cache) noexcept
+      -> compute_mul_result {
     auto r = umul192_upper128(u, cache);
     return {r.high(), r.low() == 0};
   }
 
-  static uint32_t compute_delta(cache_entry_type const& cache,
-                                int beta) noexcept {
+  static auto compute_delta(cache_entry_type const& cache, int beta) noexcept
+      -> uint32_t {
     return static_cast<uint32_t>(cache.high() >> (64 - 1 - beta));
   }
 
-  static compute_mul_parity_result compute_mul_parity(
-      carrier_uint two_f, const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_mul_parity(carrier_uint two_f,
+                                 const cache_entry_type& cache,
+                                 int beta) noexcept
+      -> compute_mul_parity_result {
     FMT_ASSERT(beta >= 1, "");
     FMT_ASSERT(beta < 64, "");
 
@@ -1116,31 +1098,35 @@ template <> struct cache_accessor<double> {
             ((r.high() << beta) | (r.low() >> (64 - beta))) == 0};
   }
 
-  static carrier_uint compute_left_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_left_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (cache.high() -
             (cache.high() >> (num_significand_bits<double>() + 2))) >>
            (64 - num_significand_bits<double>() - 1 - beta);
   }
 
-  static carrier_uint compute_right_endpoint_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_right_endpoint_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return (cache.high() +
             (cache.high() >> (num_significand_bits<double>() + 1))) >>
            (64 - num_significand_bits<double>() - 1 - beta);
   }
 
-  static carrier_uint compute_round_up_for_shorter_interval_case(
-      const cache_entry_type& cache, int beta) noexcept {
+  static auto compute_round_up_for_shorter_interval_case(
+      const cache_entry_type& cache, int beta) noexcept -> carrier_uint {
     return ((cache.high() >> (64 - num_significand_bits<double>() - 2 - beta)) +
             1) /
            2;
   }
 };
 
+FMT_FUNC auto get_cached_power(int k) noexcept -> uint128_fallback {
+  return cache_accessor<double>::get_cached_power(k);
+}
+
 // Various integer checks
-template <class T>
-bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
+template <typename T>
+auto is_left_endpoint_integer_shorter_interval(int exponent) noexcept -> bool {
   const int case_shorter_interval_left_endpoint_lower_threshold = 2;
   const int case_shorter_interval_left_endpoint_upper_threshold = 3;
   return exponent >= case_shorter_interval_left_endpoint_lower_threshold &&
@@ -1148,12 +1134,12 @@ bool is_left_endpoint_integer_shorter_interval(int exponent) noexcept {
 }
 
 // Remove trailing zeros from n and return the number of zeros removed (float)
-FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
+FMT_INLINE int remove_trailing_zeros(uint32_t& n, int s = 0) noexcept {
   FMT_ASSERT(n != 0, "");
-  const uint32_t mod_inv_5 = 0xcccccccd;
-  const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+  // Modular inverse of 5 (mod 2^32): (mod_inv_5 * 5) mod 2^32 = 1.
+  constexpr uint32_t mod_inv_5 = 0xcccccccd;
+  constexpr uint32_t mod_inv_25 = 0xc28f5c29;  // = mod_inv_5 * mod_inv_5
 
-  int s = 0;
   while (true) {
     auto q = rotr(n * mod_inv_25, 2);
     if (q > max_value<uint32_t>() / 100) break;
@@ -1165,7 +1151,6 @@ FMT_INLINE int remove_trailing_zeros(uint32_t& n) noexcept {
     n = q;
     s |= 1;
   }
-
   return s;
 }
 
@@ -1179,32 +1164,17 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
 
   // Is n is divisible by 10^8?
   if ((nm.high() & ((1ull << (90 - 64)) - 1)) == 0 && nm.low() < magic_number) {
-    // If yes, work with the quotient.
+    // If yes, work with the quotient...
     auto n32 = static_cast<uint32_t>(nm.high() >> (90 - 64));
-
-    const uint32_t mod_inv_5 = 0xcccccccd;
-    const uint32_t mod_inv_25 = mod_inv_5 * mod_inv_5;
-
-    int s = 8;
-    while (true) {
-      auto q = rotr(n32 * mod_inv_25, 2);
-      if (q > max_value<uint32_t>() / 100) break;
-      n32 = q;
-      s += 2;
-    }
-    auto q = rotr(n32 * mod_inv_5, 1);
-    if (q <= max_value<uint32_t>() / 10) {
-      n32 = q;
-      s |= 1;
-    }
-
+    // ... and use the 32 bit variant of the function
+    int s = remove_trailing_zeros(n32, 8);
     n = n32;
     return s;
   }
 
   // If n is not divisible by 10^8, work with n itself.
-  const uint64_t mod_inv_5 = 0xcccccccccccccccd;
-  const uint64_t mod_inv_25 = mod_inv_5 * mod_inv_5;
+  constexpr uint64_t mod_inv_5 = 0xcccccccccccccccd;
+  constexpr uint64_t mod_inv_25 = 0x8f5c28f5c28f5c29;  // mod_inv_5 * mod_inv_5
 
   int s = 0;
   while (true) {
@@ -1223,7 +1193,7 @@ FMT_INLINE int remove_trailing_zeros(uint64_t& n) noexcept {
 }
 
 // The main algorithm for shorter interval case
-template <class T>
+template <typename T>
 FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
   decimal_fp<T> ret_value;
   // Compute k and beta
@@ -1270,7 +1240,7 @@ FMT_INLINE decimal_fp<T> shorter_interval_case(int exponent) noexcept {
   return ret_value;
 }
 
-template <typename T> decimal_fp<T> to_decimal(T x) noexcept {
+template <typename T> auto to_decimal(T x) noexcept -> decimal_fp<T> {
   // Step 1: integer promotion & Schubfach multiplier calculation.
 
   using carrier_uint = typename float_info<T>::carrier_uint;
@@ -1394,17 +1364,6 @@ small_divisor_case_label:
   return ret_value;
 }
 }  // namespace dragonbox
-
-#ifdef _MSC_VER
-FMT_FUNC auto fmt_snprintf(char* buf, size_t size, const char* fmt, ...)
-    -> int {
-  auto args = va_list();
-  va_start(args, fmt);
-  int result = vsnprintf_s(buf, size, _TRUNCATE, fmt, args);
-  va_end(args);
-  return result;
-}
-#endif
 }  // namespace detail
 
 template <> struct formatter<detail::bigint> {
@@ -1413,23 +1372,22 @@ template <> struct formatter<detail::bigint> {
     return ctx.begin();
   }
 
-  template <typename FormatContext>
-  auto format(const detail::bigint& n, FormatContext& ctx) const ->
-      typename FormatContext::iterator {
+  auto format(const detail::bigint& n, format_context& ctx) const
+      -> format_context::iterator {
     auto out = ctx.out();
     bool first = true;
     for (auto i = n.bigits_.size(); i > 0; --i) {
       auto value = n.bigits_[i - 1u];
       if (first) {
-        out = format_to(out, FMT_STRING("{:x}"), value);
+        out = fmt::format_to(out, FMT_STRING("{:x}"), value);
         first = false;
         continue;
       }
-      out = format_to(out, FMT_STRING("{:08x}"), value);
+      out = fmt::format_to(out, FMT_STRING("{:08x}"), value);
     }
     if (n.exp_ > 0)
-      out = format_to(out, FMT_STRING("p{}"),
-                      n.exp_ * detail::bigint::bigit_bits);
+      out = fmt::format_to(out, FMT_STRING("p{}"),
+                           n.exp_ * detail::bigint::bigit_bits);
     return out;
   }
 };
@@ -1465,7 +1423,7 @@ FMT_FUNC void report_system_error(int error_code,
   report_error(format_system_error, error_code, message);
 }
 
-FMT_FUNC std::string vformat(string_view fmt, format_args args) {
+FMT_FUNC auto vformat(string_view fmt, format_args args) -> std::string {
   // Don't optimize the "{}" case to keep the binary size small and because it
   // can be better optimized in fmt::format anyway.
   auto buffer = memory_buffer();
@@ -1474,57 +1432,54 @@ FMT_FUNC std::string vformat(string_view fmt, format_args args) {
 }
 
 namespace detail {
-#ifdef _WIN32
+#if !defined(_WIN32) || defined(FMT_WINDOWS_NO_WCHAR)
+FMT_FUNC auto write_console(int, string_view) -> bool { return false; }
+FMT_FUNC auto write_console(std::FILE*, string_view) -> bool { return false; }
+#else
 using dword = conditional_t<sizeof(long) == 4, unsigned long, unsigned>;
 extern "C" __declspec(dllimport) int __stdcall WriteConsoleW(  //
     void*, const void*, dword, dword*, void*);
 
-FMT_FUNC bool write_console(std::FILE* f, string_view text) {
-  auto fd = _fileno(f);
-  if (_isatty(fd)) {
-    detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
-    auto written = detail::dword();
-    if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
-                              u16.c_str(), static_cast<uint32_t>(u16.size()),
-                              &written, nullptr)) {
-      return true;
-    }
-  }
-  // We return false if the file descriptor was not TTY, or it was but
-  // SetConsoleW failed which can happen if the output has been redirected to
-  // NUL. In both cases when we return false, we should attempt to do regular
-  // write via fwrite or std::ostream::write.
-  return false;
+FMT_FUNC bool write_console(int fd, string_view text) {
+  auto u16 = utf8_to_utf16(text);
+  return WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)), u16.c_str(),
+                       static_cast<dword>(u16.size()), nullptr, nullptr) != 0;
+}
+
+FMT_FUNC auto write_console(std::FILE* f, string_view text) -> bool {
+  return write_console(_fileno(f), text);
+}
+#endif
+
+#ifdef _WIN32
+// Print assuming legacy (non-Unicode) encoding.
+FMT_FUNC void vprint_mojibake(std::FILE* f, string_view fmt, format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
+  fwrite_fully(buffer.data(), buffer.size(), f);
 }
 #endif
 
 FMT_FUNC void print(std::FILE* f, string_view text) {
 #ifdef _WIN32
-  if (write_console(f, text)) return;
+  int fd = _fileno(f);
+  if (_isatty(fd)) {
+    std::fflush(f);
+    if (write_console(fd, text)) return;
+  }
 #endif
-  detail::fwrite_fully(text.data(), 1, text.size(), f);
+  fwrite_fully(text.data(), text.size(), f);
 }
 }  // namespace detail
 
-FMT_FUNC void vprint(std::FILE* f, string_view format_str, format_args args) {
-  memory_buffer buffer;
-  detail::vformat_to(buffer, format_str, args);
+FMT_FUNC void vprint(std::FILE* f, string_view fmt, format_args args) {
+  auto buffer = memory_buffer();
+  detail::vformat_to(buffer, fmt, args);
   detail::print(f, {buffer.data(), buffer.size()});
 }
 
-#ifdef _WIN32
-// Print assuming legacy (non-Unicode) encoding.
-FMT_FUNC void detail::vprint_mojibake(std::FILE* f, string_view format_str,
-                                      format_args args) {
-  memory_buffer buffer;
-  detail::vformat_to(buffer, format_str,
-                     basic_format_args<buffer_context<char>>(args));
-  fwrite_fully(buffer.data(), 1, buffer.size(), f);
-}
-#endif
-
-FMT_FUNC void vprint(string_view format_str, format_args args) {
-  vprint(stdout, format_str, args);
+FMT_FUNC void vprint(string_view fmt, format_args args) {
+  vprint(stdout, fmt, args);
 }
 
 namespace detail {

src/fmt/os.h

@@ -13,12 +13,14 @@
 #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"
 
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  if FMT_HAS_INCLUDE(<xlocale.h>)
+#    include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#  endif
+#endif
+
 #ifndef FMT_USE_FCNTL
 // UWP doesn't provide _pipe.
 #  if FMT_HAS_INCLUDE("winapifamily.h")
@@ -46,6 +48,7 @@
 
 // Calls to system functions are wrapped in FMT_SYSTEM for testability.
 #ifdef FMT_SYSTEM
+#  define FMT_HAS_SYSTEM
 #  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
 #else
 #  define FMT_SYSTEM(call) ::call
@@ -71,7 +74,7 @@
 #define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
 
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
 /**
   \rst
@@ -114,57 +117,19 @@ template <typename Char> class basic_cstring_view {
   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_; }
+  auto c_str() const -> const Char* { 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);
-};
-
+namespace detail {
 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);
@@ -207,7 +172,7 @@ std::system_error windows_error(int error_code, string_view message,
 // 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 {
+inline auto system_category() noexcept -> const std::error_category& {
   return std::system_category();
 }
 #endif  // _WIN32
@@ -244,7 +209,7 @@ class buffered_file {
     other.file_ = nullptr;
   }
 
-  buffered_file& operator=(buffered_file&& other) {
+  auto operator=(buffered_file&& other) -> buffered_file& {
     close();
     file_ = other.file_;
     other.file_ = nullptr;
@@ -258,9 +223,9 @@ class buffered_file {
   FMT_API void close();
 
   // Returns the pointer to a FILE object representing this file.
-  FILE* get() const noexcept { return file_; }
+  auto get() const noexcept -> FILE* { return file_; }
 
-  FMT_API int descriptor() const;
+  FMT_API auto descriptor() const -> int;
 
   void vprint(string_view format_str, format_args args) {
     fmt::vprint(file_, format_str, args);
@@ -310,7 +275,7 @@ class FMT_API file {
   file(file&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
 
   // Move assignment is not noexcept because close may throw.
-  file& operator=(file&& other) {
+  auto operator=(file&& other) -> file& {
     close();
     fd_ = other.fd_;
     other.fd_ = -1;
@@ -321,24 +286,24 @@ class FMT_API file {
   ~file() noexcept;
 
   // Returns the file descriptor.
-  int descriptor() const noexcept { return fd_; }
+  auto descriptor() const noexcept -> int { return fd_; }
 
   // Closes the file.
   void close();
 
   // Returns the file size. The size has signed type for consistency with
   // stat::st_size.
-  long long size() const;
+  auto size() const -> long long;
 
   // Attempts to read count bytes from the file into the specified buffer.
-  size_t read(void* buffer, size_t count);
+  auto read(void* buffer, size_t count) -> size_t;
 
   // Attempts to write count bytes from the specified buffer to the file.
-  size_t write(const void* buffer, size_t count);
+  auto write(const void* buffer, size_t count) -> size_t;
 
   // Duplicates a file descriptor with the dup function and returns
   // the duplicate as a file object.
-  static file dup(int fd);
+  static auto dup(int fd) -> file;
 
   // Makes fd be the copy of this file descriptor, closing fd first if
   // necessary.
@@ -350,22 +315,29 @@ class FMT_API file {
 
   // Creates a pipe setting up read_end and write_end file objects for reading
   // and writing respectively.
+  // DEPRECATED! Taking files as out parameters is deprecated.
   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);
+  auto fdopen(const char* mode) -> buffered_file;
+
+#  if defined(_WIN32) && !defined(__MINGW32__)
+  // Opens a file and constructs a file object representing this file by
+  // wcstring_view filename. Windows only.
+  static file open_windows_file(wcstring_view path, int oflag);
+#  endif
 };
 
 // Returns the memory page size.
-long getpagesize();
+auto getpagesize() -> long;
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 
 struct buffer_size {
   buffer_size() = default;
   size_t value = 0;
-  buffer_size operator=(size_t val) const {
+  auto operator=(size_t val) const -> buffer_size {
     auto bs = buffer_size();
     bs.value = val;
     return bs;
@@ -397,56 +369,61 @@ struct ostream_params {
 #  endif
 };
 
-FMT_END_DETAIL_NAMESPACE
+class file_buffer final : public buffer<char> {
+  file file_;
+
+  FMT_API void grow(size_t) override;
+
+ public:
+  FMT_API file_buffer(cstring_view path, const ostream_params& params);
+  FMT_API file_buffer(file_buffer&& other);
+  FMT_API ~file_buffer();
+
+  void flush() {
+    if (size() == 0) return;
+    file_.write(data(), size() * sizeof(data()[0]));
+    clear();
+  }
+
+  void close() {
+    flush();
+    file_.close();
+  }
+};
+
+}  // namespace detail
 
 // 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> {
+class FMT_API ostream {
  private:
-  file file_;
-
-  void grow(size_t) override;
+  FMT_MSC_WARNING(suppress : 4251)
+  detail::file_buffer buffer_;
 
   ostream(cstring_view path, const detail::ostream_params& params)
-      : file_(path, params.oflag) {
-    set(new char[params.buffer_size], params.buffer_size);
-  }
+      : buffer_(path, params) {}
 
  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();
-  }
+  ostream(ostream&& other) : buffer_(std::move(other.buffer_)) {}
 
-  void flush() {
-    if (size() == 0) return;
-    file_.write(data(), size());
-    clear();
-  }
+  ~ostream();
+
+  void flush() { buffer_.flush(); }
 
   template <typename... T>
-  friend ostream output_file(cstring_view path, T... params);
+  friend auto output_file(cstring_view path, T... params) -> ostream;
 
-  void close() {
-    flush();
-    file_.close();
-  }
+  void close() { buffer_.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,
+    vformat_to(std::back_inserter(buffer_), fmt,
                fmt::make_format_args(args...));
   }
 };
@@ -467,12 +444,12 @@ class FMT_API ostream final : private detail::buffer<char> {
   \endrst
  */
 template <typename... T>
-inline ostream output_file(cstring_view path, T... params) {
+inline auto output_file(cstring_view path, T... params) -> ostream {
   return {path, detail::ostream_params(params...)};
 }
 #endif  // FMT_USE_FCNTL
 
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_OS_H_

src/fmt/ostream.h

@@ -8,61 +8,58 @@
 #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>
+#include <fstream>  // std::filebuf
+
+#ifdef _WIN32
+#  ifdef __GLIBCXX__
+#    include <ext/stdio_filebuf.h>
+#    include <ext/stdio_sync_filebuf.h>
+#  endif
+#  include <io.h>
 #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 {
+template <typename Streambuf> class formatbuf : public Streambuf {
  private:
-  template <typename U>
-  static auto test(int)
-      -> bool_constant<sizeof(std::declval<std::basic_ostream<Char>&>()
-                              << std::declval<U>()) != 0>;
+  using char_type = typename Streambuf::char_type;
+  using streamsize = decltype(std::declval<Streambuf>().sputn(nullptr, 0));
+  using int_type = typename Streambuf::int_type;
+  using traits_type = typename Streambuf::traits_type;
 
-  template <typename> static auto test(...) -> std::false_type;
-
-  using result = decltype(test<T>(0));
+  buffer<char_type>& buffer_;
 
  public:
-  is_streamable() = default;
+  explicit formatbuf(buffer<char_type>& buf) : buffer_(buf) {}
 
-  static const bool value = result::value;
+ protected:
+  // The put area is always empty. This makes the implementation simpler and has
+  // the advantage that the streambuf and the buffer are always in sync and
+  // sputc never writes into uninitialized memory. A disadvantage is that each
+  // call to sputc always results in a (virtual) call to overflow. There is no
+  // disadvantage here for sputn since this always results in a call to xsputn.
+
+  auto overflow(int_type ch) -> int_type override {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<char_type>(ch));
+    return ch;
+  }
+
+  auto xsputn(const char_type* s, streamsize count) -> streamsize override {
+    buffer_.append(s, s + count);
+    return count;
+  }
 };
 
-// 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>
+template <typename Tag, typename BufType, FILE* BufType::*FileMemberPtr>
 class file_access {
   friend auto get_file(BufType& obj) -> FILE* { return obj.*FileMemberPtr; }
 };
@@ -71,36 +68,40 @@ class file_access {
 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) {
+inline auto write_ostream_unicode(std::ostream& os, fmt::string_view data)
+    -> bool {
+  FILE* f = nullptr;
 #if FMT_MSC_VERSION
   if (auto* buf = dynamic_cast<std::filebuf*>(os.rdbuf()))
-    if (FILE* f = get_file(*buf)) return write_console(f, data);
+    f = get_file(*buf);
+  else
+    return false;
 #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();
+  if (auto* sfbuf = dynamic_cast<__gnu_cxx::stdio_sync_filebuf<char>*>(rdbuf))
+    f = sfbuf->file();
   else if (auto* fbuf = dynamic_cast<__gnu_cxx::stdio_filebuf<char>*>(rdbuf))
-    c_file = fbuf->file();
+    f = 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);
+  ignore_unused(os, data, f);
+#endif
+#ifdef _WIN32
+  if (f) {
+    int fd = _fileno(f);
+    if (_isatty(fd)) {
+      os.flush();
+      return write_console(fd, data);
+    }
+  }
 #endif
   return false;
 }
-inline bool write_ostream_unicode(std::wostream&,
-                                  fmt::basic_string_view<wchar_t>) {
+inline auto write_ostream_unicode(std::wostream&,
+                                  fmt::basic_string_view<wchar_t>) -> bool {
   return false;
 }
 
@@ -121,18 +122,19 @@ void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
 }
 
 template <typename Char, typename T>
-void format_value(buffer<Char>& buf, const T& value,
-                  locale_ref loc = locale_ref()) {
+void format_value(buffer<Char>& buf, const T& value) {
   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>());
+  output.imbue(std::locale::classic());  // The default is always unlocalized.
 #endif
   output << value;
   output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
 }
 
-template <typename T> struct streamed_view { const T& value; };
+template <typename T> struct streamed_view {
+  const T& value;
+};
 
 }  // namespace detail
 
@@ -145,7 +147,7 @@ struct basic_ostream_formatter : formatter<basic_string_view<Char>, Char> {
   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());
+    detail::format_value(buffer, value);
     return formatter<basic_string_view<Char>, Char>::format(
         {buffer.data(), buffer.size()}, ctx);
   }
@@ -174,19 +176,12 @@ struct formatter<detail::streamed_view<T>, Char>
   \endrst
  */
 template <typename T>
-auto streamed(const T& value) -> detail::streamed_view<T> {
+constexpr 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();
@@ -196,7 +191,7 @@ inline void vprint_directly(std::ostream& os, string_view format_str,
 
 }  // namespace detail
 
-FMT_MODULE_EXPORT template <typename Char>
+FMT_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) {
@@ -215,7 +210,7 @@ void vprint(std::basic_ostream<Char>& os,
     fmt::print(cerr, "Don't {}!", "panic");
   \endrst
  */
-FMT_MODULE_EXPORT template <typename... T>
+FMT_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())
@@ -224,7 +219,7 @@ void print(std::ostream& os, format_string<T...> fmt, T&&... args) {
     detail::vprint_directly(os, fmt, vargs);
 }
 
-FMT_MODULE_EXPORT
+FMT_EXPORT
 template <typename... Args>
 void print(std::wostream& os,
            basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
@@ -232,6 +227,19 @@ void print(std::wostream& os,
   vprint(os, fmt, fmt::make_format_args<buffer_context<wchar_t>>(args...));
 }
 
+FMT_EXPORT template <typename... T>
+void println(std::ostream& os, format_string<T...> fmt, T&&... args) {
+  fmt::print(os, "{}\n", fmt::format(fmt, std::forward<T>(args)...));
+}
+
+FMT_EXPORT
+template <typename... Args>
+void println(std::wostream& os,
+             basic_format_string<wchar_t, type_identity_t<Args>...> fmt,
+             Args&&... args) {
+  print(os, L"{}\n", fmt::format(fmt, std::forward<Args>(args)...));
+}
+
 FMT_END_NAMESPACE
 
 #endif  // FMT_OSTREAM_H_

src/fmt/printf.h

@@ -14,24 +14,24 @@
 #include "format.h"
 
 FMT_BEGIN_NAMESPACE
-FMT_MODULE_EXPORT_BEGIN
+FMT_BEGIN_EXPORT
 
-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 T> struct printf_formatter {
+  printf_formatter() = delete;
 };
 
-template <typename OutputIt, typename Char> class basic_printf_context {
+template <typename Char> class basic_printf_context {
  private:
-  OutputIt out_;
+  detail::buffer_appender<Char> out_;
   basic_format_args<basic_printf_context> args_;
 
+  static_assert(std::is_same<Char, char>::value ||
+                    std::is_same<Char, wchar_t>::value,
+                "Unsupported code unit type.");
+
  public:
   using char_type = Char;
-  using format_arg = basic_format_arg<basic_printf_context>;
-  using parse_context_type = basic_printf_parse_context<Char>;
+  using parse_context_type = basic_format_parse_context<Char>;
   template <typename T> using formatter_type = printf_formatter<T>;
 
   /**
@@ -40,75 +40,77 @@ template <typename OutputIt, typename Char> class basic_printf_context {
     stored in the context object so make sure they have appropriate lifetimes.
     \endrst
    */
-  basic_printf_context(OutputIt out,
+  basic_printf_context(detail::buffer_appender<Char> out,
                        basic_format_args<basic_printf_context> args)
       : out_(out), args_(args) {}
 
-  OutputIt out() { return out_; }
-  void advance_to(OutputIt it) { out_ = it; }
+  auto out() -> detail::buffer_appender<Char> { return out_; }
+  void advance_to(detail::buffer_appender<Char>) {}
 
-  detail::locale_ref locale() { return {}; }
+  auto locale() -> detail::locale_ref { return {}; }
 
-  format_arg arg(int id) const { return args_.get(id); }
+  auto arg(int id) const -> basic_format_arg<basic_printf_context> {
+    return args_.get(id);
+  }
 
   FMT_CONSTEXPR void on_error(const char* message) {
     detail::error_handler().on_error(message);
   }
 };
 
-FMT_BEGIN_DETAIL_NAMESPACE
+namespace detail {
 
 // 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) {
+  template <typename T> static auto fits_in_int(T value) -> bool {
     unsigned max = max_value<int>();
     return value <= max;
   }
-  static bool fits_in_int(bool) { return true; }
+  static auto fits_in_int(bool) -> bool { return true; }
 };
 
 template <> struct int_checker<true> {
-  template <typename T> static bool fits_in_int(T value) {
+  template <typename T> static auto fits_in_int(T value) -> bool {
     return value >= (std::numeric_limits<int>::min)() &&
            value <= max_value<int>();
   }
-  static bool fits_in_int(int) { return true; }
+  static auto fits_in_int(int) -> bool { return true; }
 };
 
-class printf_precision_handler {
- public:
+struct printf_precision_handler {
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  int operator()(T value) {
+  auto operator()(T value) -> int {
     if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
-      FMT_THROW(format_error("number is too big"));
+      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"));
+  auto operator()(T) -> int {
+    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:
+struct is_zero_int {
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  bool operator()(T value) {
+  auto operator()(T value) -> bool {
     return value == 0;
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
-  bool operator()(T) {
+  auto operator()(T) -> bool {
     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 <> struct make_unsigned_or_bool<bool> {
+  using type = bool;
+};
 
 template <typename T, typename Context> class arg_converter {
  private:
@@ -132,22 +134,23 @@ template <typename T, typename Context> class arg_converter {
     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)));
+        auto n = static_cast<int>(static_cast<target_type>(value));
+        arg_ = detail::make_arg<Context>(n);
       } 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)));
+        auto n = static_cast<unsigned>(static_cast<unsigned_type>(value));
+        arg_ = detail::make_arg<Context>(n);
       }
     } 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));
+        auto n = static_cast<long long>(value);
+        arg_ = detail::make_arg<Context>(n);
       } else {
-        arg_ = detail::make_arg<Context>(
-            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+        auto n = static_cast<typename make_unsigned_or_bool<U>::type>(value);
+        arg_ = detail::make_arg<Context>(n);
       }
     }
   }
@@ -175,8 +178,8 @@ template <typename Context> class char_converter {
 
   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));
+    auto c = static_cast<typename Context::char_type>(value);
+    arg_ = detail::make_arg<Context>(c);
   }
 
   template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
@@ -186,122 +189,131 @@ template <typename Context> class char_converter {
 // 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; }
+  template <typename T> auto operator()(T) -> const Char* { return nullptr; }
+  auto operator()(const Char* s) -> const Char* { 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_;
+  format_specs<Char>& specs_;
 
  public:
-  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+  explicit printf_width_handler(format_specs<Char>& specs) : specs_(specs) {}
 
   template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
-  unsigned operator()(T value) {
+  auto operator()(T value) -> unsigned {
     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"));
+    if (width > int_max) 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"));
+  auto operator()(T) -> unsigned {
+    throw_format_error("width is not integer");
     return 0;
   }
 };
 
+// Workaround for a bug with the XL compiler when initializing
+// printf_arg_formatter's base class.
+template <typename Char>
+auto make_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s)
+    -> arg_formatter<Char> {
+  return {iter, s, locale_ref()};
+}
+
 // The ``printf`` argument formatter.
-template <typename OutputIt, typename Char>
+template <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>;
+  using context_type = basic_printf_context<Char>;
 
   context_type& context_;
 
-  OutputIt write_null_pointer(bool is_string = false) {
+  void 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);
+    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) {}
+  printf_arg_formatter(buffer_appender<Char> iter, format_specs<Char>& s,
+                       context_type& ctx)
+      : base(make_arg_formatter(iter, s)), context_(ctx) {}
 
-  OutputIt operator()(monostate value) { return base::operator()(value); }
+  void operator()(monostate value) { base::operator()(value); }
 
   template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
-  OutputIt operator()(T value) {
+  void 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);
+    if (!std::is_same<T, Char>::value) {
+      base::operator()(value);
+      return;
     }
-    return base::operator()(value);
+    format_specs<Char> 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;
+    write<Char>(this->out, static_cast<Char>(value), fmt_specs);
   }
 
   template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
-  OutputIt operator()(T value) {
-    return base::operator()(value);
+  void operator()(T value) {
+    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);
+  void operator()(const char* value) {
+    if (value)
+      base::operator()(value);
+    else
+      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);
+  void operator()(const wchar_t* value) {
+    if (value)
+      base::operator()(value);
+    else
+      write_null_pointer(this->specs.type != presentation_type::pointer);
   }
 
-  OutputIt operator()(basic_string_view<Char> value) {
-    return base::operator()(value);
-  }
+  void operator()(basic_string_view<Char> value) { base::operator()(value); }
 
   /** Formats a pointer. */
-  OutputIt operator()(const void* value) {
-    return value ? base::operator()(value) : write_null_pointer();
+  void operator()(const void* value) {
+    if (value)
+      base::operator()(value);
+    else
+      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>());
+  void operator()(typename basic_format_arg<context_type>::handle handle) {
+    auto parse_ctx = basic_format_parse_context<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) {
+void parse_flags(format_specs<Char>& specs, const Char*& it, const Char* end) {
   for (; it != end; ++it) {
     switch (*it) {
     case '-':
@@ -314,9 +326,7 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
       specs.fill[0] = '0';
       break;
     case ' ':
-      if (specs.sign != sign::plus) {
-        specs.sign = sign::space;
-      }
+      if (specs.sign != sign::plus) specs.sign = sign::space;
       break;
     case '#':
       specs.alt = true;
@@ -328,8 +338,8 @@ void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
 }
 
 template <typename Char, typename GetArg>
-int parse_header(const Char*& it, const Char* end,
-                 basic_format_specs<Char>& specs, GetArg get_arg) {
+auto parse_header(const Char*& it, const Char* end, format_specs<Char>& specs,
+                  GetArg get_arg) -> int {
   int arg_index = -1;
   Char c = *it;
   if (c >= '0' && c <= '9') {
@@ -344,7 +354,7 @@ int parse_header(const Char*& it, const Char* end,
       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"));
+        if (value == -1) throw_format_error("number is too big");
         specs.width = value;
         return arg_index;
       }
@@ -355,7 +365,7 @@ int parse_header(const Char*& it, const Char* end,
   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"));
+      if (specs.width == -1) throw_format_error("number is too big");
     } else if (*it == '*') {
       ++it;
       specs.width = static_cast<int>(visit_format_arg(
@@ -365,13 +375,53 @@ int parse_header(const Char*& it, const Char* end,
   return arg_index;
 }
 
+inline auto parse_printf_presentation_type(char c, type t)
+    -> presentation_type {
+  using pt = presentation_type;
+  constexpr auto integral_set = sint_set | uint_set | bool_set | char_set;
+  switch (c) {
+  case 'd':
+    return in(t, integral_set) ? pt::dec : pt::none;
+  case 'o':
+    return in(t, integral_set) ? pt::oct : pt::none;
+  case 'x':
+    return in(t, integral_set) ? pt::hex_lower : pt::none;
+  case 'X':
+    return in(t, integral_set) ? pt::hex_upper : pt::none;
+  case 'a':
+    return in(t, float_set) ? pt::hexfloat_lower : pt::none;
+  case 'A':
+    return in(t, float_set) ? pt::hexfloat_upper : pt::none;
+  case 'e':
+    return in(t, float_set) ? pt::exp_lower : pt::none;
+  case 'E':
+    return in(t, float_set) ? pt::exp_upper : pt::none;
+  case 'f':
+    return in(t, float_set) ? pt::fixed_lower : pt::none;
+  case 'F':
+    return in(t, float_set) ? pt::fixed_upper : pt::none;
+  case 'g':
+    return in(t, float_set) ? pt::general_lower : pt::none;
+  case 'G':
+    return in(t, float_set) ? pt::general_upper : pt::none;
+  case 'c':
+    return in(t, integral_set) ? pt::chr : pt::none;
+  case 's':
+    return in(t, string_set | cstring_set) ? pt::string : pt::none;
+  case 'p':
+    return in(t, pointer_set | cstring_set) ? pt::pointer : pt::none;
+  default:
+    return pt::none;
+  }
+}
+
 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);
+  using iterator = buffer_appender<Char>;
+  auto out = iterator(buf);
+  auto context = basic_printf_context<Char>(out, args);
+  auto parse_ctx = basic_format_parse_context<Char>(format);
 
   // Returns the argument with specified index or, if arg_index is -1, the next
   // argument.
@@ -387,26 +437,24 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
   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 '%'
+    if (!find<false, Char>(it, end, '%', it)) {
+      it = end;  // 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)));
+      write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
       start = ++it;
       continue;
     }
-    out = detail::write(out, basic_string_view<Char>(
-                                 start, detail::to_unsigned(it - 1 - start)));
+    write(out, basic_string_view<Char>(start, to_unsigned(it - 1 - start)));
 
-    basic_format_specs<Char> specs;
+    auto specs = format_specs<Char>();
     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");
+    if (arg_index == 0) throw_format_error("argument not found");
 
     // Parse precision.
     if (it != end && *it == '.') {
@@ -417,7 +465,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
       } else if (c == '*') {
         ++it;
         specs.precision = static_cast<int>(
-            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
+            visit_format_arg(printf_precision_handler(), get_arg(-1)));
       } else {
         specs.precision = 0;
       }
@@ -426,20 +474,19 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     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);
+    if (specs.precision >= 0 && arg.is_integral()) {
+      // Ignore '0' for non-numeric types or if '-' present.
+      specs.fill[0] = ' ';
+    }
+    if (specs.precision >= 0 && arg.type() == type::cstring_type) {
+      auto str = visit_format_arg(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)));
+      auto sv = basic_string_view<Char>(
+          str, to_unsigned(nul != str_end ? nul - str : specs.precision));
+      arg = make_arg<basic_printf_context<Char>>(sv);
     }
-    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
-      specs.alt = false;
+    if (specs.alt && visit_format_arg(is_zero_int(), arg)) specs.alt = false;
     if (specs.fill[0] == '0') {
       if (arg.is_arithmetic() && specs.align != align::left)
         specs.align = align::numeric;
@@ -451,7 +498,6 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     // 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') {
@@ -490,7 +536,7 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
     }
 
     // Parse type.
-    if (it == end) FMT_THROW(format_error("invalid format string"));
+    if (it == end) throw_format_error("invalid format string");
     char type = static_cast<char>(*it++);
     if (arg.is_integral()) {
       // Normalize type.
@@ -500,32 +546,25 @@ void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
         type = 'd';
         break;
       case 'c':
-        visit_format_arg(
-            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
-            arg);
+        visit_format_arg(char_converter<basic_printf_context<Char>>(arg), arg);
         break;
       }
     }
-    specs.type = parse_presentation_type(type);
+    specs.type = parse_printf_presentation_type(type, arg.type());
     if (specs.type == presentation_type::none)
-      parse_ctx.on_error("invalid type specifier");
+      throw_format_error("invalid format specifier");
 
     start = it;
 
     // Format argument.
-    out = visit_format_arg(
-        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
+    visit_format_arg(printf_arg_formatter<Char>(out, specs, context), arg);
   }
-  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+  write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
 }
-FMT_END_DETAIL_NAMESPACE
+}  // namespace detail
 
-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_context = basic_printf_context<char>;
+using wprintf_context = basic_printf_context<wchar_t>;
 
 using printf_args = basic_format_args<printf_context>;
 using wprintf_args = basic_format_args<wprintf_context>;
@@ -542,26 +581,21 @@ inline auto make_printf_args(const T&... args)
   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
- */
+// DEPRECATED!
 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>>
+template <typename Char>
 inline auto vsprintf(
-    const S& fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<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);
+  auto buf = basic_memory_buffer<Char>();
+  detail::vprintf(buf, fmt, args);
+  return to_string(buf);
 }
 
 /**
@@ -576,20 +610,19 @@ inline auto vsprintf(
 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...));
+                  fmt::make_format_args<basic_printf_context<Char>>(args...));
 }
 
-template <typename S, typename Char = char_t<S>>
+template <typename Char>
 inline auto vfprintf(
-    std::FILE* f, const S& fmt,
-    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    std::FILE* f, basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<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
+  auto buf = basic_memory_buffer<Char>();
+  detail::vprintf(buf, fmt, args);
+  size_t size = buf.size();
+  return std::fwrite(buf.data(), sizeof(Char), size, f) < size
              ? -1
              : static_cast<int>(size);
 }
@@ -605,17 +638,16 @@ inline auto vfprintf(
  */
 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...));
+                  fmt::make_format_args<basic_printf_context<Char>>(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)
+template <typename Char>
+FMT_DEPRECATED inline auto vprintf(
+    basic_string_view<Char> fmt,
+    basic_format_args<basic_printf_context<type_identity_t<Char>>> args)
     -> int {
-  return vfprintf(stdout, detail::to_string_view(fmt), args);
+  return vfprintf(stdout, fmt, args);
 }
 
 /**
@@ -627,14 +659,17 @@ inline auto vprintf(
     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...));
+template <typename... T>
+inline auto printf(string_view fmt, const T&... args) -> int {
+  return vfprintf(stdout, fmt, make_printf_args(args...));
+}
+template <typename... T>
+FMT_DEPRECATED inline auto printf(basic_string_view<wchar_t> fmt,
+                                  const T&... args) -> int {
+  return vfprintf(stdout, fmt, make_wprintf_args(args...));
 }
 
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_PRINTF_H_

src/fmt/ranges.h

@@ -1,13 +1,9 @@
-// Formatting library for C++ - experimental range support
+// Formatting library for C++ - range and tuple support
 //
-// Copyright (c) 2012 - present, Victor Zverovich
+// Copyright (c) 2012 - present, Victor Zverovich and {fmt} contributors
 // 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_
@@ -22,27 +18,25 @@ FMT_BEGIN_NAMESPACE
 
 namespace detail {
 
-template <typename RangeT, typename OutputIterator>
-OutputIterator copy(const RangeT& range, OutputIterator out) {
+template <typename Range, typename OutputIt>
+auto copy(const Range& range, OutputIt out) -> OutputIt {
   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) {
+template <typename OutputIt>
+auto copy(const char* str, OutputIt out) -> OutputIt {
   while (*str) *out++ = *str++;
   return out;
 }
 
-template <typename OutputIterator>
-OutputIterator copy(char ch, OutputIterator out) {
+template <typename OutputIt> auto copy(char ch, OutputIt out) -> OutputIt {
   *out++ = ch;
   return out;
 }
 
-template <typename OutputIterator>
-OutputIterator copy(wchar_t ch, OutputIterator out) {
+template <typename OutputIt> auto copy(wchar_t ch, OutputIt out) -> OutputIt {
   *out++ = ch;
   return out;
 }
@@ -69,7 +63,7 @@ template <typename T> class is_map {
   template <typename> static void check(...);
 
  public:
-#ifdef FMT_FORMAT_MAP_AS_LIST
+#ifdef FMT_FORMAT_MAP_AS_LIST  // DEPRECATED!
   static constexpr const bool value = false;
 #else
   static constexpr const bool value =
@@ -82,7 +76,7 @@ template <typename T> class is_set {
   template <typename> static void check(...);
 
  public:
-#ifdef FMT_FORMAT_SET_AS_LIST
+#ifdef FMT_FORMAT_SET_AS_LIST  // DEPRECATED!
   static constexpr const bool value = false;
 #else
   static constexpr const bool value =
@@ -157,8 +151,9 @@ 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 {};
+              // the extra int here is because older versions of MSVC don't
+              // SFINAE properly unless there are distinct types
+              int>> : std::true_type {};
 
 template <typename T>
 struct is_range_<T, void>
@@ -188,7 +183,7 @@ template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
 template <typename T, T... N> struct integer_sequence {
   using value_type = T;
 
-  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
+  static FMT_CONSTEXPR auto size() -> size_t { return sizeof...(N); }
 };
 
 template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
@@ -211,41 +206,61 @@ class is_tuple_formattable_ {
   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...>);
+  template <std::size_t... Is>
+  static auto check2(index_sequence<Is...>,
+                     integer_sequence<bool, (Is == Is)...>) -> std::true_type;
+  static auto check2(...) -> std::false_type;
+  template <std::size_t... Is>
+  static auto check(index_sequence<Is...>) -> decltype(check2(
+      index_sequence<Is...>{},
+      integer_sequence<bool,
+                       (is_formattable<typename std::tuple_element<Is, T>::type,
+                                       C>::value)...>{}));
 
  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 {
+template <typename Tuple, typename F, size_t... Is>
+FMT_CONSTEXPR void for_each(index_sequence<Is...>, Tuple&& t, F&& f) {
   using std::get;
-  // using free function get<I>(T) now.
-  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
-  (void)_;  // blocks warnings
+  // Using a free function get<Is>(Tuple) now.
+  const int unused[] = {0, ((void)f(get<Is>(t)), 0)...};
+  ignore_unused(unused);
 }
 
-template <class T>
-FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
-    T const&) {
-  return {};
+template <typename Tuple, typename F>
+FMT_CONSTEXPR void for_each(Tuple&& t, F&& f) {
+  for_each(tuple_index_sequence<remove_cvref_t<Tuple>>(),
+           std::forward<Tuple>(t), std::forward<F>(f));
 }
 
-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));
+template <typename Tuple1, typename Tuple2, typename F, size_t... Is>
+void for_each2(index_sequence<Is...>, Tuple1&& t1, Tuple2&& t2, F&& f) {
+  using std::get;
+  const int unused[] = {0, ((void)f(get<Is>(t1), get<Is>(t2)), 0)...};
+  ignore_unused(unused);
 }
 
+template <typename Tuple1, typename Tuple2, typename F>
+void for_each2(Tuple1&& t1, Tuple2&& t2, F&& f) {
+  for_each2(tuple_index_sequence<remove_cvref_t<Tuple1>>(),
+            std::forward<Tuple1>(t1), std::forward<Tuple2>(t2),
+            std::forward<F>(f));
+}
+
+namespace tuple {
+// Workaround a bug in MSVC 2019 (v140).
+template <typename Char, typename... T>
+using result_t = std::tuple<formatter<remove_cvref_t<T>, Char>...>;
+
+using std::get;
+template <typename Tuple, typename Char, std::size_t... Is>
+auto get_formatters(index_sequence<Is...>)
+    -> result_t<Char, decltype(get<Is>(std::declval<Tuple>()))...>;
+}  // namespace tuple
+
 #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 {
@@ -269,45 +284,37 @@ using range_reference_type =
 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 Formatter>
+FMT_CONSTEXPR auto maybe_set_debug_format(Formatter& f, bool set)
+    -> decltype(f.set_debug_format(set)) {
+  f.set_debug_format(set);
 }
+template <typename Formatter>
+FMT_CONSTEXPR void maybe_set_debug_format(Formatter&, ...) {}
 
-template <typename Char, typename OutputIt>
-auto write_range_entry(OutputIt out, basic_string_view<Char> str) -> OutputIt {
-  return write_escaped_string(out, str);
-}
+// These are not generic lambdas for compatibility with C++11.
+template <typename ParseContext> struct parse_empty_specs {
+  template <typename Formatter> FMT_CONSTEXPR void operator()(Formatter& f) {
+    f.parse(ctx);
+    detail::maybe_set_debug_format(f, true);
+  }
+  ParseContext& ctx;
+};
+template <typename FormatContext> struct format_tuple_element {
+  using char_type = typename FormatContext::char_type;
 
-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 T>
+  void operator()(const formatter<T, char_type>& f, const T& v) {
+    if (i > 0)
+      ctx.advance_to(detail::copy_str<char_type>(separator, ctx.out()));
+    ctx.advance_to(f.format(v, ctx));
+    ++i;
+  }
 
-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);
-}
+  int i;
+  FormatContext& ctx;
+  basic_string_view<char_type> separator;
+};
 
 }  // namespace detail
 
@@ -321,29 +328,20 @@ template <typename T, typename C> struct is_tuple_formattable {
       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>> {
+template <typename Tuple, typename Char>
+struct formatter<Tuple, Char,
+                 enable_if_t<fmt::is_tuple_like<Tuple>::value &&
+                             fmt::is_tuple_formattable<Tuple, Char>::value>> {
  private:
+  decltype(detail::tuple::get_formatters<Tuple, Char>(
+      detail::tuple_index_sequence<Tuple>())) formatters_;
+
   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() {}
 
@@ -359,17 +357,21 @@ struct formatter<TupleT, Char,
 
   template <typename ParseContext>
   FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    return ctx.begin();
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it != '}')
+      FMT_THROW(format_error("invalid format specifier"));
+    detail::for_each(formatters_, detail::parse_empty_specs<ParseContext>{ctx});
+    return it;
   }
 
-  template <typename FormatContext = format_context>
-  auto format(const TupleT& values, FormatContext& ctx) const
+  template <typename FormatContext>
+  auto format(const Tuple& value, 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;
+    ctx.advance_to(detail::copy_str<Char>(opening_bracket_, ctx.out()));
+    detail::for_each2(
+        formatters_, value,
+        detail::format_tuple_element<FormatContext>{0, ctx, separator_});
+    return detail::copy_str<Char>(closing_bracket_, ctx.out());
   }
 };
 
@@ -398,12 +400,10 @@ template <typename Context> struct range_mapper {
 };
 
 template <typename Char, typename Element>
-using range_formatter_type = conditional_t<
-    is_formattable<Element, Char>::value,
+using range_formatter_type =
     formatter<remove_cvref_t<decltype(range_mapper<buffer_context<Char>>{}.map(
                   std::declval<Element>()))>,
-              Char>,
-    fallback_formatter<Element, Char>>;
+              Char>;
 
 template <typename R>
 using maybe_const_range =
@@ -413,45 +413,32 @@ using maybe_const_range =
 #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>> {};
+    : is_formattable<uncvref_type<maybe_const_range<R>>, Char> {};
 #endif
-
 }  // namespace detail
 
+template <typename...> struct conjunction : std::true_type {};
+template <typename P> struct conjunction<P> : P {};
+template <typename P1, typename... Pn>
+struct conjunction<P1, Pn...>
+    : conditional_t<bool(P1::value), conjunction<Pn...>, P1> {};
+
 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>> {
+    enable_if_t<conjunction<std::is_same<T, remove_cvref_t<T>>,
+                            is_formattable<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() {}
 
@@ -473,31 +460,24 @@ struct range_formatter<
   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') {
+    if (it != end && *it == 'n') {
       set_brackets({}, {});
       ++it;
     }
 
-    if (*it == '}') {
-      maybe_set_debug_format();
-      return it;
+    if (it != end && *it != '}') {
+      if (*it != ':') FMT_THROW(format_error("invalid format specifier"));
+      ++it;
+    } else {
+      detail::maybe_set_debug_format(underlying_, true);
     }
 
-    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>
+  template <typename R, typename FormatContext>
   auto format(R&& range, FormatContext& ctx) const -> decltype(ctx.out()) {
     detail::range_mapper<buffer_context<Char>> mapper;
     auto out = ctx.out();
@@ -507,9 +487,9 @@ struct range_formatter<
     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);
+      auto&& item = *it;
+      out = underlying_.format(mapper.map(item), ctx);
       ++i;
     }
     out = detail::copy_str<Char>(closing_bracket_, out);
@@ -520,13 +500,14 @@ struct range_formatter<
 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 <typename T>
+struct range_format_kind_
+    : std::integral_constant<range_format,
+                             std::is_same<uncvref_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;
@@ -601,9 +582,6 @@ template <typename Char, typename... T> struct tuple_join_view : detail::view {
       : 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.
@@ -673,7 +651,45 @@ struct formatter<tuple_join_view<Char, T...>, Char> {
   }
 };
 
-FMT_MODULE_EXPORT_BEGIN
+namespace detail {
+// Check if T has an interface like a container adaptor (e.g. std::stack,
+// std::queue, std::priority_queue).
+template <typename T> class is_container_adaptor_like {
+  template <typename U> static auto check(U* p) -> typename U::container_type;
+  template <typename> static void check(...);
+
+ public:
+  static constexpr const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template <typename Container> struct all {
+  const Container& c;
+  auto begin() const -> typename Container::const_iterator { return c.begin(); }
+  auto end() const -> typename Container::const_iterator { return c.end(); }
+};
+}  // namespace detail
+
+template <typename T, typename Char>
+struct formatter<
+    T, Char,
+    enable_if_t<conjunction<detail::is_container_adaptor_like<T>,
+                            bool_constant<range_format_kind<T, Char>::value ==
+                                          range_format::disabled>>::value>>
+    : formatter<detail::all<typename T::container_type>, Char> {
+  using all = detail::all<typename T::container_type>;
+  template <typename FormatContext>
+  auto format(const T& t, FormatContext& ctx) const -> decltype(ctx.out()) {
+    struct getter : T {
+      static auto get(const T& t) -> all {
+        return {t.*(&getter::c)};  // Access c through the derived class.
+      }
+    };
+    return formatter<all>::format(getter::get(t), ctx);
+  }
+};
+
+FMT_BEGIN_EXPORT
 
 /**
   \rst
@@ -716,7 +732,7 @@ auto join(std::initializer_list<T> list, string_view sep)
   return join(std::begin(list), std::end(list), sep);
 }
 
-FMT_MODULE_EXPORT_END
+FMT_END_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_RANGES_H_

src/fmt/std.h

@@ -8,10 +8,18 @@
 #ifndef FMT_STD_H_
 #define FMT_STD_H_
 
+#include <atomic>
+#include <bitset>
+#include <cstdlib>
+#include <exception>
+#include <memory>
 #include <thread>
 #include <type_traits>
+#include <typeinfo>
 #include <utility>
+#include <vector>
 
+#include "format.h"
 #include "ostream.h"
 
 #if FMT_HAS_INCLUDE(<version>)
@@ -25,94 +33,258 @@
 #  if FMT_HAS_INCLUDE(<variant>)
 #    include <variant>
 #  endif
+#  if FMT_HAS_INCLUDE(<optional>)
+#    include <optional>
+#  endif
 #endif
 
-#ifdef __cpp_lib_filesystem
+#if FMT_CPLUSPLUS > 201703L && FMT_HAS_INCLUDE(<source_location>)
+#  include <source_location>
+#endif
+
+// GCC 4 does not support FMT_HAS_INCLUDE.
+#if FMT_HAS_INCLUDE(<cxxabi.h>) || defined(__GLIBCXX__)
+#  include <cxxabi.h>
+// Android NDK with gabi++ library on some architectures does not implement
+// abi::__cxa_demangle().
+#  ifndef __GABIXX_CXXABI_H__
+#    define FMT_HAS_ABI_CXA_DEMANGLE
+#  endif
+#endif
+
+// Check if typeid is available.
+#ifndef FMT_USE_TYPEID
+// __RTTI is for EDG compilers. In MSVC typeid is available without RTTI.
+#  if defined(__GXX_RTTI) || FMT_HAS_FEATURE(cxx_rtti) || FMT_MSC_VERSION || \
+      defined(__INTEL_RTTI__) || defined(__RTTI)
+#    define FMT_USE_TYPEID 1
+#  else
+#    define FMT_USE_TYPEID 0
+#  endif
+#endif
+
+// For older Xcode versions, __cpp_lib_xxx flags are inaccurately defined.
+#ifndef FMT_CPP_LIB_FILESYSTEM
+#  ifdef __cpp_lib_filesystem
+#    define FMT_CPP_LIB_FILESYSTEM __cpp_lib_filesystem
+#  else
+#    define FMT_CPP_LIB_FILESYSTEM 0
+#  endif
+#endif
+
+#ifndef FMT_CPP_LIB_VARIANT
+#  ifdef __cpp_lib_variant
+#    define FMT_CPP_LIB_VARIANT __cpp_lib_variant
+#  else
+#    define FMT_CPP_LIB_VARIANT 0
+#  endif
+#endif
+
+#if FMT_CPP_LIB_FILESYSTEM
 FMT_BEGIN_NAMESPACE
 
 namespace detail {
 
-template <typename Char>
+template <typename Char, typename PathChar>
+auto get_path_string(const std::filesystem::path& p,
+                     const std::basic_string<PathChar>& native) {
+  if constexpr (std::is_same_v<Char, char> && std::is_same_v<PathChar, wchar_t>)
+    return to_utf8<wchar_t>(native, to_utf8_error_policy::replace);
+  else
+    return p.string<Char>();
+}
+
+template <typename Char, typename PathChar>
 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());
+                        const std::filesystem::path& p,
+                        const std::basic_string<PathChar>& native) {
+  if constexpr (std::is_same_v<Char, char> &&
+                std::is_same_v<PathChar, wchar_t>) {
+    auto buf = basic_memory_buffer<wchar_t>();
+    write_escaped_string<wchar_t>(std::back_inserter(buf), native);
+    bool valid = to_utf8<wchar_t>::convert(quoted, {buf.data(), buf.size()});
+    FMT_ASSERT(valid, "invalid utf16");
+  } else if constexpr (std::is_same_v<Char, PathChar>) {
+    write_escaped_string<std::filesystem::path::value_type>(
+        std::back_inserter(quoted), native);
+  } else {
+    write_escaped_string<Char>(std::back_inserter(quoted), p.string<Char>());
+  }
 }
 
 }  // namespace detail
 
-template <typename Char>
-struct formatter<std::filesystem::path, Char>
-    : formatter<basic_string_view<Char>> {
+FMT_EXPORT
+template <typename Char> struct formatter<std::filesystem::path, Char> {
+ private:
+  format_specs<Char> specs_;
+  detail::arg_ref<Char> width_ref_;
+  bool debug_ = false;
+  char path_type_ = 0;
+
+ public:
+  FMT_CONSTEXPR void set_debug_format(bool set = true) { debug_ = set; }
+
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it == end) return it;
+
+    it = detail::parse_align(it, end, specs_);
+    if (it == end) return it;
+
+    it = detail::parse_dynamic_spec(it, end, specs_.width, width_ref_, ctx);
+    if (it != end && *it == '?') {
+      debug_ = true;
+      ++it;
+    }
+    if (it != end && (*it == 'g')) path_type_ = *it++;
+    return it;
+  }
+
   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);
+  auto format(const std::filesystem::path& p, FormatContext& ctx) const {
+    auto specs = specs_;
+#  ifdef _WIN32
+    auto path_string = !path_type_ ? p.native() : p.generic_wstring();
+#  else
+    auto path_string = !path_type_ ? p.native() : p.generic_string();
+#  endif
+
+    detail::handle_dynamic_spec<detail::width_checker>(specs.width, width_ref_,
+                                                       ctx);
+    if (!debug_) {
+      auto s = detail::get_path_string<Char>(p, path_string);
+      return detail::write(ctx.out(), basic_string_view<Char>(s), specs);
+    }
+    auto quoted = basic_memory_buffer<Char>();
+    detail::write_escaped_path(quoted, p, path_string);
+    return detail::write(ctx.out(),
+                         basic_string_view<Char>(quoted.data(), quoted.size()),
+                         specs);
+  }
+};
+FMT_END_NAMESPACE
+#endif  // FMT_CPP_LIB_FILESYSTEM
+
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <std::size_t N, typename Char>
+struct formatter<std::bitset<N>, Char> : nested_formatter<string_view> {
+ private:
+  // Functor because C++11 doesn't support generic lambdas.
+  struct writer {
+    const std::bitset<N>& bs;
+
+    template <typename OutputIt>
+    FMT_CONSTEXPR auto operator()(OutputIt out) -> OutputIt {
+      for (auto pos = N; pos > 0; --pos) {
+        out = detail::write<Char>(out, bs[pos - 1] ? Char('1') : Char('0'));
+      }
+
+      return out;
+    }
+  };
+
+ public:
+  template <typename FormatContext>
+  auto format(const std::bitset<N>& bs, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return write_padded(ctx, writer{bs});
+  }
+};
+
+FMT_EXPORT
+template <typename Char>
+struct formatter<std::thread::id, Char> : basic_ostream_formatter<Char> {};
+FMT_END_NAMESPACE
+
+#ifdef __cpp_lib_optional
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <typename T, typename Char>
+struct formatter<std::optional<T>, Char,
+                 std::enable_if_t<is_formattable<T, Char>::value>> {
+ private:
+  formatter<T, Char> underlying_;
+  static constexpr basic_string_view<Char> optional =
+      detail::string_literal<Char, 'o', 'p', 't', 'i', 'o', 'n', 'a', 'l',
+                             '('>{};
+  static constexpr basic_string_view<Char> none =
+      detail::string_literal<Char, 'n', 'o', 'n', 'e'>{};
+
+  template <class U>
+  FMT_CONSTEXPR static auto maybe_set_debug_format(U& u, bool set)
+      -> decltype(u.set_debug_format(set)) {
+    u.set_debug_format(set);
+  }
+
+  template <class U>
+  FMT_CONSTEXPR static void maybe_set_debug_format(U&, ...) {}
+
+ public:
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+    maybe_set_debug_format(underlying_, true);
+    return underlying_.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  auto format(const std::optional<T>& opt, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    if (!opt) return detail::write<Char>(ctx.out(), none);
+
+    auto out = ctx.out();
+    out = detail::write<Char>(out, optional);
+    ctx.advance_to(out);
+    out = underlying_.format(*opt, ctx);
+    return detail::write(out, ')');
+  }
+};
+FMT_END_NAMESPACE
+#endif  // __cpp_lib_optional
+
+#ifdef __cpp_lib_source_location
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+template <> struct formatter<std::source_location> {
+  template <typename ParseContext> FMT_CONSTEXPR auto parse(ParseContext& ctx) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const std::source_location& loc, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write(out, loc.file_name());
+    out = detail::write(out, ':');
+    out = detail::write<char>(out, loc.line());
+    out = detail::write(out, ':');
+    out = detail::write<char>(out, loc.column());
+    out = detail::write(out, ": ");
+    out = detail::write(out, loc.function_name());
+    return out;
   }
 };
 FMT_END_NAMESPACE
 #endif
 
+#if FMT_CPP_LIB_VARIANT
 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 {};
+template <typename> struct is_variant_like_ : std::false_type {};
+template <typename... Types>
+struct is_variant_like_<std::variant<Types...>> : std::true_type {};
 
-// formattable element check
+// formattable element check.
 template <typename T, typename C> class is_variant_formattable_ {
-  template <std::size_t... I>
+  template <std::size_t... Is>
   static std::conjunction<
-      is_formattable<std::variant_alternative_t<I, T>, C>...>
-      check(std::index_sequence<I...>);
+      is_formattable<std::variant_alternative_t<Is, T>, C>...>
+      check(std::index_sequence<Is...>);
 
  public:
   static constexpr const bool value =
@@ -140,6 +312,21 @@ template <typename T, typename C> struct is_variant_formattable {
       detail::is_variant_formattable_<T, C>::value;
 };
 
+FMT_EXPORT
+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()) {
+    return detail::write<Char>(ctx.out(), "monostate");
+  }
+};
+
+FMT_EXPORT
 template <typename Variant, typename Char>
 struct formatter<
     Variant, Char,
@@ -156,16 +343,195 @@ struct formatter<
     auto out = ctx.out();
 
     out = detail::write<Char>(out, "variant(");
-    std::visit(
-        [&](const auto& v) {
-          out = detail::write_variant_alternative<Char>(out, v);
-        },
-        value);
+    FMT_TRY {
+      std::visit(
+          [&](const auto& v) {
+            out = detail::write_variant_alternative<Char>(out, v);
+          },
+          value);
+    }
+    FMT_CATCH(const std::bad_variant_access&) {
+      detail::write<Char>(out, "valueless by exception");
+    }
     *out++ = ')';
     return out;
   }
 };
 FMT_END_NAMESPACE
+#endif  // FMT_CPP_LIB_VARIANT
+
+FMT_BEGIN_NAMESPACE
+FMT_EXPORT
+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(), format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
+};
+
+FMT_EXPORT
+template <typename T, typename Char>
+struct formatter<
+    T, Char,  // DEPRECATED! Mixing code unit types.
+    typename std::enable_if<std::is_base_of<std::exception, T>::value>::type> {
+ private:
+  bool with_typename_ = false;
+
+ public:
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    auto end = ctx.end();
+    if (it == end || *it == '}') return it;
+    if (*it == 't') {
+      ++it;
+      with_typename_ = FMT_USE_TYPEID != 0;
+    }
+    return it;
+  }
+
+  template <typename OutputIt>
+  auto format(const std::exception& ex,
+              basic_format_context<OutputIt, Char>& ctx) const -> OutputIt {
+    format_specs<Char> spec;
+    auto out = ctx.out();
+    if (!with_typename_)
+      return detail::write_bytes(out, string_view(ex.what()), spec);
+
+#if FMT_USE_TYPEID
+    const std::type_info& ti = typeid(ex);
+#  ifdef FMT_HAS_ABI_CXA_DEMANGLE
+    int status = 0;
+    std::size_t size = 0;
+    std::unique_ptr<char, void (*)(void*)> demangled_name_ptr(
+        abi::__cxa_demangle(ti.name(), nullptr, &size, &status), &std::free);
+
+    string_view demangled_name_view;
+    if (demangled_name_ptr) {
+      demangled_name_view = demangled_name_ptr.get();
+
+      // Normalization of stdlib inline namespace names.
+      // libc++ inline namespaces.
+      //  std::__1::*       -> std::*
+      //  std::__1::__fs::* -> std::*
+      // libstdc++ inline namespaces.
+      //  std::__cxx11::*             -> std::*
+      //  std::filesystem::__cxx11::* -> std::filesystem::*
+      if (demangled_name_view.starts_with("std::")) {
+        char* begin = demangled_name_ptr.get();
+        char* to = begin + 5;  // std::
+        for (char *from = to, *end = begin + demangled_name_view.size();
+             from < end;) {
+          // This is safe, because demangled_name is NUL-terminated.
+          if (from[0] == '_' && from[1] == '_') {
+            char* next = from + 1;
+            while (next < end && *next != ':') next++;
+            if (next[0] == ':' && next[1] == ':') {
+              from = next + 2;
+              continue;
+            }
+          }
+          *to++ = *from++;
+        }
+        demangled_name_view = {begin, detail::to_unsigned(to - begin)};
+      }
+    } else {
+      demangled_name_view = string_view(ti.name());
+    }
+    out = detail::write_bytes(out, demangled_name_view, spec);
+#  elif FMT_MSC_VERSION
+    string_view demangled_name_view(ti.name());
+    if (demangled_name_view.starts_with("class "))
+      demangled_name_view.remove_prefix(6);
+    else if (demangled_name_view.starts_with("struct "))
+      demangled_name_view.remove_prefix(7);
+    out = detail::write_bytes(out, demangled_name_view, spec);
+#  else
+    out = detail::write_bytes(out, string_view(ti.name()), spec);
+#  endif
+    *out++ = ':';
+    *out++ = ' ';
+    return detail::write_bytes(out, string_view(ex.what()), spec);
+#endif
+  }
+};
+
+namespace detail {
+
+template <typename T, typename Enable = void>
+struct has_flip : std::false_type {};
+
+template <typename T>
+struct has_flip<T, void_t<decltype(std::declval<T>().flip())>>
+    : std::true_type {};
+
+template <typename T> struct is_bit_reference_like {
+  static constexpr const bool value =
+      std::is_convertible<T, bool>::value &&
+      std::is_nothrow_assignable<T, bool>::value && has_flip<T>::value;
+};
+
+#ifdef _LIBCPP_VERSION
+
+// Workaround for libc++ incompatibility with C++ standard.
+// According to the Standard, `bitset::operator[] const` returns bool.
+template <typename C>
+struct is_bit_reference_like<std::__bit_const_reference<C>> {
+  static constexpr const bool value = true;
+};
+
 #endif
 
+}  // namespace detail
+
+// We can't use std::vector<bool, Allocator>::reference and
+// std::bitset<N>::reference because the compiler can't deduce Allocator and N
+// in partial specialization.
+FMT_EXPORT
+template <typename BitRef, typename Char>
+struct formatter<BitRef, Char,
+                 enable_if_t<detail::is_bit_reference_like<BitRef>::value>>
+    : formatter<bool, Char> {
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const BitRef& v, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<bool, Char>::format(v, ctx);
+  }
+};
+
+FMT_EXPORT
+template <typename T, typename Char>
+struct formatter<std::atomic<T>, Char,
+                 enable_if_t<is_formattable<T, Char>::value>>
+    : formatter<T, Char> {
+  template <typename FormatContext>
+  auto format(const std::atomic<T>& v, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<T, Char>::format(v.load(), ctx);
+  }
+};
+
+#ifdef __cpp_lib_atomic_flag_test
+FMT_EXPORT
+template <typename Char>
+struct formatter<std::atomic_flag, Char> : formatter<bool, Char> {
+  template <typename FormatContext>
+  auto format(const std::atomic_flag& v, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    return formatter<bool, Char>::format(v.test(), ctx);
+  }
+};
+#endif  // __cpp_lib_atomic_flag_test
+
+FMT_END_NAMESPACE
 #endif  // FMT_STD_H_

src/fmt/xchar.h

@@ -12,13 +12,32 @@
 
 #include "format.h"
 
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+#  include <locale>
+#endif
+
 FMT_BEGIN_NAMESPACE
 namespace detail {
+
 template <typename T>
 using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
-}
 
-FMT_MODULE_EXPORT_BEGIN
+inline auto write_loc(std::back_insert_iterator<detail::buffer<wchar_t>> out,
+                      loc_value value, const format_specs<wchar_t>& specs,
+                      locale_ref loc) -> bool {
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+  auto& numpunct =
+      std::use_facet<std::numpunct<wchar_t>>(loc.get<std::locale>());
+  auto separator = std::wstring();
+  auto grouping = numpunct.grouping();
+  if (!grouping.empty()) separator = std::wstring(1, numpunct.thousands_sep());
+  return value.visit(loc_writer<wchar_t>{out, specs, separator, grouping, {}});
+#endif
+  return false;
+}
+}  // namespace detail
+
+FMT_BEGIN_EXPORT
 
 using wstring_view = basic_string_view<wchar_t>;
 using wformat_parse_context = basic_format_parse_context<wchar_t>;
@@ -33,7 +52,9 @@ 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}}; }
+inline auto runtime(wstring_view s) -> runtime_format_string<wchar_t> {
+  return {{s}};
+}
 #endif
 
 template <> struct is_char<wchar_t> : std::true_type {};
@@ -41,15 +62,16 @@ 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) {
+template <typename... T>
+constexpr auto make_wformat_args(const T&... args)
+    -> format_arg_store<wformat_context, T...> {
   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) {
+constexpr auto operator""_a(const wchar_t* s, size_t)
+    -> detail::udl_arg<wchar_t> {
   return {s};
 }
 #endif
@@ -78,9 +100,9 @@ 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);
+  auto buf = basic_memory_buffer<Char>();
+  detail::vformat_to(buf, format_str, args);
+  return to_string(buf);
 }
 
 template <typename... T>
@@ -90,10 +112,10 @@ auto format(wformat_string<T...> fmt, T&&... args) -> std::wstring {
 
 // 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>,
+template <typename S, typename... T, 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> {
+auto format(const S& format_str, T&&... args) -> std::basic_string<Char> {
   return vformat(detail::to_string_view(format_str),
                  fmt::make_format_args<buffer_context<Char>>(args...));
 }
@@ -108,11 +130,10 @@ inline auto vformat(
   return detail::vformat(loc, detail::to_string_view(format_str), args);
 }
 
-template <typename Locale, typename S, typename... Args,
-          typename Char = char_t<S>,
+template <typename Locale, typename S, typename... T, 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)
+inline auto format(const Locale& loc, const S& format_str, T&&... args)
     -> std::basic_string<Char> {
   return detail::vformat(loc, detail::to_string_view(format_str),
                          fmt::make_format_args<buffer_context<Char>>(args...));
@@ -126,14 +147,14 @@ auto vformat_to(OutputIt out, const S& format_str,
     -> OutputIt {
   auto&& buf = detail::get_buffer<Char>(out);
   detail::vformat_to(buf, detail::to_string_view(format_str), args);
-  return detail::get_iterator(buf);
+  return detail::get_iterator(buf, out);
 }
 
-template <typename OutputIt, typename S, typename... Args,
+template <typename OutputIt, typename S, typename... T,
           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 {
+inline auto format_to(OutputIt out, const S& fmt, T&&... args) -> OutputIt {
   return vformat_to(out, detail::to_string_view(fmt),
                     fmt::make_format_args<buffer_context<Char>>(args...));
 }
@@ -149,18 +170,18 @@ inline auto vformat_to(
   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);
+  return detail::get_iterator(buf, out);
 }
 
-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>
+template <typename OutputIt, typename Locale, typename S, typename... T,
+          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) ->
+                      T&&... args) ->
     typename std::enable_if<enable, OutputIt>::type {
-  return vformat_to(out, loc, to_string_view(format_str),
+  return vformat_to(out, loc, detail::to_string_view(format_str),
                     fmt::make_format_args<buffer_context<Char>>(args...));
 }
 
@@ -171,36 +192,36 @@ 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);
+  using traits = detail::fixed_buffer_traits;
+  auto buf = detail::iterator_buffer<OutputIt, Char, traits>(out, n);
   detail::vformat_to(buf, format_str, args);
   return {buf.out(), buf.count()};
 }
 
-template <typename OutputIt, typename S, typename... Args,
+template <typename OutputIt, typename S, typename... T,
           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> {
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt, T&&... 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>,
+template <typename S, typename... T, 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;
+inline auto formatted_size(const S& fmt, T&&... args) -> size_t {
+  auto buf = detail::counting_buffer<Char>();
   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)
+  auto buf = wmemory_buffer();
+  detail::vformat_to(buf, fmt, args);
+  buf.push_back(L'\0');
+  if (std::fputws(buf.data(), f) == -1)
     FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
 }
 
@@ -217,13 +238,22 @@ template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
   return vprint(wstring_view(fmt), fmt::make_wformat_args(args...));
 }
 
+template <typename... T>
+void println(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
+  return print(f, L"{}\n", fmt::format(fmt, std::forward<T>(args)...));
+}
+
+template <typename... T> void println(wformat_string<T...> fmt, T&&... args) {
+  return print(L"{}\n", fmt::format(fmt, std::forward<T>(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_EXPORT
 FMT_END_NAMESPACE
 
 #endif  // FMT_XCHAR_H_

src/format.cpp

@@ -0,0 +1,43 @@
+// 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*);
+
+template FMT_API void vformat_to(buffer<char>&, string_view,
+                                 typename vformat_args<>::type, 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

src/fs_copydata_readwrite.cpp

@@ -57,8 +57,7 @@ namespace l
   int
   copydata_readwrite(const int    src_fd_,
                      const int    dst_fd_,
-                     const size_t count_,
-                     const size_t blocksize_)
+                     const size_t count_)
   {
     ssize_t nr;
     ssize_t nw;
@@ -66,11 +65,9 @@ namespace l
     size_t  totalwritten;
     vector<char> buf;
 
-    bufsize = (blocksize_ * 16);
+    bufsize = (1024 * 1024);
     buf.resize(bufsize);
 
-    fs::lseek(src_fd_,0,SEEK_SET);
-
     totalwritten = 0;
     while(totalwritten < count_)
       {
@@ -108,7 +105,6 @@ namespace fs
 
     return l::copydata_readwrite(src_fd_,
                                  dst_fd_,
-                                 st.st_size,
-                                 st.st_blksize);
+                                 st.st_size);
   }
 }

src/fs_cow.cpp

@@ -22,6 +22,7 @@
 #include "fs_lstat.hpp"
 #include "fs_mktemp.hpp"
 #include "fs_open.hpp"
+#include "fs_path.hpp"
 #include "fs_rename.hpp"
 #include "fs_unlink.hpp"
 
@@ -109,16 +110,14 @@ namespace fs
       int rv;
       int src_fd;
       int dst_fd;
-      string dst_fullpath;
+      std::string dst_fullpath;
 
       src_fd = fs::open(src_fullpath_,O_RDONLY|O_NOFOLLOW);
       if(src_fd == -1)
         return -1;
 
-      dst_fullpath = src_fullpath_;
-
-      dst_fd = fs::mktemp(&dst_fullpath,O_WRONLY);
-      if(dst_fd == -1)
+      std::tie(dst_fd,dst_fullpath) = fs::mktemp(src_fullpath_,O_WRONLY);
+      if(dst_fd < 0)
         return l::cleanup_on_error(src_fd);
 
       rv = fs::clonefile(src_fd,dst_fd);

src/fs_devid.hpp

@@ -19,6 +19,7 @@
 #pragma once
 
 #include "fs_fstat.hpp"
+#include "fs_dirfd.hpp"
 
 
 namespace fs
@@ -37,4 +38,16 @@ namespace fs
 
     return st.st_dev;
   }
+
+  static
+  inline
+  dev_t
+  devid(DIR *dh_)
+  {
+    int dirfd;
+
+    dirfd = fs::dirfd(dh_);
+
+    return fs::devid(dirfd);
+  }
 }

src/fs_dirfd.hpp

@@ -27,8 +27,8 @@ namespace fs
   static
   inline
   int
-  dirfd(DIR *dirp_)
+  dirfd(DIR *dh_)
   {
-    return ::dirfd(dirp_);
+    return ::dirfd(dh_);
   }
 }

src/fs_dup2.hpp

@@ -0,0 +1,38 @@
+/*
+  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 <unistd.h>
+
+
+namespace fs
+{
+  static
+  inline
+  int
+  dup2(int const oldfd_,
+       int const newfd_)
+  {
+    int rv;
+
+    rv = ::dup2(oldfd_,newfd_);
+
+    return ((rv == -1) ? -errno : rv);
+  }
+}

src/fs_inode.cpp

@@ -208,6 +208,19 @@ namespace fs
       return g_func(fusepath_,fusepath_len_,mode_,dev_,ino_);
     }
 
+    uint64_t
+    calc(std::string const &fusepath_,
+         const mode_t       mode_,
+         const dev_t        dev_,
+         const ino_t        ino_)
+    {
+      return calc(fusepath_.c_str(),
+                  fusepath_.size(),
+                  mode_,
+                  dev_,
+                  ino_);
+    }
+
     void
     calc(const char     *fusepath_,
          const uint64_t  fusepath_len_,

src/fs_inode.hpp

@@ -37,7 +37,11 @@ namespace fs
                   const uint64_t  fusepath_len,
                   const mode_t    mode,
                   const dev_t     dev,
-                  const ino_t     ion);
+                  const ino_t     ino);
+    uint64_t calc(std::string const &fusepath,
+                  mode_t const       mode,
+                  dev_t const        dev,
+                  ino_t              ino);
     void calc(const char     *fusepath,
               const uint64_t  fusepath_len,
               struct stat    *st);

src/fs_is_rofs.hpp

@@ -0,0 +1,75 @@
+/*
+  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 "fs_mktemp.hpp"
+#include "fs_statvfs.hpp"
+#include "fs_unlink.hpp"
+#include "statvfs_util.hpp"
+#include "ugid.hpp"
+
+#include <string>
+
+
+namespace fs
+{
+  static
+  inline
+  bool
+  is_mounted_rofs(const std::string path_)
+  {
+    int rv;
+    struct statvfs st;
+
+    rv = fs::statvfs(path_,&st);
+
+    return ((rv == 0) ? StatVFS::readonly(st) : false);
+  }
+
+  static
+  inline
+  bool
+  is_rofs(std::string path_)
+  {
+    ugid::SetRootGuard const ugid;
+
+    int fd;
+    std::string tmp_filepath;
+
+    std::tie(fd,tmp_filepath) = fs::mktemp_in_dir(path_,O_WRONLY);
+    if(fd < 0)
+      return (fd == -EROFS);
+
+    fs::close(fd);
+    fs::unlink(tmp_filepath);
+
+    return false;
+  }
+
+  static
+  inline
+  bool
+  is_rofs_but_not_mounted_ro(const std::string path_)
+  {
+    if(fs::is_mounted_rofs(path_))
+      return false;
+
+    return fs::is_rofs(path_);
+  }
+}

src/fs_mktemp.cpp

@@ -18,61 +18,78 @@
 
 #include "errno.hpp"
 #include "fs_open.hpp"
-
-#include <cstdlib>
-#include <string>
+#include "fs_path.hpp"
+#include "rnd.hpp"
 
 #include <limits.h>
 
-using std::string;
+#include <cstdlib>
+#include <string>
+#include <tuple>
 
-#define PADLEN 6
-#define MAX_ATTEMPTS 10
+#define PAD_LEN             16
+#define MAX_ATTEMPTS        3
+
+static char const   CHARS[]    = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+static size_t const CHARS_SIZE = (sizeof(CHARS) - 1);
 
 
-static
-string
-generate_tmp_path(const string &base_)
+namespace l
 {
-  string tmp;
+  static
+  std::string
+  generate_tmp_path(std::string const base_)
+  {
+    fs::Path path;
+    std::string filename;
 
-  tmp = base_;
-  if((tmp.size() + PADLEN + 1) > PATH_MAX)
-    tmp.resize(tmp.size() - PADLEN - 1);
-  tmp += '.';
-  for(int i = 0; i < PADLEN; i++)
-    tmp += ('A' + (std::rand() % 26));
+    filename  = '.';
+    for(int i = 0; i < PAD_LEN; i++)
+      filename += CHARS[RND::rand64(CHARS_SIZE)];
 
-  return tmp;
+    path = base_;
+    path /= filename;
+
+    return path.string();
+  }
 }
 
 namespace fs
 {
-  int
-  mktemp(string    *base_,
-         const int  flags_)
+  std::tuple<int,std::string>
+  mktemp_in_dir(std::string const dirpath_,
+                int const         flags_)
   {
     int fd;
     int count;
     int flags;
-    string tmppath;
+    std::string tmp_filepath;
 
     fd    = -1;
     count = MAX_ATTEMPTS;
-    flags = (flags_ | O_EXCL | O_CREAT);
+    flags = (flags_ | O_EXCL | O_CREAT | O_TRUNC);
     while(count-- > 0)
       {
-        tmppath = generate_tmp_path(*base_);
+        tmp_filepath = l::generate_tmp_path(dirpath_);
 
-        fd = fs::open(tmppath,flags,S_IWUSR);
+        fd = fs::open(tmp_filepath,flags,S_IWUSR);
         if((fd == -1) && (errno == EEXIST))
           continue;
-        else if(fd != -1)
-          *base_ = tmppath;
+        if(fd == -1)
+          return std::make_tuple(-errno,std::string());
 
-        return fd;
+        return std::make_tuple(fd,tmp_filepath);
       }
 
-    return (errno=EEXIST,-1);
+    return std::make_tuple(-EEXIST,std::string());
+  }
+
+  std::tuple<int,std::string>
+  mktemp(std::string const filepath_,
+         int const         flags_)
+  {
+    ghc::filesystem::path filepath{filepath_};
+
+    return fs::mktemp_in_dir(filepath.parent_path(),flags_);
   }
 }

src/fs_mktemp.hpp

@@ -19,11 +19,15 @@
 #pragma once
 
 #include <string>
-
+#include <tuple>
 
 namespace fs
 {
-  int
-  mktemp(std::string *base,
-         const int    flags);
+  std::tuple<int,std::string>
+  mktemp(std::string const filepath,
+         int const         flags);
+
+  std::tuple<int,std::string>
+  mktemp_in_dir(std::string const dirpath,
+                int const         flags);
 }

src/fs_movefile.cpp

@@ -44,6 +44,21 @@ using std::string;
 using std::vector;
 
 
+static
+int
+cleanup_flags(const int flags_)
+{
+  int rv;
+
+  rv = flags_;
+  rv = (rv & ~O_TRUNC);
+  rv = (rv & ~O_CREAT);
+  rv = (rv & ~O_EXCL);
+
+  return rv;
+}
+
+
 namespace l
 {
   static
@@ -51,82 +66,96 @@ namespace l
   movefile(const Policy::Create &createFunc_,
            const Branches::CPtr &branches_,
            const string         &fusepath_,
-           int                  *origfd_)
+           int                   origfd_)
   {
     int rv;
-    int fdin;
-    int fdout;
-    int fdin_flags;
-    int64_t fdin_size;
+    int srcfd;
+    int dstfd;
+    int dstfd_flags;
+    int origfd_flags;
+    int64_t srcfd_size;
     string fusedir;
-    string fdin_path;
-    string fdout_temp;
-    vector<string> fdout_path;
+    string srcfd_branch;
+    string srcfd_filepath;
+    string dstfd_filepath;
+    string dstfd_tmp_filepath;
+    vector<string> dstfd_branch;
 
-    fdin = *origfd_;
+    srcfd = -1;
+    dstfd = -1;
 
-    fdin_flags = fs::getfl(fdin);
-    if(fdin_flags == -1)
-      return -1;
-
-    rv = fs::findonfs(branches_,fusepath_,fdin,&fdin_path);
+    rv = fs::findonfs(branches_,fusepath_,origfd_,&srcfd_branch);
     if(rv == -1)
-      return -1;
+      return -errno;
 
-    rv = createFunc_(branches_,fusepath_,&fdout_path);
+    rv = createFunc_(branches_,fusepath_,&dstfd_branch);
     if(rv == -1)
-      return -1;
+      return -errno;
 
-    fdin_size = fs::file_size(fdin);
-    if(fdin_size == -1)
-      return -1;
+    origfd_flags = fs::getfl(origfd_);
+    if(origfd_flags == -1)
+      return -errno;
 
-    if(fs::has_space(fdout_path[0],fdin_size) == false)
-      return (errno=ENOSPC,-1);
+    srcfd_size = fs::file_size(origfd_);
+    if(srcfd_size == -1)
+      return -errno;
+
+    if(fs::has_space(dstfd_branch[0],srcfd_size) == false)
+      return -ENOSPC;
 
     fusedir = fs::path::dirname(fusepath_);
 
-    rv = fs::clonepath(fdin_path,fdout_path[0],fusedir);
+    rv = fs::clonepath(srcfd_branch,dstfd_branch[0],fusedir);
     if(rv == -1)
-      return -1;
+      return -ENOSPC;
 
-    fs::path::append(fdin_path,fusepath_);
-    fdin = fs::open(fdin_path,O_RDONLY);
-    if(fdin == -1)
-      return -1;
+    srcfd_filepath = srcfd_branch;
+    fs::path::append(srcfd_filepath,fusepath_);
+    srcfd = fs::open(srcfd_filepath,O_RDONLY);
+    if(srcfd == -1)
+      return -ENOSPC;
 
-    fs::path::append(fdout_path[0],fusepath_);
-    fdout_temp = fdout_path[0];
-    fdout = fs::mktemp(&fdout_temp,fdin_flags);
-    if(fdout == -1)
-      return -1;
+    dstfd_filepath = dstfd_branch[0];
+    fs::path::append(dstfd_filepath,fusepath_);
+    std::tie(dstfd,dstfd_tmp_filepath) = fs::mktemp(dstfd_filepath,O_WRONLY);
+    if(dstfd < 0)
+      {
+        fs::close(srcfd);
+        return -ENOSPC;
+      }
 
-    rv = fs::clonefile(fdin,fdout);
+    rv = fs::clonefile(srcfd,dstfd);
     if(rv == -1)
-      goto cleanup;
+      {
+        fs::close(srcfd);
+        fs::close(dstfd);
+        fs::unlink(dstfd_tmp_filepath);
+        return -ENOSPC;
+      }
 
-    rv = fs::rename(fdout_temp,fdout_path[0]);
+    rv = fs::rename(dstfd_tmp_filepath,dstfd_filepath);
     if(rv == -1)
-      goto cleanup;
+      {
+        fs::close(srcfd);
+        fs::close(dstfd);
+        fs::unlink(dstfd_tmp_filepath);
+        return -ENOSPC;
+      }
 
-    // should we care if it fails?
-    fs::unlink(fdin_path);
+    fs::close(srcfd);
+    fs::close(dstfd);
 
-    std::swap(*origfd_,fdout);
-    fs::close(fdin);
-    fs::close(fdout);
+    dstfd_flags = ::cleanup_flags(origfd_flags);
+    rv = fs::open(dstfd_filepath,dstfd_flags);
+    if(rv == -1)
+      {
+        fs::unlink(dstfd_tmp_filepath);
+        return -ENOSPC;
+      }
 
-    return 0;
+    fs::unlink(srcfd_filepath);
 
-  cleanup:
-    rv = errno;
-    if(fdin != -1)
-      fs::close(fdin);
-    if(fdout != -1)
-      fs::close(fdout);
-    fs::unlink(fdout_temp);
-    errno = rv;
-    return -1;
+    return rv;
   }
 }
 
@@ -136,7 +165,7 @@ namespace fs
   movefile(const Policy::Create &policy_,
            const Branches::CPtr &basepaths_,
            const string         &fusepath_,
-           int                  *origfd_)
+           int                   origfd_)
   {
     return l::movefile(policy_,basepaths_,fusepath_,origfd_);
   }
@@ -145,7 +174,7 @@ namespace fs
   movefile_as_root(const Policy::Create &policy_,
                    const Branches::CPtr &basepaths_,
                    const string         &fusepath_,
-                   int                  *origfd_)
+                   int                   origfd_)
   {
     const ugid::Set ugid(0,0);
 

src/fs_movefile.hpp

@@ -28,11 +28,11 @@ namespace fs
   movefile(const Policy::Create &policy,
            const Branches::CPtr &branches,
            const std::string    &fusepath,
-           int                  *origfd);
+           int                   origfd);
 
   int
   movefile_as_root(const Policy::Create &policy,
                    const Branches::CPtr &branches,
                    const std::string    &fusepath,
-                   int                  *origfd);
+                   int                   origfd);
 }

src/fs_preadn.hpp

@@ -0,0 +1,59 @@
+/*
+  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 "fs_pread.hpp"
+
+
+namespace fs
+{
+  static
+  inline
+  ssize_t
+  preadn(int const     fd_,
+         void         *buf_,
+         size_t const  count_,
+         off_t const   offset_,
+         int          *err_)
+  {
+    ssize_t rv;
+    ssize_t count = count_;
+    off_t   offset = offset_;
+    char const *buf = (char const *)buf_;
+
+    *err_ = 0;
+    while(count > 0)
+      {
+        rv = fs::pread(fd_,buf,count,offset);
+        if(rv == 0)
+          return (count_ - count);
+        if(rv < 0)
+          {
+            *err_ = rv;
+            return (count_ - count);
+          }
+
+        buf    += rv;
+        count  -= rv;
+        offset += rv;
+      }
+
+    return count_;
+  }
+}

src/fs_pwrite.hpp

@@ -0,0 +1,42 @@
+/*
+  ISC License
+
+  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include <unistd.h>
+
+
+namespace fs
+{
+  static
+  inline
+  ssize_t
+  pwrite(int const     fd_,
+         void const   *buf_,
+         size_t const  count_,
+         off_t const   offset_)
+  {
+    ssize_t rv;
+
+    rv = ::pwrite(fd_,buf_,count_,offset_);
+    if(rv == -1)
+      return -errno;
+
+    return rv;
+  }
+}

src/fs_pwriten.hpp

@@ -0,0 +1,59 @@
+/*
+  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 "fs_pwrite.hpp"
+
+
+namespace fs
+{
+  static
+  inline
+  ssize_t
+  pwriten(const int     fd_,
+          const void   *buf_,
+          const size_t  count_,
+          const off_t   offset_,
+          int          *err_)
+  {
+    ssize_t rv;
+    ssize_t count  = count_;
+    off_t   offset = offset_;
+    char const *buf = (char const *)buf_;
+
+    *err_ = 0;
+    while(count > 0)
+      {
+        rv = fs::pwrite(fd_,buf,count,offset);
+        if(rv == 0)
+          return (count_ - count);
+        if(rv < 0)
+          {
+            *err_ = rv;
+            return (count_ - count);
+          }
+
+        buf    += rv;
+        count  -= rv;
+        offset += rv;
+      }
+
+    return count_;
+  }
+}

src/fs_write.hpp

@@ -32,15 +32,4 @@ namespace fs
   {
     return ::write(fd_,buf_,count_);
   }
-
-  static
-  inline
-  ssize_t
-  pwrite(const int     fd_,
-         const void   *buf_,
-         const size_t  count_,
-         const off_t   offset_)
-  {
-    return ::pwrite(fd_,buf_,count_,offset_);
-  }
 }

src/fuse_create.cpp

@@ -51,6 +51,31 @@ namespace l
       *flags_ &= ~O_APPEND;
   }
 
+  static
+  bool
+  rdonly(const int flags_)
+  {
+    return ((flags_ & O_ACCMODE) == O_RDONLY);
+  }
+
+  static
+  bool
+  calculate_flush(FlushOnClose const flushonclose_,
+                  int const          flags_)
+  {
+    switch(flushonclose_)
+      {
+      case FlushOnCloseEnum::NEVER:
+        return false;
+      case FlushOnCloseEnum::OPENED_FOR_WRITE:
+        return !l::rdonly(flags_);
+      case FlushOnCloseEnum::ALWAYS:
+        return true;
+      }
+
+    return true;
+  }
+
   static
   void
   config_to_ffi_flags(Config::Read     &cfg_,
@@ -102,6 +127,9 @@ namespace l
           }
         break;
       }
+
+    if(cfg_->parallel_direct_writes == true)
+      ffi_->parallel_direct_writes = ffi_->direct_io;
   }
 
   static
@@ -121,21 +149,23 @@ namespace l
   int
   create_core(const std::string &createpath_,
               const char        *fusepath_,
+              fuse_file_info_t  *ffi_,
               const mode_t       mode_,
-              const mode_t       umask_,
-              const int          flags_,
-              uint64_t          *fh_)
+              const mode_t       umask_)
   {
     int rv;
+    FileInfo *fi;
     std::string fullpath;
 
     fullpath = fs::path::make(createpath_,fusepath_);
 
-    rv = l::create_core(fullpath,mode_,umask_,flags_);
+    rv = l::create_core(fullpath,mode_,umask_,ffi_->flags);
     if(rv == -1)
       return -errno;
 
-    *fh_ = reinterpret_cast<uint64_t>(new FileInfo(rv,fusepath_));
+    fi = new FileInfo(rv,fusepath_,ffi_->direct_io);
+
+    ffi_->fh = reinterpret_cast<uint64_t>(fi);
 
     return 0;
   }
@@ -146,10 +176,9 @@ namespace l
          const Policy::Create &createFunc_,
          const Branches       &branches_,
          const char           *fusepath_,
+         fuse_file_info_t     *ffi_,
          const mode_t          mode_,
-         const mode_t          umask_,
-         const int             flags_,
-         uint64_t             *fh_)
+         const mode_t          umask_)
   {
     int rv;
     std::string fullpath;
@@ -173,10 +202,9 @@ namespace l
 
     return l::create_core(createpaths[0],
                           fusepath_,
+                          ffi_,
                           mode_,
-                          umask_,
-                          flags_,
-                          fh_);
+                          umask_);
   }
 }
 
@@ -187,6 +215,7 @@ namespace FUSE
          mode_t            mode_,
          fuse_file_info_t *ffi_)
   {
+    int rv;
     Config::Read cfg;
     const fuse_context *fc = fuse_get_context();
     const ugid::Set     ugid(fc->uid,fc->gid);
@@ -196,13 +225,28 @@ namespace FUSE
     if(cfg->writeback_cache)
       l::tweak_flags_writeback_cache(&ffi_->flags);
 
-    return l::create(cfg->func.getattr.policy,
-                     cfg->func.create.policy,
-                     cfg->branches,
-                     fusepath_,
-                     mode_,
-                     fc->umask,
-                     ffi_->flags,
-                     &ffi_->fh);
+    ffi_->noflush = !l::calculate_flush(cfg->flushonclose,
+                                        ffi_->flags);
+
+    rv = l::create(cfg->func.getattr.policy,
+                   cfg->func.create.policy,
+                   cfg->branches,
+                   fusepath_,
+                   ffi_,
+                   mode_,
+                   fc->umask);
+    if(rv == -EROFS)
+      {
+        Config::Write()->branches.find_and_set_mode_ro();
+        rv = l::create(cfg->func.getattr.policy,
+                       cfg->func.create.policy,
+                       cfg->branches,
+                       fusepath_,
+                       ffi_,
+                       mode_,
+                       fc->umask);
+      }
+
+    return rv;
   }
 }

src/fuse_init.cpp

@@ -137,18 +137,22 @@ namespace FUSE
 
     ugid::init();
 
+    cfg->readdir.initialize();
+
     l::want_if_capable(conn_,FUSE_CAP_ASYNC_DIO);
     l::want_if_capable(conn_,FUSE_CAP_ASYNC_READ,&cfg->async_read);
     l::want_if_capable(conn_,FUSE_CAP_ATOMIC_O_TRUNC);
     l::want_if_capable(conn_,FUSE_CAP_BIG_WRITES);
     l::want_if_capable(conn_,FUSE_CAP_CACHE_SYMLINKS,&cfg->cache_symlinks);
+    l::want_if_capable(conn_,FUSE_CAP_DIRECT_IO_ALLOW_MMAP,&cfg->direct_io_allow_mmap);
     l::want_if_capable(conn_,FUSE_CAP_DONT_MASK);
+    l::want_if_capable(conn_,FUSE_CAP_EXPORT_SUPPORT,&cfg->export_support);
     l::want_if_capable(conn_,FUSE_CAP_IOCTL_DIR);
     l::want_if_capable(conn_,FUSE_CAP_PARALLEL_DIROPS);
-    l::want_if_capable(conn_,FUSE_CAP_READDIR_PLUS,&cfg->readdirplus);
-    //l::want_if_capable(conn_,FUSE_CAP_READDIR_PLUS_AUTO);
     l::want_if_capable(conn_,FUSE_CAP_POSIX_ACL,&cfg->posix_acl);
+    l::want_if_capable(conn_,FUSE_CAP_READDIR_PLUS,&cfg->readdirplus);
     l::want_if_capable(conn_,FUSE_CAP_WRITEBACK_CACHE,&cfg->writeback_cache);
+    //    l::want_if_capable(conn_,FUSE_CAP_READDIR_PLUS_AUTO);
     l::want_if_capable_max_pages(conn_,cfg);
     conn_->want &= ~FUSE_CAP_POSIX_LOCKS;
     conn_->want &= ~FUSE_CAP_FLOCK_LOCKS;

src/fuse_ioctl.cpp

@@ -24,6 +24,7 @@
 #include "fs_ioctl.hpp"
 #include "fs_open.hpp"
 #include "fs_path.hpp"
+#include "gidcache.hpp"
 #include "str.hpp"
 #include "ugid.hpp"
 
@@ -41,8 +42,13 @@ using std::vector;
 #endif
 
 typedef char IOCTL_BUF[4096];
-#define IOCTL_APP_TYPE  0xDF
-#define IOCTL_FILE_INFO _IOWR(IOCTL_APP_TYPE,0,IOCTL_BUF)
+#define IOCTL_APP_TYPE             0xDF
+#define IOCTL_FILE_INFO            _IOWR(IOCTL_APP_TYPE,0,IOCTL_BUF)
+#define IOCTL_GC                   _IO(IOCTL_APP_TYPE,1)
+#define IOCTL_GC1                  _IO(IOCTL_APP_TYPE,2)
+#define IOCTL_INVALIDATE_ALL_NODES _IO(IOCTL_APP_TYPE,3)
+#define IOCTL_INVALIDATE_GID_CACHE _IO(IOCTL_APP_TYPE,4)
+
 
 // From linux/btrfs.h
 #define BTRFS_IOCTL_MAGIC 0x94
@@ -334,6 +340,18 @@ namespace l
       {
       case IOCTL_FILE_INFO:
         return l::file_info(ffi_,data_);
+      case IOCTL_GC:
+        fuse_gc();
+        return 0;
+      case IOCTL_GC1:
+        fuse_gc1();
+        return 0;
+      case IOCTL_INVALIDATE_ALL_NODES:
+        fuse_invalidate_all_nodes();
+        return 0;
+      case IOCTL_INVALIDATE_GID_CACHE:
+        GIDCache::invalidate_all_caches();
+        break;
       }
 
     return -ENOTTY;

src/fuse_link.cpp

@@ -352,7 +352,7 @@ namespace FUSE
 
     rv = l::link(cfg,oldpath_,newpath_,st_,timeouts_);
     if(rv == -EXDEV)
-      return l::link_exdev(cfg,oldpath_,newpath_,st_,timeouts_);
+      rv = l::link_exdev(cfg,oldpath_,newpath_,st_,timeouts_);
 
     return rv;
   }

src/fuse_mkdir.cpp

@@ -150,15 +150,28 @@ namespace FUSE
   mkdir(const char *fusepath_,
         mode_t      mode_)
   {
+    int rv;
     Config::Read cfg;
     const fuse_context *fc = fuse_get_context();
     const ugid::Set     ugid(fc->uid,fc->gid);
 
-    return l::mkdir(cfg->func.getattr.policy,
-                    cfg->func.mkdir.policy,
-                    cfg->branches,
-                    fusepath_,
-                    mode_,
-                    fc->umask);
+    rv = l::mkdir(cfg->func.getattr.policy,
+                  cfg->func.mkdir.policy,
+                  cfg->branches,
+                  fusepath_,
+                  mode_,
+                  fc->umask);
+    if(rv == -EROFS)
+      {
+        Config::Write()->branches.find_and_set_mode_ro();
+        rv = l::mkdir(cfg->func.getattr.policy,
+                      cfg->func.mkdir.policy,
+                      cfg->branches,
+                      fusepath_,
+                      mode_,
+                      fc->umask);
+      }
+
+    return rv;
   }
 }

src/fuse_mknod.cpp

@@ -152,16 +152,30 @@ namespace FUSE
         mode_t      mode_,
         dev_t       rdev_)
   {
+    int rv;
     Config::Read cfg;
     const fuse_context *fc = fuse_get_context();
     const ugid::Set     ugid(fc->uid,fc->gid);
 
-    return l::mknod(cfg->func.getattr.policy,
-                    cfg->func.mknod.policy,
-                    cfg->branches,
-                    fusepath_,
-                    mode_,
-                    fc->umask,
-                    rdev_);
+    rv = l::mknod(cfg->func.getattr.policy,
+                  cfg->func.mknod.policy,
+                  cfg->branches,
+                  fusepath_,
+                  mode_,
+                  fc->umask,
+                  rdev_);
+    if(rv == -EROFS)
+      {
+        Config::Write()->branches.find_and_set_mode_ro();
+        rv = l::mknod(cfg->func.getattr.policy,
+                      cfg->func.mknod.policy,
+                      cfg->branches,
+                      fusepath_,
+                      mode_,
+                      fc->umask,
+                      rdev_);
+      }
+
+    return rv;
   }
 }

src/fuse_open.cpp

@@ -114,6 +114,24 @@ namespace l
       *flags_ &= ~O_APPEND;
   }
 
+  static
+  bool
+  calculate_flush(FlushOnClose const flushonclose_,
+                  int const          flags_)
+  {
+    switch(flushonclose_)
+      {
+      case FlushOnCloseEnum::NEVER:
+        return false;
+      case FlushOnCloseEnum::OPENED_FOR_WRITE:
+        return !l::rdonly(flags_);
+      case FlushOnCloseEnum::ALWAYS:
+        return true;
+      }
+
+    return true;
+  }
+
   static
   void
   config_to_ffi_flags(Config::Read     &cfg_,
@@ -165,32 +183,37 @@ namespace l
           }
         break;
       }
+
+    if(cfg_->parallel_direct_writes == true)
+      ffi_->parallel_direct_writes = ffi_->direct_io;
   }
 
   static
   int
   open_core(const std::string &basepath_,
             const char        *fusepath_,
-            const int          flags_,
+            fuse_file_info_t  *ffi_,
             const bool         link_cow_,
-            const NFSOpenHack  nfsopenhack_,
-            uint64_t          *fh_)
+            const NFSOpenHack  nfsopenhack_)
   {
     int fd;
+    FileInfo *fi;
     std::string fullpath;
 
     fullpath = fs::path::make(basepath_,fusepath_);
 
-    if(link_cow_ && fs::cow::is_eligible(fullpath.c_str(),flags_))
+    if(link_cow_ && fs::cow::is_eligible(fullpath.c_str(),ffi_->flags))
       fs::cow::break_link(fullpath.c_str());
 
-    fd = fs::open(fullpath,flags_);
+    fd = fs::open(fullpath,ffi_->flags);
     if((fd == -1) && (errno == EACCES))
-      fd = l::nfsopenhack(fullpath,flags_,nfsopenhack_);
+      fd = l::nfsopenhack(fullpath,ffi_->flags,nfsopenhack_);
     if(fd == -1)
       return -errno;
 
-    *fh_ = reinterpret_cast<uint64_t>(new FileInfo(fd,fusepath_));
+    fi = new FileInfo(fd,fusepath_,ffi_->direct_io);
+
+    ffi_->fh = reinterpret_cast<uint64_t>(fi);
 
     return 0;
   }
@@ -200,10 +223,9 @@ namespace l
   open(const Policy::Search &searchFunc_,
        const Branches       &branches_,
        const char           *fusepath_,
-       const int             flags_,
+       fuse_file_info_t     *ffi_,
        const bool            link_cow_,
-       const NFSOpenHack     nfsopenhack_,
-       uint64_t             *fh_)
+       const NFSOpenHack     nfsopenhack_)
   {
     int rv;
     StrVec basepaths;
@@ -212,7 +234,7 @@ namespace l
     if(rv == -1)
       return -errno;
 
-    return l::open_core(basepaths[0],fusepath_,flags_,link_cow_,nfsopenhack_,fh_);
+    return l::open_core(basepaths[0],fusepath_,ffi_,link_cow_,nfsopenhack_);
   }
 }
 
@@ -222,6 +244,7 @@ namespace FUSE
   open(const char       *fusepath_,
        fuse_file_info_t *ffi_)
   {
+    int rv;
     Config::Read cfg;
     const fuse_context *fc  = fuse_get_context();
     const ugid::Set     ugid(fc->uid,fc->gid);
@@ -231,12 +254,16 @@ namespace FUSE
     if(cfg->writeback_cache)
       l::tweak_flags_writeback_cache(&ffi_->flags);
 
-    return l::open(cfg->func.open.policy,
-                   cfg->branches,
-                   fusepath_,
-                   ffi_->flags,
-                   cfg->link_cow,
-                   cfg->nfsopenhack,
-                   &ffi_->fh);
+    ffi_->noflush = !l::calculate_flush(cfg->flushonclose,
+                                        ffi_->flags);
+
+    rv = l::open(cfg->func.open.policy,
+                 cfg->branches,
+                 fusepath_,
+                 ffi_,
+                 cfg->link_cow,
+                 cfg->nfsopenhack);
+
+    return rv;
   }
 }

src/fuse_opendir.cpp

@@ -30,6 +30,8 @@ namespace FUSE
 
     ffi_->fh = reinterpret_cast<uint64_t>(new DirInfo(fusepath_));
 
+    ffi_->noflush = true;
+
     if(cfg->cache_readdir)
       {
         ffi_->keep_cache    = 1;

src/fuse_read.cpp

@@ -23,17 +23,29 @@
 #include <stdlib.h>
 #include <string.h>
 
-typedef struct fuse_bufvec fuse_bufvec;
-
 
 namespace l
 {
   static
   int
-  read(const int     fd_,
-       char         *buf_,
-       const size_t  size_,
-       const off_t   offset_)
+  read_direct_io(const int     fd_,
+                 char         *buf_,
+                 const size_t  size_,
+                 const off_t   offset_)
+  {
+    int rv;
+
+    rv = fs::pread(fd_,buf_,size_,offset_);
+
+    return rv;
+  }
+
+  static
+  int
+  read_cached(const int     fd_,
+              char         *buf_,
+              const size_t  size_,
+              const off_t   offset_)
   {
     int rv;
 
@@ -53,10 +65,10 @@ namespace FUSE
   {
     FileInfo *fi = reinterpret_cast<FileInfo*>(ffi_->fh);
 
-    return l::read(fi->fd,
-                   buf_,
-                   size_,
-                   offset_);
+    if(fi->direct_io)
+      return l::read_direct_io(fi->fd,buf_,size_,offset_);
+
+    return l::read_cached(fi->fd,buf_,size_,offset_);
   }
 
   int

src/fuse_readdir.cpp

@@ -16,35 +16,95 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#include "fuse_readdir_posix.hpp"
-#include "fuse_readdir_linux.hpp"
+#include "fuse_readdir.hpp"
 
 #include "config.hpp"
-#include "dirinfo.hpp"
-#include "rwlock.hpp"
-#include "ugid.hpp"
+#include "fuse_readdir_factory.hpp"
 
-#include "fuse.h"
+/*
+  The _initialized stuff is not pretty but easiest way to deal with
+  the fact that mergerfs is doing arg parsing and setting up of things
+  (including thread pools) before the daemonizing
+ */
 
-
-namespace FUSE
+int
+FUSE::readdir(const fuse_file_info_t *ffi_,
+              fuse_dirents_t         *buf_)
 {
-  int
-  readdir(const fuse_file_info_t *ffi_,
-          fuse_dirents_t         *buf_)
-  {
-    Config::Read cfg;
-    DirInfo            *di = reinterpret_cast<DirInfo*>(ffi_->fh);
-    const fuse_context *fc = fuse_get_context();
-    const ugid::Set     ugid(fc->uid,fc->gid);
+  Config::Write cfg;
 
-    switch(cfg->readdir)
+  return cfg->readdir(ffi_,buf_);
+}
+
+FUSE::ReadDir::ReadDir(std::string const s_)
+  : _initialized(false)
+{
+  from_string(s_);
+  if(_initialized)
+    assert(_readdir);
+}
+
+std::string
+FUSE::ReadDir::to_string() const
+{
+  std::lock_guard<std::mutex> lg(_mutex);
+
+  return _type;
+}
+
+void
+FUSE::ReadDir::initialize()
+{
+  _initialized = true;
+  from_string(_type);
+}
+
+int
+FUSE::ReadDir::from_string(std::string const &str_)
+{
+  if(_initialized)
+    {
+      std::shared_ptr<FUSE::ReadDirBase> tmp;
+
+      tmp = FUSE::ReadDirFactory::make(str_);
+      if(!tmp)
+        return -EINVAL;
+
       {
-      case ReadDir::ENUM::LINUX:
-        return FUSE::readdir_linux(cfg->branches,di->fusepath.c_str(),buf_);
-      default:
-      case ReadDir::ENUM::POSIX:
-        return FUSE::readdir_posix(cfg->branches,di->fusepath.c_str(),buf_);
+        std::lock_guard<std::mutex> lg(_mutex);
+
+        _type    = str_;
+        std::swap(_readdir,tmp);
       }
+    }
+  else
+    {
+      std::lock_guard<std::mutex> lg(_mutex);
+
+      if(!FUSE::ReadDirFactory::valid(str_))
+        return -EINVAL;
+
+      _type = str_;
+    }
+
+  return 0;
+}
+
+/*
+  Yeah... if not initialized it will crash... ¯\_(ツ)_/¯
+  This will be resolved once initialization of internal objects and
+  handling of input is better seperated.
+*/
+int
+FUSE::ReadDir::operator()(fuse_file_info_t const *ffi_,
+                          fuse_dirents_t         *buf_)
+{
+  std::shared_ptr<FUSE::ReadDirBase> readdir;
+
+  {
+    std::lock_guard<std::mutex> lg(_mutex);
+    readdir = _readdir;
   }
+
+  return (*readdir)(ffi_,buf_);
 }

src/fuse_readdir.hpp

@@ -17,11 +17,45 @@
 #pragma once
 
 #include "fuse.h"
+#include "tofrom_string.hpp"
+#include "fuse_readdir_base.hpp"
 
+#include <memory>
+#include <mutex>
 
+#include <assert.h>
+
+// The initialization behavior is not pretty but for the moment
+// needed due to the daemonizing function of the libfuse library when
+// not using foreground mode. The threads need to be created after the
+// fork, not before.
 namespace FUSE
 {
-  int
-  readdir(const fuse_file_info_t *ffi,
-          fuse_dirents_t         *buf);
+  int readdir(fuse_file_info_t const *ffi,
+              fuse_dirents_t         *buf);
+
+  class ReadDir : public ToFromString
+  {
+  public:
+    ReadDir(std::string const s_);
+
+  public:
+    std::string to_string() const;
+    int from_string(const std::string &);
+
+  public:
+    int operator()(fuse_file_info_t const *ffi,
+                   fuse_dirents_t         *buf);
+
+  public:
+    void initialize();
+
+  private:
+    mutable std::mutex _mutex;
+
+  private:
+    bool _initialized;
+    std::string _type;
+    std::shared_ptr<FUSE::ReadDirBase> _readdir;
+  };
 }

src/fuse_readdir_base.hpp

@@ -0,0 +1,34 @@
+/*
+  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 "fuse.h"
+
+
+namespace FUSE
+{
+  class ReadDirBase
+  {
+  public:
+    ReadDirBase() {};
+    virtual ~ReadDirBase() {};
+
+  public:
+    virtual int operator()(fuse_file_info_t const *ffi,
+                           fuse_dirents_t         *buf) = 0;
+  };
+}

src/fuse_readdir_cor.cpp

@@ -0,0 +1,208 @@
+/*
+  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 "fuse_readdir_cor.hpp"
+
+#include "config.hpp"
+#include "dirinfo.hpp"
+#include "errno.hpp"
+#include "fs_close.hpp"
+#include "fs_devid.hpp"
+#include "fs_getdents64.hpp"
+#include "fs_inode.hpp"
+#include "fs_open.hpp"
+#include "fs_path.hpp"
+#include "fs_readdir.hpp"
+#include "hashset.hpp"
+#include "scope_guard.hpp"
+#include "ugid.hpp"
+
+#include "fuse_dirents.h"
+#include "linux_dirent64.h"
+
+
+FUSE::ReadDirCOR::ReadDirCOR(unsigned concurrency_,
+                             unsigned max_queue_depth_)
+  : _tp(concurrency_,max_queue_depth_,"readdir.cor")
+{
+
+}
+
+FUSE::ReadDirCOR::~ReadDirCOR()
+{
+
+}
+
+namespace l
+{
+  struct Error
+  {
+  private:
+    int _err;
+
+  public:
+    Error()
+      : _err(ENOENT)
+    {
+    }
+
+    operator int()
+    {
+      return _err;
+    }
+
+    Error&
+    operator=(int v_)
+    {
+      if(_err != 0)
+        _err = v_;
+
+      return *this;
+    }
+  };
+
+  static
+  inline
+  int
+  readdir(std::string     basepath_,
+          HashSet        &names_,
+          fuse_dirents_t *buf_,
+          std::mutex     &mutex_)
+  {
+    int rv;
+    int dfd;
+    dev_t dev;
+    std::string filepath;
+
+    dfd = fs::open_dir_ro(basepath_);
+    if(dfd == -1)
+      return errno;
+
+    DEFER{ fs::close(dfd); };
+
+    dev = fs::devid(dfd);
+
+    rv = 0;
+    for(;;)
+      {
+        long nread;
+        char buf[32 * 1024];
+
+        nread = fs::getdents_64(dfd,buf,sizeof(buf));
+        if(nread == -1)
+          return errno;
+        if(nread == 0)
+          break;
+
+        linux_dirent64_t *d;
+        std::lock_guard<std::mutex> lk(mutex_);
+        for(long pos = 0; pos < nread; pos += d->reclen)
+          {
+            std::uint64_t namelen;
+
+            d = (linux_dirent64_t*)&buf[pos];
+
+            namelen = DIRENT_NAMELEN(d);
+
+            rv = names_.put(d->name,namelen);
+            if(rv == 0)
+              continue;
+
+            filepath = fs::path::make(basepath_,d->name);
+            d->ino = fs::inode::calc(filepath,
+                                     DTTOIF(d->type),
+                                     dev,
+                                     d->ino);
+
+            rv = fuse_dirents_add_linux(buf_,d,namelen);
+            if(rv >= 0)
+              continue;
+
+            return ENOMEM;
+          }
+      }
+
+    return 0;
+  }
+
+  static
+  int
+  concurrent_readdir(ThreadPool           &tp_,
+                     const Branches::CPtr &branches_,
+                     const char           *dirname_,
+                     fuse_dirents_t       *buf_,
+                     uid_t const           uid_,
+                     gid_t const           gid_)
+  {
+    HashSet names;
+    std::mutex mutex;
+    std::vector<std::future<int>> futures;
+
+    futures.reserve(branches_->size());
+    for(auto const &branch : *branches_)
+      {
+        auto func = [&,dirname_,buf_,uid_,gid_]()
+        {
+          std::string basepath;
+          ugid::Set const ugid(uid_,gid_);
+
+          basepath = fs::path::make(branch.path,dirname_);
+
+          return l::readdir(basepath,names,buf_,mutex);
+        };
+
+        auto rv = tp_.enqueue_task(func);
+
+        futures.emplace_back(std::move(rv));
+      }
+
+    Error error;
+    for(auto &future : futures)
+      error = future.get();
+
+    return -error;
+  }
+
+  static
+  int
+  readdir(ThreadPool           &tp_,
+          const Branches::CPtr &branches_,
+          const char           *dirname_,
+          fuse_dirents_t       *buf_,
+          uid_t const           uid_,
+          gid_t const           gid_)
+  {
+    fuse_dirents_reset(buf_);
+
+    return l::concurrent_readdir(tp_,branches_,dirname_,buf_,uid_,gid_);
+  }
+}
+
+int
+FUSE::ReadDirCOR::operator()(fuse_file_info_t const *ffi_,
+                             fuse_dirents_t         *buf_)
+{
+  Config::Read        cfg;
+  DirInfo            *di = reinterpret_cast<DirInfo*>(ffi_->fh);
+  const fuse_context *fc = fuse_get_context();
+
+  return l::readdir(_tp,
+                    cfg->branches,
+                    di->fusepath.c_str(),
+                    buf_,
+                    fc->uid,
+                    fc->gid);
+}

src/fuse_readdir_cor.hpp

@@ -1,7 +1,7 @@
 /*
   ISC License
 
-  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+  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
@@ -18,19 +18,25 @@
 
 #pragma once
 
-#include "branches.hpp"
+#include "fuse_readdir_base.hpp"
 
-#include "fuse.h"
-
-#include <cstdint>
+#include "thread_pool.hpp"
 
 
+// concurrent open & read
 namespace FUSE
 {
-  int
-  readdir_plus_posix(const Branches::CPtr &branches,
-                     const char           *dirname,
-                     const uint64_t        entry_timeout,
-                     const uint64_t        attr_timeout,
-                     fuse_dirents_t       *buf);
+  class ReadDirCOR final : public FUSE::ReadDirBase
+  {
+  public:
+    ReadDirCOR(unsigned concurrency,
+               unsigned max_queue_depth);
+    ~ReadDirCOR();
+
+    int operator()(fuse_file_info_t const *ffi,
+                   fuse_dirents_t         *buf);
+
+  private:
+    ThreadPool _tp;
+  };
 }

src/fuse_readdir_cosr.cpp

@@ -0,0 +1,224 @@
+/*
+  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 "fuse_readdir_cosr.hpp"
+
+#include "config.hpp"
+#include "dirinfo.hpp"
+#include "errno.hpp"
+#include "fs_closedir.hpp"
+#include "fs_devid.hpp"
+#include "fs_dirfd.hpp"
+#include "fs_inode.hpp"
+#include "fs_opendir.hpp"
+#include "fs_path.hpp"
+#include "fs_readdir.hpp"
+#include "fs_stat.hpp"
+#include "hashset.hpp"
+#include "scope_guard.hpp"
+#include "ugid.hpp"
+
+#include "fuse_dirents.h"
+
+
+FUSE::ReadDirCOSR::ReadDirCOSR(unsigned concurrency_,
+                               unsigned max_queue_depth_)
+  : _tp(concurrency_,max_queue_depth_,"readdir.cosr")
+{
+
+}
+
+FUSE::ReadDirCOSR::~ReadDirCOSR()
+{
+
+}
+
+namespace l
+{
+  struct DirRV
+  {
+    DIR *dir;
+    int  err;
+  };
+
+  struct Error
+  {
+  private:
+    int _err;
+
+  public:
+    Error()
+      : _err(ENOENT)
+    {
+
+    }
+
+    operator int()
+    {
+      return _err;
+    }
+
+    Error&
+    operator=(int const v_)
+    {
+      if(_err != 0)
+        _err = v_;
+
+      return *this;
+    }
+  };
+
+  static
+  uint64_t
+  dirent_exact_namelen(const struct dirent *d_)
+  {
+#ifdef _D_EXACT_NAMLEN
+    return _D_EXACT_NAMLEN(d_);
+#elif defined _DIRENT_HAVE_D_NAMLEN
+    return d_->d_namlen;
+#else
+    return strlen(d_->d_name);
+#endif
+  }
+
+  static
+  inline
+  std::vector<std::future<DirRV>>
+  opendir(ThreadPool           &tp_,
+          const Branches::CPtr &branches_,
+          char const           *dirname_,
+          uid_t const           uid_,
+          gid_t const           gid_)
+  {
+    std::vector<std::future<DirRV>> futures;
+
+    futures.reserve(branches_->size());
+    for(auto const &branch : *branches_)
+      {
+        auto func = [&branch,dirname_,uid_,gid_]()
+        {
+          DirRV rv;
+          std::string basepath;
+          ugid::Set const ugid(uid_,gid_);
+
+          basepath = fs::path::make(branch.path,dirname_);
+
+          errno  = 0;
+          rv.dir = fs::opendir(basepath);
+          rv.err = errno;
+
+          return rv;
+        };
+
+        auto rv = tp_.enqueue_task(func);
+
+        futures.emplace_back(std::move(rv));
+      }
+
+    return futures;
+  }
+
+  static
+  inline
+  int
+  readdir(std::vector<std::future<DirRV>> &dh_futures_,
+          char const                      *dirname_,
+          fuse_dirents_t                  *buf_)
+  {
+    Error error;
+    HashSet names;
+    std::string fullpath;
+
+    for(auto &dh_future : dh_futures_)
+      {
+        int rv;
+        dev_t dev;
+        DirRV dirrv;
+
+        dirrv = dh_future.get();
+        error = dirrv.err;
+        if(dirrv.dir == NULL)
+          continue;
+
+        DEFER { fs::closedir(dirrv.dir); };
+
+        dev = fs::devid(dirrv.dir);
+
+        rv = 0;
+        for(dirent *de = fs::readdir(dirrv.dir); de && !rv; de = fs::readdir(dirrv.dir))
+          {
+            std::uint64_t namelen;
+
+            namelen = l::dirent_exact_namelen(de);
+
+            rv = names.put(de->d_name,namelen);
+            if(rv == 0)
+              continue;
+
+            fullpath  = fs::path::make(dirname_,de->d_name);
+            de->d_ino = fs::inode::calc(fullpath,
+                                        DTTOIF(de->d_type),
+                                        dev,
+                                        de->d_ino);
+
+            rv = fuse_dirents_add(buf_,de,namelen);
+            if(rv == 0)
+              continue;
+
+            error = ENOMEM;
+          }
+      }
+
+    return -error;
+  }
+
+  static
+  inline
+  int
+  readdir(ThreadPool           &tp_,
+          const Branches::CPtr &branches_,
+          const char           *dirname_,
+          fuse_dirents_t       *buf_,
+          uid_t const           uid_,
+          gid_t const           gid_)
+  {
+    int rv;
+    std::vector<std::future<DirRV>> futures;
+
+    fuse_dirents_reset(buf_);
+
+    futures = l::opendir(tp_,branches_,dirname_,uid_,gid_);
+    rv      = l::readdir(futures,dirname_,buf_);
+
+    return rv;
+  }
+}
+
+int
+FUSE::ReadDirCOSR::operator()(fuse_file_info_t const *ffi_,
+                              fuse_dirents_t         *buf_)
+{
+  Config::Read        cfg;
+  DirInfo            *di = reinterpret_cast<DirInfo*>(ffi_->fh);
+  const fuse_context *fc = fuse_get_context();
+
+  return l::readdir(_tp,
+                    cfg->branches,
+                    di->fusepath.c_str(),
+                    buf_,
+                    fc->uid,
+                    fc->gid);
+}

src/fuse_readdir_cosr.hpp

@@ -0,0 +1,41 @@
+/*
+  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 "fuse_readdir_base.hpp"
+
+#include "thread_pool.hpp"
+
+// concurrent open, sequential read
+namespace FUSE
+{
+  class ReadDirCOSR final : public FUSE::ReadDirBase
+  {
+  public:
+    ReadDirCOSR(unsigned concurrency,
+                unsigned max_queue_depth);
+    ~ReadDirCOSR();
+
+    int operator()(fuse_file_info_t const *ffi,
+                   fuse_dirents_t         *buf);
+
+  private:
+    ThreadPool _tp;
+  };
+}

src/fuse_readdir_factory.cpp

@@ -0,0 +1,114 @@
+/*
+  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 "fuse_readdir_factory.hpp"
+
+#include "fuse_readdir_cor.hpp"
+#include "fuse_readdir_cosr.hpp"
+#include "fuse_readdir_seq.hpp"
+
+#include <cassert>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <set>
+
+#define DEFAULT_MAX_QUEUE_DEPTH 3
+
+namespace l
+{
+  static
+  void
+  read_cfg(std::string const  str_,
+           std::string       &type_,
+           unsigned          &concurrency_,
+           unsigned          &max_queue_depth_)
+  {
+    char type[16];
+    int concurrency;
+    int max_queue_depth;
+
+    concurrency = 0;
+    max_queue_depth = 0;
+    std::sscanf(str_.c_str(),
+                "%15[a-z]:%d:%d",
+                type,
+                &concurrency,
+                &max_queue_depth);
+
+    if(concurrency == 0)
+      concurrency = std::thread::hardware_concurrency();
+    else if(concurrency < 0)
+      concurrency = (std::thread::hardware_concurrency() / std::abs(concurrency));
+
+    if(concurrency == 0)
+      concurrency = 1;
+
+    if(max_queue_depth == 0)
+      max_queue_depth = DEFAULT_MAX_QUEUE_DEPTH;
+
+    max_queue_depth *= concurrency;
+
+    type_            = type;
+    concurrency_     = concurrency;
+    max_queue_depth_ = max_queue_depth;
+  }
+}
+
+bool
+FUSE::ReadDirFactory::valid(std::string const str_)
+{
+  unsigned concurrency;
+  unsigned max_queue_depth;
+  std::string type;
+  static const std::set<std::string> types =
+    {
+      "seq", "cosr", "cor"
+    };
+
+  l::read_cfg(str_,type,concurrency,max_queue_depth);
+
+  if(types.find(type) == types.end())
+    return false;
+  if(concurrency <= 0)
+    return false;
+
+  return true;
+}
+
+std::shared_ptr<FUSE::ReadDirBase>
+FUSE::ReadDirFactory::make(std::string const str_)
+{
+  unsigned concurrency;
+  unsigned max_queue_depth;
+  std::string type;
+
+  if(!valid(str_))
+    return {};
+
+  l::read_cfg(str_,type,concurrency,max_queue_depth);
+
+  if(type == "seq")
+    return std::make_shared<FUSE::ReadDirSeq>();
+  if(type == "cosr")
+    return std::make_shared<FUSE::ReadDirCOSR>(concurrency,max_queue_depth);
+  if(type == "cor")
+    return std::make_shared<FUSE::ReadDirCOR>(concurrency,max_queue_depth);
+
+  return {};
+}

src/fuse_readdir_factory.hpp

@@ -0,0 +1,35 @@
+/*
+  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 "fuse_readdir_base.hpp"
+
+#include <string>
+#include <memory>
+
+
+namespace FUSE
+{
+  class ReadDirFactory
+  {
+  public:
+    static bool valid(std::string str);
+    static std::shared_ptr<ReadDirBase> make(std::string const str);
+  };
+}

src/fuse_readdir_linux.cpp

@@ -1,135 +0,0 @@
-/*
-  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
-
-  Permission to use, copy, modify, and/or distribute this software for any
-  purpose with or without fee is hereby granted, provided that the above
-  copyright notice and this permission notice appear in all copies.
-
-  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-*/
-
-#include "branches.hpp"
-#include "errno.hpp"
-#include "fs_close.hpp"
-#include "fs_devid.hpp"
-#include "fs_getdents64.hpp"
-#include "fs_inode.hpp"
-#include "fs_open.hpp"
-#include "fs_path.hpp"
-#include "fs_stat.hpp"
-#include "hashset.hpp"
-#include "linux_dirent64.h"
-#include "mempools.hpp"
-
-#include "fuse.h"
-#include "fuse_dirents.h"
-
-#include <string>
-#include <vector>
-
-#include <stddef.h>
-
-using std::string;
-using std::vector;
-
-namespace l
-{
-  static
-  int
-  close_free_ret_enomem(int   fd_,
-                        void *buf_)
-  {
-    fs::close(fd_);
-    g_DENTS_BUF_POOL.free(buf_);
-    return -ENOMEM;
-  }
-
-  static
-  int
-  readdir(const Branches::CPtr &branches_,
-          const char           *dirname_,
-          fuse_dirents_t       *buf_)
-  {
-    int rv;
-    dev_t dev;
-    char *buf;
-    HashSet names;
-    string basepath;
-    string fullpath;
-    uint64_t namelen;
-    struct linux_dirent64 *d;
-
-    fuse_dirents_reset(buf_);
-
-    buf = (char*)g_DENTS_BUF_POOL.alloc();
-    if(buf == NULL)
-      return -ENOMEM;
-
-    for(const auto &branch : *branches_)
-      {
-        int dirfd;
-        int64_t nread;
-
-        basepath = fs::path::make(branch.path,dirname_);
-
-        dirfd = fs::open_dir_ro(basepath);
-        if(dirfd == -1)
-          continue;
-
-        dev = fs::devid(dirfd);
-
-        for(;;)
-          {
-            nread = fs::getdents_64(dirfd,buf,g_DENTS_BUF_POOL.size());
-            if(nread == -1)
-              break;
-            if(nread == 0)
-              break;
-
-            for(int64_t pos = 0; pos < nread; pos += d->reclen)
-              {
-                d = (struct linux_dirent64*)(buf + pos);
-                namelen = strlen(d->name);
-
-                rv = names.put(d->name,namelen);
-                if(rv == 0)
-                  continue;
-
-                fullpath = fs::path::make(dirname_,d->name);
-                d->ino = fs::inode::calc(fullpath.c_str(),
-                                         fullpath.size(),
-                                         DTTOIF(d->type),
-                                         dev,
-                                         d->ino);
-
-                rv = fuse_dirents_add_linux(buf_,d,namelen);
-                if(rv)
-                  return close_free_ret_enomem(dirfd,buf);
-              }
-          }
-
-        fs::close(dirfd);
-      }
-
-    g_DENTS_BUF_POOL.free(buf);
-
-    return 0;
-  }
-}
-
-namespace FUSE
-{
-  int
-  readdir_linux(const Branches::CPtr &branches_,
-                const char           *dirname_,
-                fuse_dirents_t       *buf_)
-  {
-    return l::readdir(branches_,dirname_,buf_);
-  }
-}