update optional.hpp: fixes building on older clang versions

branches: add per branch minfreespace w/ original value as default

.cirrus.yml

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

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,28 @@
+---
+name: Bug report
+about: For the reporting of behavior not as described
+title: ''
+labels: bug, investigating
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is. Please do not file bugs for unreleased versions. The master branch is **not** to be considered in a production state.
+
+**To Reproduce**
+Steps to reproduce the behavior. List **all** steps to reproduce. All settings.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**System information:**
+ - OS, kernel version: `uname -a`
+ - mergerfs version: `mergerfs -V`
+ - mergerfs settings
+ - List of drives, filesystems, & sizes: `df -h`
+ - A strace of the application having a problem: `strace -f -o /tmp/app.strace.txt <cmd>` or `strace -f -p <appPID> -o /tmp/app.strace.txt`
+ - strace of mergerfs while app tried to do it's thing: `strace -f -p <mergerfsPID> -o /tmp/mergerfs.strace.txt`
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

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

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,10 @@
+---
+name: Question
+about: When you're looking for information
+title: ''
+labels: investigating, question
+assignees: ''
+
+---
+
+You can also ask questions on Discord for realtime help: https://discord.gg/MpAr69V

.travis.yml

@@ -26,9 +26,19 @@ matrix:
       dist: xenial
       compiler: clang
       sudo: required
+    - os: linux
+      dist: bionic
+      compiler: gcc
+      sudo: required
+    - os: linux
+      dist: bionic
+      compiler: clang
+      sudo: required
 
 script:
   - sudo -E apt-get install fakeroot
   - sudo -E make install-build-pkgs
-  - make
+  - make -j$(($(nproc) + 1))
   - make deb
+  - sudo -E dpkg -i ../*.deb
+  - mergerfs -v || true

LICENSE

@@ -1,7 +1,7 @@
 /*
   ISC License
 
-  Copyright (c) 2016, Antonio SJ Musumeci <trapexit@spawn.link>
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
 
   Permission to use, copy, modify, and/or distribute this software for any
   purpose with or without fee is hereby granted, provided that the above

Makefile

@@ -37,13 +37,12 @@ endif
 endif
 
 USE_XATTR = 1
-
-FUSE_CFLAGS = -D_FILE_OFFSET_BITS=64 -Ilibfuse/include
+UGID_USE_RWLOCK = 0
 
 ifeq ($(DEBUG),1)
-DEBUG_FLAGS := -g
+OPT_FLAGS := -O0 -g
 else
-DEBUG_FLAGS :=
+OPT_FLAGS := -O2
 endif
 
 ifeq ($(STATIC),1)
@@ -58,29 +57,33 @@ else
 LTO_FLAGS :=
 endif
 
-UGID_USE_RWLOCK = 0
-
-OPTS 	    = -O2
 SRC	    = $(wildcard src/*.cpp)
 OBJS        = $(SRC:src/%.cpp=build/%.o)
 DEPS        = $(SRC:src/%.cpp=build/%.d)
 MANPAGE     = mergerfs.1
-CXXFLAGS   += \
-	      $(OPTS) \
-              $(DEBUG_FLAGS) \
+CXXFLAGS    ?= ${OPT_FLAGS}
+CXXFLAGS    := \
+              ${CXXFLAGS} \
+              -std=c++0x \
               $(STATIC_FLAGS) \
               $(LTO_FLAGS) \
               -Wall \
-	      -Wno-unused-result \
-              $(FUSE_CFLAGS) \
-              -DFUSE_USE_VERSION=29 \
-              -MMD \
+              -Wno-unused-result \
+              -MMD
+FUSE_FLAGS = \
+              -Ilibfuse/include \
+              -D_FILE_OFFSET_BITS=64 \
+              -DFUSE_USE_VERSION=29
+MFS_FLAGS  = \
 	      -DUSE_XATTR=$(USE_XATTR) \
 	      -DUGID_USE_RWLOCK=$(UGID_USE_RWLOCK)
-LDFLAGS    += \
-	      -pthread \
-              -lrt
 
+LDFLAGS := \
+    ${LDFLAGS} \
+    -pthread \
+    -lrt
+
+DESTDIR       =
 PREFIX        = /usr/local
 EXEC_PREFIX   = $(PREFIX)
 DATAROOTDIR   = $(PREFIX)/share
@@ -108,7 +111,7 @@ objects: version build/stamp
 	$(MAKE) $(OBJS)
 
 build/mergerfs: libfuse objects
-	$(CXX) $(CXXFLAGS) $(CPPFLAGS) $(OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)
+	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) $(OBJS) -o $@ libfuse/build/libfuse.a $(LDFLAGS)
 
 mergerfs: build/mergerfs
 
@@ -128,7 +131,7 @@ build/stamp:
 	$(TOUCH) $@
 
 build/%.o: src/%.cpp
-	$(CXX) $(CXXFLAGS) $(CPPFLAGS) -c $< -o $@
+	$(CXX) $(CXXFLAGS) $(FUSE_FLAGS) $(MFS_FLAGS) $(CPPFLAGS) -c $< -o $@
 
 .PHONY: clean
 clean: rpm-clean
@@ -142,15 +145,15 @@ ifeq ($(GIT_REPO),1)
 endif
 
 .PHONY: install
-install: install-base install-mount.mergerfs install-man
+install: install-base install-mount-tools install-man
 
 install-base: build/mergerfs
 	$(MKDIR) -p "$(INSTALLBINDIR)"
 	$(INSTALL) -v -m 0755 build/mergerfs "$(INSTALLBINDIR)/mergerfs"
 
-install-mount.mergerfs: install-base
+install-mount-tools: install-base
 	$(MKDIR) -p "$(INSTALLBINDIR)"
-	$(LN) -s "mergerfs" "$(INSTALLBINDIR)/mount.mergerfs"
+	$(MAKE) -C libfuse install
 
 install-man: $(MANPAGE)
 	$(MKDIR) -p "$(INSTALLMAN1DIR)"
@@ -230,6 +233,6 @@ install-build-pkgs:
 
 .PHONY: libfuse
 libfuse:
-	$(MAKE) -C libfuse
+	$(MAKE) DEBUG=$(DEBUG) -C libfuse
 
 -include $(DEPS)

debian/mergerfs.postinst

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

debian/rules

@@ -2,7 +2,7 @@
 # -*- makefile -*-
 
 # Uncomment this to turn on verbose mode.
-#export DH_VERBOSE=1
+export DH_VERBOSE=1
 
 %:
 	dh $@ --parallel

libfuse/Makefile

@@ -1,21 +1,41 @@
-VERSION = "2.9.7-mergerfs_2.27.0"
-OPT = -O2
+VERSION = 2.9.7-mergerfs_2.30.0
 
-ifeq ($(DEBUG),1)
-DEBUG_FLAGS := -g
+OS := $(shell uname -s)
+ifeq ($(OS),Linux)
+UTILS := utils
+INSTALLUTILS := install-utils
 else
-DEBUG_FLAGS :=
+UTILS :=
+INSTALLUTILS :=
 endif
 
-DESTDIR = "/"
-BINDIR = "/bin"
-SBINDIR = "/sbin"
+ifeq ($(DEBUG),1)
+OPT_FLAGS := -O0 -g
+else
+OPT_FLAGS := -O2
+endif
+
+DESTDIR       =
+PREFIX        = /usr/local
+EXEC_PREFIX   = $(PREFIX)
+DATAROOTDIR   = $(PREFIX)/share
+DATADIR       = $(DATAROOTDIR)
+BINDIR        = $(EXEC_PREFIX)/bin
+SBINDIR       = /sbin
+MANDIR        = $(DATAROOTDIR)/man
+MAN1DIR       = $(MANDIR)/man1
+
+INSTALLBINDIR  = $(DESTDIR)$(BINDIR)
+INSTALLSBINDIR = $(DESTDIR)$(SBINDIR)
+INSTALLMAN1DIR = $(DESTDIR)$(MAN1DIR)
+
+AR ?= ar
+
 SRC   = \
 	lib/buffer.c \
-	lib/cuse_lowlevel.c \
+	lib/fuse_dirents.c \
 	lib/fuse.c \
 	lib/fuse_kern_chan.c \
-	lib/fuse_loop.c \
 	lib/fuse_loop_mt.c \
 	lib/fuse_lowlevel.c \
 	lib/fuse_mt.c \
@@ -26,25 +46,28 @@ SRC   = \
 	lib/mount.c
 OBJS = $(SRC:lib/%.c=build/%.o)
 DEPS = $(SRC:lib/%.c=build/%.d)
-
-CFLAGS += \
-	$(OPT) \
-	$(DEBUG_FLAGS) \
+CFLAGS ?= \
+	$(OPT_FLAGS)
+CFLAGS := \
+    ${CFLAGS} \
 	-Wall \
 	-pipe \
-	'-D_FILE_OFFSET_BITS=64' \
-	'-D_REENTRANT' \
-	'-DFUSE_USE_VERSION=29' \
-	'-DFUSERMOUNT_DIR="/usr/local/bin"' \
-	'-DPACKAGE_VERSION=$(VERSION)' \
+	-MMD
+FUSERMOUNT_DIR = $(BINDIR)
+FUSE_FLAGS = \
 	-Iinclude \
 	-Ibuild \
-	-MMD
-LDFLAGS += \
+	-D_REENTRANT \
+	-D_FILE_OFFSET_BITS=64 \
+	-DFUSE_USE_VERSION=29 \
+	-DPACKAGE_VERSION=\"$(VERSION)\" \
+	-DFUSERMOUNT_DIR=\"$(FUSERMOUNT_DIR)\"
+LDFLAGS := \
+	${LDFLAGS} \
 	-lrt \
 	-pthread
 
-all: build/libfuse.a
+all: build/libfuse.a $(UTILS)
 
 build/config.h: build/stamp
 	ecfd/build | tee build/config.h
@@ -57,28 +80,40 @@ objects: build/config.h
 	$(MAKE) $(OBJS)
 
 build/libfuse.a: objects
-	ar rcs build/libfuse.a $(OBJS)
+	${AR} rcs build/libfuse.a $(OBJS)
 
-build/mergerfs-mount: build/config.h util/fusermount.c lib/mount_util.c
-	$(CC) $(CFLAGS) -Ilib -o mergerfs-mount util/fusermount.c lib/mount_util.c
+utils: mergerfs-fusermount mount.mergerfs
 
-build/mount.mergerfs: build/libfuse.a util/mount.fuse.c
-	$(CC) $(CFLAGS) -o mount.mergerfs util/mount.fuse.c build/libfuse.a $(LDFLAGS)
+build/mergerfs-fusermount: build/config.h util/fusermount.c lib/mount_util.c
+	$(CC) $(CFLAGS) $(FUSE_FLAGS) -Ilib -o build/mergerfs-fusermount util/fusermount.c lib/mount_util.c
+
+mergerfs-fusermount: build/mergerfs-fusermount
+
+build/mount.mergerfs: build/libfuse.a util/mount.mergerfs.c
+	$(CC) $(CFLAGS) $(FUSE_FLAGS) -o build/mount.mergerfs util/mount.mergerfs.c build/libfuse.a $(LDFLAGS)
+
+mount.mergerfs: build/mount.mergerfs
 
 build/%.o: lib/%.c
-	$(CC) $(CFLAGS) -c $< -o $@
+	$(CC) $(CFLAGS) $(FUSE_FLAGS) -c $< -o $@
 
 clean:
 	rm -rf build
 
 distclean: clean
 
-install: build/mergerfs-mount build/mount.mergerfs
-	install -D build/mergerfs-mount "$(DESTDIR)$(BINDIR)/mergerfs-mount"
-	chown root:root "$(DESTDIR)$(BINDIR)/mergerfs-mount"
-	chmod u+s "$(DESTDIR)$(BINDIR)/mergerfs-mount"
-	install -D build/mount.mergerfs "$(DESTDIR)$(SBINDIR)/mount.mergerfs"
+strip:
+	strip --strip-all build/mount.mergerfs
+	strip --strip-all build/mergerfs-fusermount
 
-.PHONY: objects
+install-utils: mergerfs-fusermount mount.mergerfs strip
+	install -D build/mergerfs-fusermount "$(INSTALLBINDIR)/mergerfs-fusermount"
+	install -D build/mount.mergerfs "$(INSTALLSBINDIR)/mount.mergerfs"
+	chown root "$(INSTALLBINDIR)/mergerfs-fusermount"
+	chmod u+s "$(INSTALLBINDIR)/mergerfs-fusermount"
+
+install: $(INSTALLUTILS)
+
+.PHONY: objects strip utils install install-utils
 
 -include $(DEPS)

libfuse/fuse.pc.in

@@ -1,11 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: fuse
-Description: Filesystem in Userspace
-Version: @VERSION@
-Libs: -L${libdir} -lfuse -pthread
-Libs.private: @libfuse_libs@
-Cflags: -I${includedir}/fuse -D_FILE_OFFSET_BITS=64

libfuse/include/Makefile.am

@@ -1,17 +0,0 @@
-## Process this file with automake to produce Makefile.in
-
-fuseincludedir=$(includedir)/fuse
-
-fuseinclude_HEADERS = \
-	fuse.h			\
-	fuse_compat.h		\
-	fuse_common.h		\
-	fuse_common_compat.h    \
-	fuse_lowlevel.h		\
-	fuse_lowlevel_compat.h	\
-	fuse_opt.h		\
-	cuse_lowlevel.h
-
-include_HEADERS = old/fuse.h ulockmgr.h
-
-noinst_HEADERS = fuse_kernel.h

libfuse/include/cuse_lowlevel.h

@@ -1,87 +0,0 @@
-/*
-  CUSE: Character device in Userspace
-  Copyright (C) 2008-2009  SUSE Linux Products GmbH
-  Copyright (C) 2008-2009  Tejun Heo <tj@kernel.org>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB.
-
-  Read example/cusexmp.c for usages.
-*/
-
-#ifndef _CUSE_LOWLEVEL_H_
-#define _CUSE_LOWLEVEL_H_
-
-#ifndef FUSE_USE_VERSION
-#define FUSE_USE_VERSION 29
-#endif
-
-#include "fuse_lowlevel.h"
-
-#include <fcntl.h>
-#include <sys/types.h>
-#include <sys/uio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define CUSE_UNRESTRICTED_IOCTL		(1 << 0) /* use unrestricted ioctl */
-
-struct fuse_session;
-
-struct cuse_info {
-	unsigned	dev_major;
-	unsigned	dev_minor;
-	unsigned	dev_info_argc;
-	const char	**dev_info_argv;
-	unsigned	flags;
-};
-
-/*
- * Most ops behave almost identically to the matching fuse_lowlevel
- * ops except that they don't take @ino.
- *
- * init_done	: called after initialization is complete
- * read/write	: always direct IO, simultaneous operations allowed
- * ioctl	: might be in unrestricted mode depending on ci->flags
- */
-struct cuse_lowlevel_ops {
-	void (*init) (void *userdata, struct fuse_conn_info *conn);
-	void (*init_done) (void *userdata);
-	void (*destroy) (void *userdata);
-	void (*open) (fuse_req_t req, struct fuse_file_info *fi);
-	void (*read) (fuse_req_t req, size_t size, off_t off,
-		      struct fuse_file_info *fi);
-	void (*write) (fuse_req_t req, const char *buf, size_t size, off_t off,
-		       struct fuse_file_info *fi);
-	void (*flush) (fuse_req_t req, struct fuse_file_info *fi);
-	void (*release) (fuse_req_t req, struct fuse_file_info *fi);
-	void (*fsync) (fuse_req_t req, int datasync, struct fuse_file_info *fi);
-	void (*ioctl) (fuse_req_t req, int cmd, void *arg,
-		       struct fuse_file_info *fi, unsigned int flags,
-		       const void *in_buf, size_t in_bufsz, size_t out_bufsz);
-	void (*poll) (fuse_req_t req, struct fuse_file_info *fi,
-		      struct fuse_pollhandle *ph);
-};
-
-struct fuse_session *cuse_lowlevel_new(struct fuse_args *args,
-				       const struct cuse_info *ci,
-				       const struct cuse_lowlevel_ops *clop,
-				       void *userdata);
-
-struct fuse_session *cuse_lowlevel_setup(int argc, char *argv[],
-					 const struct cuse_info *ci,
-					 const struct cuse_lowlevel_ops *clop,
-					 int *multithreaded, void *userdata);
-
-void cuse_lowlevel_teardown(struct fuse_session *se);
-
-int cuse_lowlevel_main(int argc, char *argv[], const struct cuse_info *ci,
-		       const struct cuse_lowlevel_ops *clop, void *userdata);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* _CUSE_LOWLEVEL_H_ */

libfuse/include/extern_c.h

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

libfuse/include/fuse_attr.h

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

libfuse/include/fuse_common.h

@@ -15,7 +15,10 @@
 #ifndef _FUSE_COMMON_H_
 #define _FUSE_COMMON_H_
 
+#include "extern_c.h"
 #include "fuse_opt.h"
+#include "fuse_timeouts.h"
+
 #include <stdint.h>
 #include <sys/types.h>
 
@@ -33,58 +36,60 @@
 #error Please add -D_FILE_OFFSET_BITS=64 to your compile flags!
 #endif
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+#define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
+#define FUSE_MAX_MAX_PAGES 256
+
+EXTERN_C_BEGIN
 
 /**
  * Information about open files
  *
  * Changed in version 2.5
  */
-struct fuse_file_info {
-	/** Open flags.	 Available in open() and release() */
-	int flags;
+struct
+fuse_file_info
+{
+  /** Open flags. Available in open() and release() */
+  int flags;
 
-	/** Old file handle, don't use */
-	unsigned long fh_old;
+  /** In case of a write operation indicates if this was caused by a
+      writepage */
+  uint32_t writepage : 1;
 
-	/** In case of a write operation indicates if this was caused by a
-	    writepage */
-	int writepage;
+  /** Can be filled in by open, to use direct I/O on this file.
+      Introduced in version 2.4 */
+  uint32_t direct_io : 1;
 
-	/** Can be filled in by open, to use direct I/O on this file.
-	    Introduced in version 2.4 */
-	unsigned int direct_io : 1;
+  /** Can be filled in by open, to indicate, that cached file data
+      need not be invalidated.  Introduced in version 2.4 */
+  uint32_t keep_cache : 1;
 
-	/** Can be filled in by open, to indicate, that cached file data
-	    need not be invalidated.  Introduced in version 2.4 */
-	unsigned int keep_cache : 1;
+  /** Indicates a flush operation.  Set in flush operation, also
+      maybe set in highlevel lock operation and lowlevel release
+      operation.	Introduced in version 2.6 */
+  uint32_t flush : 1;
 
-	/** Indicates a flush operation.  Set in flush operation, also
-	    maybe set in highlevel lock operation and lowlevel release
-	    operation.	Introduced in version 2.6 */
-	unsigned int flush : 1;
+  /** Can be filled in by open, to indicate that the file is not
+      seekable.  Introduced in version 2.8 */
+  uint32_t nonseekable : 1;
 
-	/** Can be filled in by open, to indicate that the file is not
-	    seekable.  Introduced in version 2.8 */
-	unsigned int nonseekable : 1;
+  /* Indicates that flock locks for this file should be
+     released.  If set, lock_owner shall contain a valid value.
+     May only be set in ->release().  Introduced in version
+     2.9 */
+  uint32_t flock_release : 1;
 
-	/* Indicates that flock locks for this file should be
-	   released.  If set, lock_owner shall contain a valid value.
-	   May only be set in ->release().  Introduced in version
-	   2.9 */
-	unsigned int flock_release : 1;
+  /* Requests the kernel to cache entries returned by readdir */
+  uint32_t cache_readdir : 1;
 
-	/** Padding.  Do not use*/
-	unsigned int padding : 27;
+  uint32_t auto_cache : 1;
 
-	/** File handle.  May be filled in by filesystem in open().
-	    Available in all other file operations */
-	uint64_t fh;
+  /** File handle.  May be filled in by filesystem in open().
+      Available in all other file operations */
+  uint64_t fh;
 
-	/** Lock owner id.  Available in locking operations and flush */
-	uint64_t lock_owner;
+  /** Lock owner id.  Available in locking operations and flush */
+  uint64_t lock_owner;
 };
 
 /**
@@ -100,22 +105,27 @@ struct fuse_file_info {
  * FUSE_CAP_SPLICE_MOVE: ability to move data to the fuse device with splice()
  * FUSE_CAP_SPLICE_READ: ability to use splice() to read from the fuse device
  * FUSE_CAP_IOCTL_DIR: ioctl support on directories
+ * FUSE_CAP_CACHE_SYMLINKS: cache READLINK responses
  */
-#define FUSE_CAP_ASYNC_READ      (1 << 0)
-#define FUSE_CAP_POSIX_LOCKS     (1 << 1)
-#define FUSE_CAP_ATOMIC_O_TRUNC  (1 << 3)
-#define FUSE_CAP_EXPORT_SUPPORT  (1 << 4)
-#define FUSE_CAP_BIG_WRITES      (1 << 5)
-#define FUSE_CAP_DONT_MASK       (1 << 6)
-#define FUSE_CAP_SPLICE_WRITE    (1 << 7)
-#define FUSE_CAP_SPLICE_MOVE     (1 << 8)
-#define FUSE_CAP_SPLICE_READ     (1 << 9)
-#define FUSE_CAP_FLOCK_LOCKS     (1 << 10)
-#define FUSE_CAP_IOCTL_DIR       (1 << 11)
-#define FUSE_CAP_ASYNC_DIO       (1 << 15)
-#define FUSE_CAP_PARALLEL_DIROPS (1 << 18)
-#define FUSE_CAP_POSIX_ACL       (1 << 19)
-
+#define FUSE_CAP_ASYNC_READ        (1 << 0)
+#define FUSE_CAP_POSIX_LOCKS       (1 << 1)
+#define FUSE_CAP_ATOMIC_O_TRUNC    (1 << 3)
+#define FUSE_CAP_EXPORT_SUPPORT    (1 << 4)
+#define FUSE_CAP_BIG_WRITES        (1 << 5)
+#define FUSE_CAP_DONT_MASK         (1 << 6)
+#define FUSE_CAP_SPLICE_WRITE      (1 << 7)
+#define FUSE_CAP_SPLICE_MOVE       (1 << 8)
+#define FUSE_CAP_SPLICE_READ       (1 << 9)
+#define FUSE_CAP_FLOCK_LOCKS       (1 << 10)
+#define FUSE_CAP_IOCTL_DIR         (1 << 11)
+#define FUSE_CAP_READDIR_PLUS      (1 << 13)
+#define FUSE_CAP_READDIR_PLUS_AUTO (1 << 14)
+#define FUSE_CAP_ASYNC_DIO         (1 << 15)
+#define FUSE_CAP_WRITEBACK_CACHE   (1 << 16)
+#define FUSE_CAP_PARALLEL_DIROPS   (1 << 18)
+#define FUSE_CAP_POSIX_ACL         (1 << 19)
+#define FUSE_CAP_CACHE_SYMLINKS    (1 << 20)
+#define FUSE_CAP_MAX_PAGES         (1 << 21)
 
 /**
  * Ioctl flags
@@ -142,55 +152,55 @@ struct fuse_file_info {
  * value must usually be smaller than the indicated value.
  */
 struct fuse_conn_info {
-	/**
-	 * Major version of the protocol (read-only)
-	 */
-	unsigned proto_major;
+  /**
+   * Major version of the protocol (read-only)
+   */
+  unsigned proto_major;
 
-	/**
-	 * Minor version of the protocol (read-only)
-	 */
-	unsigned proto_minor;
+  /**
+   * Minor version of the protocol (read-only)
+   */
+  unsigned proto_minor;
 
-	/**
-	 * Is asynchronous read supported (read-write)
-	 */
-	unsigned async_read;
+  /**
+   * Maximum size of the write buffer
+   */
+  unsigned max_write;
 
-	/**
-	 * Maximum size of the write buffer
-	 */
-	unsigned max_write;
+  /**
+   * Maximum readahead
+   */
+  unsigned max_readahead;
 
-	/**
-	 * Maximum readahead
-	 */
-	unsigned max_readahead;
+  /**
+   * Capability flags, that the kernel supports
+   */
+  unsigned capable;
 
-	/**
-	 * Capability flags, that the kernel supports
-	 */
-	unsigned capable;
+  /**
+   * Capability flags, that the filesystem wants to enable
+   */
+  unsigned want;
 
-	/**
-	 * Capability flags, that the filesystem wants to enable
-	 */
-	unsigned want;
+  /**
+   * Maximum number of backgrounded requests
+   */
+  unsigned max_background;
 
-	/**
-	 * Maximum number of backgrounded requests
-	 */
-	unsigned max_background;
+  /**
+   * Kernel congestion threshold parameter
+   */
+  unsigned congestion_threshold;
 
-	/**
-	 * Kernel congestion threshold parameter
-	 */
-	unsigned congestion_threshold;
+  /**
+   * Max pages
+   */
+  uint16_t max_pages;
 
-	/**
-	 * For future use.
-	 */
-	unsigned reserved[23];
+  /**
+   * For future use.
+   */
+  unsigned reserved[22];
 };
 
 struct fuse_session;
@@ -207,7 +217,8 @@ struct fuse_pollhandle;
  * @param args argument vector
  * @return the communication channel on success, NULL on failure
  */
-struct fuse_chan *fuse_mount(const char *mountpoint, struct fuse_args *args);
+struct fuse_chan *fuse_mount(const char       *mountpoint,
+                             struct fuse_args *args);
 
 /**
  * Umount a FUSE mountpoint
@@ -224,7 +235,6 @@ void fuse_unmount(const char *mountpoint, struct fuse_chan *ch);
  *
  *   '-f'	     foreground
  *   '-d' '-odebug'  foreground, but keep the debug option
- *   '-s'	     single threaded
  *   '-h' '--help'   help
  *   '-ho'	     help without header
  *   '-ofsname=..'   file system name, if not present, then set to the program
@@ -234,12 +244,12 @@ void fuse_unmount(const char *mountpoint, struct fuse_chan *ch);
  *
  * @param args argument vector
  * @param mountpoint the returned mountpoint, should be freed after use
- * @param multithreaded set to 1 unless the '-s' option is present
  * @param foreground set to 1 if one of the relevant options is present
  * @return 0 on success, -1 on failure
  */
-int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint,
-		       int *multithreaded, int *foreground);
+int fuse_parse_cmdline(struct fuse_args  *args,
+                       char             **mountpoint,
+                       int               *foreground);
 
 /**
  * Go into the background
@@ -271,73 +281,73 @@ void fuse_pollhandle_destroy(struct fuse_pollhandle *ph);
  * Buffer flags
  */
 enum fuse_buf_flags {
-	/**
-	 * Buffer contains a file descriptor
-	 *
-	 * If this flag is set, the .fd field is valid, otherwise the
-	 * .mem fields is valid.
-	 */
-	FUSE_BUF_IS_FD		= (1 << 1),
+  /**
+   * Buffer contains a file descriptor
+   *
+   * If this flag is set, the .fd field is valid, otherwise the
+   * .mem fields is valid.
+   */
+  FUSE_BUF_IS_FD		= (1 << 1),
 
-	/**
-	 * Seek on the file descriptor
-	 *
-	 * If this flag is set then the .pos field is valid and is
-	 * used to seek to the given offset before performing
-	 * operation on file descriptor.
-	 */
-	FUSE_BUF_FD_SEEK	= (1 << 2),
+  /**
+   * Seek on the file descriptor
+   *
+   * If this flag is set then the .pos field is valid and is
+   * used to seek to the given offset before performing
+   * operation on file descriptor.
+   */
+  FUSE_BUF_FD_SEEK	= (1 << 2),
 
-	/**
-	 * Retry operation on file descriptor
-	 *
-	 * If this flag is set then retry operation on file descriptor
-	 * until .size bytes have been copied or an error or EOF is
-	 * detected.
-	 */
-	FUSE_BUF_FD_RETRY	= (1 << 3),
+  /**
+   * Retry operation on file descriptor
+   *
+   * If this flag is set then retry operation on file descriptor
+   * until .size bytes have been copied or an error or EOF is
+   * detected.
+   */
+  FUSE_BUF_FD_RETRY	= (1 << 3),
 };
 
 /**
  * Buffer copy flags
  */
 enum fuse_buf_copy_flags {
-	/**
-	 * Don't use splice(2)
-	 *
-	 * Always fall back to using read and write instead of
-	 * splice(2) to copy data from one file descriptor to another.
-	 *
-	 * If this flag is not set, then only fall back if splice is
-	 * unavailable.
-	 */
-	FUSE_BUF_NO_SPLICE	= (1 << 1),
+  /**
+   * Don't use splice(2)
+   *
+   * Always fall back to using read and write instead of
+   * splice(2) to copy data from one file descriptor to another.
+   *
+   * If this flag is not set, then only fall back if splice is
+   * unavailable.
+   */
+  FUSE_BUF_NO_SPLICE	= (1 << 1),
 
-	/**
-	 * Force splice
-	 *
-	 * Always use splice(2) to copy data from one file descriptor
-	 * to another.  If splice is not available, return -EINVAL.
-	 */
-	FUSE_BUF_FORCE_SPLICE	= (1 << 2),
+  /**
+   * Force splice
+   *
+   * Always use splice(2) to copy data from one file descriptor
+   * to another.  If splice is not available, return -EINVAL.
+   */
+  FUSE_BUF_FORCE_SPLICE	= (1 << 2),
 
-	/**
-	 * Try to move data with splice.
-	 *
-	 * If splice is used, try to move pages from the source to the
-	 * destination instead of copying.  See documentation of
-	 * SPLICE_F_MOVE in splice(2) man page.
-	 */
-	FUSE_BUF_SPLICE_MOVE	= (1 << 3),
+  /**
+   * Try to move data with splice.
+   *
+   * If splice is used, try to move pages from the source to the
+   * destination instead of copying.  See documentation of
+   * SPLICE_F_MOVE in splice(2) man page.
+   */
+  FUSE_BUF_SPLICE_MOVE	= (1 << 3),
 
-	/**
-	 * Don't block on the pipe when copying data with splice
-	 *
-	 * Makes the operations on the pipe non-blocking (if the pipe
-	 * is full or empty).  See SPLICE_F_NONBLOCK in the splice(2)
-	 * man page.
-	 */
-	FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
+  /**
+   * Don't block on the pipe when copying data with splice
+   *
+   * Makes the operations on the pipe non-blocking (if the pipe
+   * is full or empty).  See SPLICE_F_NONBLOCK in the splice(2)
+   * man page.
+   */
+  FUSE_BUF_SPLICE_NONBLOCK= (1 << 4),
 };
 
 /**
@@ -347,36 +357,36 @@ enum fuse_buf_copy_flags {
  * be supplied as a memory pointer or as a file descriptor
  */
 struct fuse_buf {
-	/**
-	 * Size of data in bytes
-	 */
-	size_t size;
+  /**
+   * Size of data in bytes
+   */
+  size_t size;
 
-	/**
-	 * Buffer flags
-	 */
-	enum fuse_buf_flags flags;
+  /**
+   * Buffer flags
+   */
+  enum fuse_buf_flags flags;
 
-	/**
-	 * Memory pointer
-	 *
-	 * Used unless FUSE_BUF_IS_FD flag is set.
-	 */
-	void *mem;
+  /**
+   * Memory pointer
+   *
+   * Used unless FUSE_BUF_IS_FD flag is set.
+   */
+  void *mem;
 
-	/**
-	 * File descriptor
-	 *
-	 * Used if FUSE_BUF_IS_FD flag is set.
-	 */
-	int fd;
+  /**
+   * File descriptor
+   *
+   * Used if FUSE_BUF_IS_FD flag is set.
+   */
+  int fd;
 
-	/**
-	 * File position
-	 *
-	 * Used if FUSE_BUF_FD_SEEK flag is set.
-	 */
-	off_t pos;
+  /**
+   * File position
+   *
+   * Used if FUSE_BUF_FD_SEEK flag is set.
+   */
+  off_t pos;
 };
 
 /**
@@ -388,41 +398,41 @@ struct fuse_buf {
  * Allocate dynamically to add more than one buffer.
  */
 struct fuse_bufvec {
-	/**
-	 * Number of buffers in the array
-	 */
-	size_t count;
+  /**
+   * Number of buffers in the array
+   */
+  size_t count;
 
-	/**
-	 * Index of current buffer within the array
-	 */
-	size_t idx;
+  /**
+   * Index of current buffer within the array
+   */
+  size_t idx;
 
-	/**
-	 * Current offset within the current buffer
-	 */
-	size_t off;
+  /**
+   * Current offset within the current buffer
+   */
+  size_t off;
 
-	/**
-	 * Array of buffers
-	 */
-	struct fuse_buf buf[1];
+  /**
+   * Array of buffers
+   */
+  struct fuse_buf buf[1];
 };
 
 /* Initialize bufvec with a single buffer of given size */
-#define FUSE_BUFVEC_INIT(size__) 				\
-	((struct fuse_bufvec) {					\
-		/* .count= */ 1,				\
-		/* .idx =  */ 0,				\
-		/* .off =  */ 0,				\
-		/* .buf =  */ { /* [0] = */ {			\
-			/* .size =  */ (size__),		\
-			/* .flags = */ (enum fuse_buf_flags) 0,	\
-			/* .mem =   */ NULL,			\
-			/* .fd =    */ -1,			\
-			/* .pos =   */ 0,			\
-		} }						\
-	} )
+#define FUSE_BUFVEC_INIT(size__)                        \
+  ((struct fuse_bufvec) {                               \
+    /* .count= */ 1,                                    \
+      /* .idx =  */ 0,                                  \
+      /* .off =  */ 0,                                  \
+      /* .buf =  */ { /* [0] = */ {			\
+        /* .size =  */ (size__),                        \
+          /* .flags = */ (enum fuse_buf_flags) 0,	\
+          /* .mem =   */ NULL,                          \
+          /* .fd =    */ -1,                            \
+          /* .pos =   */ 0,                             \
+          } }						\
+  } )
 
 /**
  * Get total size of data in a fuse buffer vector
@@ -441,7 +451,7 @@ size_t fuse_buf_size(const struct fuse_bufvec *bufv);
  * @return actual number of bytes copied or -errno on error
  */
 ssize_t fuse_buf_copy(struct fuse_bufvec *dst, struct fuse_bufvec *src,
-		      enum fuse_buf_copy_flags flags);
+                      enum fuse_buf_copy_flags flags);
 
 /* ----------------------------------------------------------- *
  * Signal handling					       *
@@ -468,42 +478,6 @@ int fuse_set_signal_handlers(struct fuse_session *se);
  */
 void fuse_remove_signal_handlers(struct fuse_session *se);
 
-/* ----------------------------------------------------------- *
- * Compatibility stuff					       *
- * ----------------------------------------------------------- */
-
-#if FUSE_USE_VERSION < 26
-#    ifdef __FreeBSD__
-#	 if FUSE_USE_VERSION < 25
-#	     error On FreeBSD API version 25 or greater must be used
-#	 endif
-#    endif
-#    include "fuse_common_compat.h"
-#    undef FUSE_MINOR_VERSION
-#    undef fuse_main
-#    define fuse_unmount fuse_unmount_compat22
-#    if FUSE_USE_VERSION == 25
-#	 define FUSE_MINOR_VERSION 5
-#	 define fuse_mount fuse_mount_compat25
-#    elif FUSE_USE_VERSION == 24 || FUSE_USE_VERSION == 22
-#	 define FUSE_MINOR_VERSION 4
-#	 define fuse_mount fuse_mount_compat22
-#    elif FUSE_USE_VERSION == 21
-#	 define FUSE_MINOR_VERSION 1
-#	 define fuse_mount fuse_mount_compat22
-#    elif FUSE_USE_VERSION == 11
-#	 warning Compatibility with API version 11 is deprecated
-#	 undef FUSE_MAJOR_VERSION
-#	 define FUSE_MAJOR_VERSION 1
-#	 define FUSE_MINOR_VERSION 1
-#	 define fuse_mount fuse_mount_compat1
-#    else
-#	 error Compatibility with API version other than 21, 22, 24, 25 and 11 not supported
-#    endif
-#endif
-
-#ifdef __cplusplus
-}
-#endif
+EXTERN_C_END
 
 #endif /* _FUSE_COMMON_H_ */

libfuse/include/fuse_common_compat.h

@@ -1,26 +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.
-*/
-
-/* these definitions provide source compatibility to prior versions.
-   Do not include this file directly! */
-
-struct fuse_file_info_compat {
-	int flags;
-	unsigned long fh;
-	int writepage;
-	unsigned int direct_io : 1;
-	unsigned int keep_cache : 1;
-};
-
-int fuse_mount_compat25(const char *mountpoint, struct fuse_args *args);
-
-int fuse_mount_compat22(const char *mountpoint, const char *opts);
-
-int fuse_mount_compat1(const char *mountpoint, const char *args[]);
-
-void fuse_unmount_compat22(const char *mountpoint);

libfuse/include/fuse_compat.h

@@ -1,201 +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.
-*/
-
-/* these definitions provide source compatibility to prior versions.
-   Do not include this file directly! */
-
-struct fuse_operations_compat25 {
-	int (*getattr) (const char *, struct stat *);
-	int (*readlink) (const char *, char *, size_t);
-	int (*getdir) (const char *, fuse_dirh_t, fuse_dirfil_t);
-	int (*mknod) (const char *, mode_t, dev_t);
-	int (*mkdir) (const char *, mode_t);
-	int (*unlink) (const char *);
-	int (*rmdir) (const char *);
-	int (*symlink) (const char *, const char *);
-	int (*rename) (const char *, const char *);
-	int (*link) (const char *, const char *);
-	int (*chmod) (const char *, mode_t);
-	int (*chown) (const char *, uid_t, gid_t);
-	int (*truncate) (const char *, off_t);
-	int (*utime) (const char *, struct utimbuf *);
-	int (*open) (const char *, struct fuse_file_info *);
-	int (*read) (const char *, char *, size_t, off_t,
-		     struct fuse_file_info *);
-	int (*write) (const char *, const char *, size_t, off_t,
-		      struct fuse_file_info *);
-	int (*statfs) (const char *, struct statvfs *);
-	int (*flush) (const char *, struct fuse_file_info *);
-	int (*release) (const char *, struct fuse_file_info *);
-	int (*fsync) (const char *, int, struct fuse_file_info *);
-	int (*setxattr) (const char *, const char *, const char *, size_t, int);
-	int (*getxattr) (const char *, const char *, char *, size_t);
-	int (*listxattr) (const char *, char *, size_t);
-	int (*removexattr) (const char *, const char *);
-	int (*opendir) (const char *, struct fuse_file_info *);
-	int (*readdir) (const char *, void *, fuse_fill_dir_t, off_t,
-			struct fuse_file_info *);
-	int (*releasedir) (const char *, struct fuse_file_info *);
-	int (*fsyncdir) (const char *, int, struct fuse_file_info *);
-	void *(*init) (void);
-	void (*destroy) (void *);
-	int (*access) (const char *, int);
-	int (*create) (const char *, mode_t, struct fuse_file_info *);
-	int (*ftruncate) (const char *, off_t, struct fuse_file_info *);
-	int (*fgetattr) (const char *, struct stat *, struct fuse_file_info *);
-};
-
-struct fuse *fuse_new_compat25(int fd, struct fuse_args *args,
-			       const struct fuse_operations_compat25 *op,
-			       size_t op_size);
-
-int fuse_main_real_compat25(int argc, char *argv[],
-			    const struct fuse_operations_compat25 *op,
-			    size_t op_size);
-
-struct fuse *fuse_setup_compat25(int argc, char *argv[],
-				 const struct fuse_operations_compat25 *op,
-				 size_t op_size, char **mountpoint,
-				 int *multithreaded, int *fd);
-
-void fuse_teardown_compat22(struct fuse *fuse, int fd, char *mountpoint);
-
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
-#include <sys/statfs.h>
-
-struct fuse_operations_compat22 {
-	int (*getattr) (const char *, struct stat *);
-	int (*readlink) (const char *, char *, size_t);
-	int (*getdir) (const char *, fuse_dirh_t, fuse_dirfil_t);
-	int (*mknod) (const char *, mode_t, dev_t);
-	int (*mkdir) (const char *, mode_t);
-	int (*unlink) (const char *);
-	int (*rmdir) (const char *);
-	int (*symlink) (const char *, const char *);
-	int (*rename) (const char *, const char *);
-	int (*link) (const char *, const char *);
-	int (*chmod) (const char *, mode_t);
-	int (*chown) (const char *, uid_t, gid_t);
-	int (*truncate) (const char *, off_t);
-	int (*utime) (const char *, struct utimbuf *);
-	int (*open) (const char *, struct fuse_file_info_compat *);
-	int (*read) (const char *, char *, size_t, off_t,
-		     struct fuse_file_info_compat *);
-	int (*write) (const char *, const char *, size_t, off_t,
-		      struct fuse_file_info_compat *);
-	int (*statfs) (const char *, struct statfs *);
-	int (*flush) (const char *, struct fuse_file_info_compat *);
-	int (*release) (const char *, struct fuse_file_info_compat *);
-	int (*fsync) (const char *, int, struct fuse_file_info_compat *);
-	int (*setxattr) (const char *, const char *, const char *, size_t, int);
-	int (*getxattr) (const char *, const char *, char *, size_t);
-	int (*listxattr) (const char *, char *, size_t);
-	int (*removexattr) (const char *, const char *);
-	int (*opendir) (const char *, struct fuse_file_info_compat *);
-	int (*readdir) (const char *, void *, fuse_fill_dir_t, off_t,
-			struct fuse_file_info_compat *);
-	int (*releasedir) (const char *, struct fuse_file_info_compat *);
-	int (*fsyncdir) (const char *, int, struct fuse_file_info_compat *);
-	void *(*init) (void);
-	void (*destroy) (void *);
-};
-
-struct fuse *fuse_new_compat22(int fd, const char *opts,
-			       const struct fuse_operations_compat22 *op,
-			       size_t op_size);
-
-struct fuse *fuse_setup_compat22(int argc, char *argv[],
-				 const struct fuse_operations_compat22 *op,
-				 size_t op_size, char **mountpoint,
-				 int *multithreaded, int *fd);
-
-int fuse_main_real_compat22(int argc, char *argv[],
-			    const struct fuse_operations_compat22 *op,
-			    size_t op_size);
-
-typedef int (*fuse_dirfil_t_compat) (fuse_dirh_t h, const char *name, int type);
-struct fuse_operations_compat2 {
-	int (*getattr)	   (const char *, struct stat *);
-	int (*readlink)	   (const char *, char *, size_t);
-	int (*getdir)	   (const char *, fuse_dirh_t, fuse_dirfil_t_compat);
-	int (*mknod)	   (const char *, mode_t, dev_t);
-	int (*mkdir)	   (const char *, mode_t);
-	int (*unlink)	   (const char *);
-	int (*rmdir)	   (const char *);
-	int (*symlink)	   (const char *, const char *);
-	int (*rename)	   (const char *, const char *);
-	int (*link)	   (const char *, const char *);
-	int (*chmod)	   (const char *, mode_t);
-	int (*chown)	   (const char *, uid_t, gid_t);
-	int (*truncate)	   (const char *, off_t);
-	int (*utime)	   (const char *, struct utimbuf *);
-	int (*open)	   (const char *, int);
-	int (*read)	   (const char *, char *, size_t, off_t);
-	int (*write)	   (const char *, const char *, size_t, off_t);
-	int (*statfs)	   (const char *, struct statfs *);
-	int (*flush)	   (const char *);
-	int (*release)	   (const char *, int);
-	int (*fsync)	   (const char *, int);
-	int (*setxattr)	   (const char *, const char *, const char *,
-			    size_t, int);
-	int (*getxattr)	   (const char *, const char *, char *, size_t);
-	int (*listxattr)   (const char *, char *, size_t);
-	int (*removexattr) (const char *, const char *);
-};
-
-int fuse_main_compat2(int argc, char *argv[],
-		      const struct fuse_operations_compat2 *op);
-
-struct fuse *fuse_new_compat2(int fd, const char *opts,
-			      const struct fuse_operations_compat2 *op);
-
-struct fuse *fuse_setup_compat2(int argc, char *argv[],
-				const struct fuse_operations_compat2 *op,
-				char **mountpoint, int *multithreaded, int *fd);
-
-struct fuse_statfs_compat1 {
-	long block_size;
-	long blocks;
-	long blocks_free;
-	long files;
-	long files_free;
-	long namelen;
-};
-
-struct fuse_operations_compat1 {
-	int (*getattr)	(const char *, struct stat *);
-	int (*readlink) (const char *, char *, size_t);
-	int (*getdir)	(const char *, fuse_dirh_t, fuse_dirfil_t_compat);
-	int (*mknod)	(const char *, mode_t, dev_t);
-	int (*mkdir)	(const char *, mode_t);
-	int (*unlink)	(const char *);
-	int (*rmdir)	(const char *);
-	int (*symlink)	(const char *, const char *);
-	int (*rename)	(const char *, const char *);
-	int (*link)	(const char *, const char *);
-	int (*chmod)	(const char *, mode_t);
-	int (*chown)	(const char *, uid_t, gid_t);
-	int (*truncate) (const char *, off_t);
-	int (*utime)	(const char *, struct utimbuf *);
-	int (*open)	(const char *, int);
-	int (*read)	(const char *, char *, size_t, off_t);
-	int (*write)	(const char *, const char *, size_t, off_t);
-	int (*statfs)	(struct fuse_statfs_compat1 *);
-	int (*release)	(const char *, int);
-	int (*fsync)	(const char *, int);
-};
-
-#define FUSE_DEBUG_COMPAT1	 (1 << 1)
-
-struct fuse *fuse_new_compat1(int fd, int flags,
-			      const struct fuse_operations_compat1 *op);
-
-void fuse_main_compat1(int argc, char *argv[],
-		       const struct fuse_operations_compat1 *op);
-
-#endif /* __FreeBSD__ || __NetBSD__ */

libfuse/include/fuse_dirent.h

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

libfuse/include/fuse_direntplus.h

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

libfuse/include/fuse_dirents.h

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

libfuse/include/fuse_entry.h

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

libfuse/include/fuse_kernel.h

@@ -38,12 +38,50 @@
  *
  * Protocol changelog:
  *
+ * 7.1:
+ *  - add the following messages:
+ *      FUSE_SETATTR, FUSE_SYMLINK, FUSE_MKNOD, FUSE_MKDIR, FUSE_UNLINK,
+ *      FUSE_RMDIR, FUSE_RENAME, FUSE_LINK, FUSE_OPEN, FUSE_READ, FUSE_WRITE,
+ *      FUSE_RELEASE, FUSE_FSYNC, FUSE_FLUSH, FUSE_SETXATTR, FUSE_GETXATTR,
+ *      FUSE_LISTXATTR, FUSE_REMOVEXATTR, FUSE_OPENDIR, FUSE_READDIR,
+ *      FUSE_RELEASEDIR
+ *  - add padding to messages to accommodate 32-bit servers on 64-bit kernels
+ *
+ * 7.2:
+ *  - add FOPEN_DIRECT_IO and FOPEN_KEEP_CACHE flags
+ *  - add FUSE_FSYNCDIR message
+ *
+ * 7.3:
+ *  - add FUSE_ACCESS message
+ *  - add FUSE_CREATE message
+ *  - add filehandle to fuse_setattr_in
+ *
+ * 7.4:
+ *  - add frsize to fuse_kstatfs
+ *  - clean up request size limit checking
+ *
+ * 7.5:
+ *  - add flags and max_write to fuse_init_out
+ *
+ * 7.6:
+ *  - add max_readahead to fuse_init_in and fuse_init_out
+ *
+ * 7.7:
+ *  - add FUSE_INTERRUPT message
+ *  - add POSIX file lock support
+ *
+ * 7.8:
+ *  - add lock_owner and flags fields to fuse_release_in
+ *  - add FUSE_BMAP message
+ *  - add FUSE_DESTROY message
+ *
  * 7.9:
  *  - new fuse_getattr_in input argument of GETATTR
  *  - add lk_flags in fuse_lk_in
  *  - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
  *  - add blksize field to fuse_attr
  *  - add file flags field to fuse_read_in and fuse_write_in
+ *  - Add ATIME_NOW and MTIME_NOW flags to fuse_setattr_in
  *
  * 7.10
  *  - add nonseekable open flag
@@ -54,7 +92,7 @@
  *  - add POLL message and NOTIFY_POLL notification
  *
  * 7.12
- *  - add umask flag to input argument of open, mknod and mkdir
+ *  - add umask flag to input argument of create, mknod and mkdir
  *  - add notification messages for invalidation of inodes and
  *    directory entries
  *
@@ -119,6 +157,21 @@
  *
  *  7.28
  *  - add FUSE_COPY_FILE_RANGE
+ *  - add FOPEN_CACHE_DIR
+ *  - add FUSE_MAX_PAGES, add max_pages to init_out
+ *  - add FUSE_CACHE_SYMLINKS
+ *
+ *  7.29
+ *  - add FUSE_NO_OPENDIR_SUPPORT flag
+ *
+ *  7.30
+ *  - add FUSE_EXPLICIT_INVAL_DATA
+ *  - add FUSE_IOCTL_COMPAT_X32
+ *
+ *  7.31
+ *  - add FUSE_WRITE_KILL_PRIV flag
+ *  - add FUSE_SETUPMAPPING and FUSE_REMOVEMAPPING
+ *  - add map_alignment to fuse_init_out, add FUSE_MAP_ALIGNMENT flag
  */
 
 #ifndef _LINUX_FUSE_H
@@ -154,7 +207,7 @@
 #define FUSE_KERNEL_VERSION 7
 
 /** Minor version number of this interface */
-#define FUSE_KERNEL_MINOR_VERSION 27
+#define FUSE_KERNEL_MINOR_VERSION 31
 
 /** The node ID of the root inode */
 #define FUSE_ROOT_ID 1
@@ -222,10 +275,14 @@ struct fuse_file_lock {
  * FOPEN_DIRECT_IO: bypass page cache for this open file
  * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
  * FOPEN_NONSEEKABLE: the file is not seekable
+ * FOPEN_CACHE_DIR: allow caching this directory
+ * FOPEN_STREAM: the file is stream-like (no file position at all)
  */
 #define FOPEN_DIRECT_IO		(1 << 0)
 #define FOPEN_KEEP_CACHE	(1 << 1)
 #define FOPEN_NONSEEKABLE	(1 << 2)
+#define FOPEN_CACHE_DIR		(1 << 3)
+#define FOPEN_STREAM		(1 << 4)
 
 /**
  * INIT request/reply flags
@@ -252,6 +309,11 @@ struct fuse_file_lock {
  * FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc
  * FUSE_POSIX_ACL: filesystem supports posix acls
  * FUSE_ABORT_ERROR: reading the device after abort returns ECONNABORTED
+ * FUSE_MAX_PAGES: init_out.max_pages contains the max number of req pages
+ * FUSE_CACHE_SYMLINKS: cache READLINK responses
+ * FUSE_NO_OPENDIR_SUPPORT: kernel supports zero-message opendir
+ * FUSE_EXPLICIT_INVAL_DATA: only invalidate cached pages on explicit request
+ * FUSE_MAP_ALIGNMENT: map_alignment field is valid
  */
 #define FUSE_ASYNC_READ		(1 << 0)
 #define FUSE_POSIX_LOCKS	(1 << 1)
@@ -275,6 +337,11 @@ struct fuse_file_lock {
 #define FUSE_HANDLE_KILLPRIV	(1 << 19)
 #define FUSE_POSIX_ACL		(1 << 20)
 #define FUSE_ABORT_ERROR	(1 << 21)
+#define FUSE_MAX_PAGES		(1 << 22)
+#define FUSE_CACHE_SYMLINKS	(1 << 23)
+#define FUSE_NO_OPENDIR_SUPPORT (1 << 24)
+#define FUSE_EXPLICIT_INVAL_DATA (1 << 25)
+#define FUSE_MAP_ALIGNMENT	(1 << 26)
 
 /**
  * CUSE INIT request/reply flags
@@ -304,9 +371,11 @@ struct fuse_file_lock {
  *
  * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
  * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
+ * FUSE_WRITE_KILL_PRIV: kill suid and sgid bits
  */
 #define FUSE_WRITE_CACHE	(1 << 0)
 #define FUSE_WRITE_LOCKOWNER	(1 << 1)
+#define FUSE_WRITE_KILL_PRIV	(1 << 2)
 
 /**
  * Read flags
@@ -321,6 +390,7 @@ struct fuse_file_lock {
  * FUSE_IOCTL_RETRY: retry with new iovecs
  * FUSE_IOCTL_32BIT: 32bit ioctl
  * FUSE_IOCTL_DIR: is a directory
+ * FUSE_IOCTL_COMPAT_X32: x32 compat ioctl on 64bit machine (64bit time_t)
  *
  * FUSE_IOCTL_MAX_IOV: maximum of in_iovecs + out_iovecs
  */
@@ -329,6 +399,7 @@ struct fuse_file_lock {
 #define FUSE_IOCTL_RETRY	(1 << 2)
 #define FUSE_IOCTL_32BIT	(1 << 3)
 #define FUSE_IOCTL_DIR		(1 << 4)
+#define FUSE_IOCTL_COMPAT_X32	(1 << 5)
 
 #define FUSE_IOCTL_MAX_IOV	256
 
@@ -339,6 +410,13 @@ struct fuse_file_lock {
  */
 #define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
 
+/**
+ * Fsync flags
+ *
+ * FUSE_FSYNC_FDATASYNC: Sync data only, not metadata
+ */
+#define FUSE_FSYNC_FDATASYNC	(1 << 0)
+
 enum fuse_opcode {
 	FUSE_LOOKUP		= 1,
 	FUSE_FORGET		= 2,  /* no reply */
@@ -385,9 +463,15 @@ enum fuse_opcode {
 	FUSE_RENAME2		= 45,
 	FUSE_LSEEK		= 46,
 	FUSE_COPY_FILE_RANGE	= 47,
+	FUSE_SETUPMAPPING	= 48,
+	FUSE_REMOVEMAPPING	= 49,
 
 	/* CUSE specific operations */
 	CUSE_INIT		= 4096,
+
+	/* Reserved opcodes: helpful to detect structure endian-ness */
+	CUSE_INIT_BSWAP_RESERVED	= 1048576,	/* CUSE_INIT << 8 */
+	FUSE_INIT_BSWAP_RESERVED	= 436207616,	/* FUSE_INIT << 24 */
 };
 
 enum fuse_notify_code {
@@ -614,7 +698,9 @@ struct fuse_init_out {
 	uint16_t	congestion_threshold;
 	uint32_t	max_write;
 	uint32_t	time_gran;
-	uint32_t	unused[9];
+	uint16_t	max_pages;
+	uint16_t	map_alignment;
+	uint32_t	unused[8];
 };
 
 #define CUSE_INIT_INFO_MAX 4096

libfuse/include/fuse_lowlevel_compat.h

@@ -1,155 +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.
-*/
-
-/* these definitions provide source compatibility to prior versions.
-   Do not include this file directly! */
-
-struct fuse_lowlevel_ops_compat25 {
-	void (*init) (void *userdata);
-	void (*destroy) (void *userdata);
-	void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);
-	void (*forget) (fuse_req_t req, fuse_ino_t ino, unsigned long nlookup);
-	void (*getattr) (fuse_req_t req, fuse_ino_t ino,
-			 struct fuse_file_info *fi);
-	void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct stat *attr,
-			 int to_set, struct fuse_file_info *fi);
-	void (*readlink) (fuse_req_t req, fuse_ino_t ino);
-	void (*mknod) (fuse_req_t req, fuse_ino_t parent, const char *name,
-		       mode_t mode, dev_t rdev);
-	void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const char *name,
-		       mode_t mode);
-	void (*unlink) (fuse_req_t req, fuse_ino_t parent, const char *name);
-	void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const char *name);
-	void (*symlink) (fuse_req_t req, const char *link, fuse_ino_t parent,
-			 const char *name);
-	void (*rename) (fuse_req_t req, fuse_ino_t parent, const char *name,
-			fuse_ino_t newparent, const char *newname);
-	void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
-		      const char *newname);
-	void (*open) (fuse_req_t req, fuse_ino_t ino,
-		      struct fuse_file_info *fi);
-	void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
-		      struct fuse_file_info *fi);
-	void (*write) (fuse_req_t req, fuse_ino_t ino, const char *buf,
-		       size_t size, off_t off, struct fuse_file_info *fi);
-	void (*flush) (fuse_req_t req, fuse_ino_t ino,
-		       struct fuse_file_info *fi);
-	void (*release) (fuse_req_t req, fuse_ino_t ino,
-			 struct fuse_file_info *fi);
-	void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync,
-		       struct fuse_file_info *fi);
-	void (*opendir) (fuse_req_t req, fuse_ino_t ino,
-			 struct fuse_file_info *fi);
-	void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
-			 struct fuse_file_info *fi);
-	void (*releasedir) (fuse_req_t req, fuse_ino_t ino,
-			    struct fuse_file_info *fi);
-	void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync,
-			  struct fuse_file_info *fi);
-	void (*statfs) (fuse_req_t req);
-	void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
-			  const char *value, size_t size, int flags);
-	void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
-			  size_t size);
-	void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size);
-	void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const char *name);
-	void (*access) (fuse_req_t req, fuse_ino_t ino, int mask);
-	void (*create) (fuse_req_t req, fuse_ino_t parent, const char *name,
-			mode_t mode, struct fuse_file_info *fi);
-};
-
-struct fuse_session *fuse_lowlevel_new_compat25(struct fuse_args *args,
-				const struct fuse_lowlevel_ops_compat25 *op,
-				size_t op_size, void *userdata);
-
-size_t fuse_dirent_size(size_t namelen);
-
-char *fuse_add_dirent(char *buf, const char *name, const struct stat *stbuf,
-		      off_t off);
-
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
-
-#include <sys/statfs.h>
-
-struct fuse_lowlevel_ops_compat {
-	void (*init) (void *userdata);
-	void (*destroy) (void *userdata);
-	void (*lookup) (fuse_req_t req, fuse_ino_t parent, const char *name);
-	void (*forget) (fuse_req_t req, fuse_ino_t ino, unsigned long nlookup);
-	void (*getattr) (fuse_req_t req, fuse_ino_t ino,
-			 struct fuse_file_info_compat *fi);
-	void (*setattr) (fuse_req_t req, fuse_ino_t ino, struct stat *attr,
-			 int to_set, struct fuse_file_info_compat *fi);
-	void (*readlink) (fuse_req_t req, fuse_ino_t ino);
-	void (*mknod) (fuse_req_t req, fuse_ino_t parent, const char *name,
-		       mode_t mode, dev_t rdev);
-	void (*mkdir) (fuse_req_t req, fuse_ino_t parent, const char *name,
-		       mode_t mode);
-	void (*unlink) (fuse_req_t req, fuse_ino_t parent, const char *name);
-	void (*rmdir) (fuse_req_t req, fuse_ino_t parent, const char *name);
-	void (*symlink) (fuse_req_t req, const char *link, fuse_ino_t parent,
-			 const char *name);
-	void (*rename) (fuse_req_t req, fuse_ino_t parent, const char *name,
-			fuse_ino_t newparent, const char *newname);
-	void (*link) (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent,
-		      const char *newname);
-	void (*open) (fuse_req_t req, fuse_ino_t ino,
-		      struct fuse_file_info_compat *fi);
-	void (*read) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
-		      struct fuse_file_info_compat *fi);
-	void (*write) (fuse_req_t req, fuse_ino_t ino, const char *buf,
-		       size_t size, off_t off, struct fuse_file_info_compat *fi);
-	void (*flush) (fuse_req_t req, fuse_ino_t ino,
-		       struct fuse_file_info_compat *fi);
-	void (*release) (fuse_req_t req, fuse_ino_t ino,
-			 struct fuse_file_info_compat *fi);
-	void (*fsync) (fuse_req_t req, fuse_ino_t ino, int datasync,
-		       struct fuse_file_info_compat *fi);
-	void (*opendir) (fuse_req_t req, fuse_ino_t ino,
-			 struct fuse_file_info_compat *fi);
-	void (*readdir) (fuse_req_t req, fuse_ino_t ino, size_t size, off_t off,
-			 struct fuse_file_info_compat *fi);
-	void (*releasedir) (fuse_req_t req, fuse_ino_t ino,
-			    struct fuse_file_info_compat *fi);
-	void (*fsyncdir) (fuse_req_t req, fuse_ino_t ino, int datasync,
-			  struct fuse_file_info_compat *fi);
-	void (*statfs) (fuse_req_t req);
-	void (*setxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
-			  const char *value, size_t size, int flags);
-	void (*getxattr) (fuse_req_t req, fuse_ino_t ino, const char *name,
-			  size_t size);
-	void (*listxattr) (fuse_req_t req, fuse_ino_t ino, size_t size);
-	void (*removexattr) (fuse_req_t req, fuse_ino_t ino, const char *name);
-	void (*access) (fuse_req_t req, fuse_ino_t ino, int mask);
-	void (*create) (fuse_req_t req, fuse_ino_t parent, const char *name,
-			mode_t mode, struct fuse_file_info_compat *fi);
-};
-
-int fuse_reply_statfs_compat(fuse_req_t req, const struct statfs *stbuf);
-
-int fuse_reply_open_compat(fuse_req_t req,
-			   const struct fuse_file_info_compat *fi);
-
-struct fuse_session *fuse_lowlevel_new_compat(const char *opts,
-				const struct fuse_lowlevel_ops_compat *op,
-				size_t op_size, void *userdata);
-
-#endif /* __FreeBSD__ || __NetBSD__ */
-
-struct fuse_chan_ops_compat24 {
-	int (*receive)(struct fuse_chan *ch, char *buf, size_t size);
-	int (*send)(struct fuse_chan *ch, const struct iovec iov[],
-		    size_t count);
-	void (*destroy)(struct fuse_chan *ch);
-};
-
-struct fuse_chan *fuse_chan_new_compat24(struct fuse_chan_ops_compat24 *op,
-					 int fd, size_t bufsize, void *data);
-
-int fuse_chan_receive(struct fuse_chan *ch, char *buf, size_t size);
-struct fuse_chan *fuse_kern_chan_new(int fd);

libfuse/include/fuse_opt.h

@@ -9,14 +9,14 @@
 #ifndef _FUSE_OPT_H_
 #define _FUSE_OPT_H_
 
+#include "extern_c.h"
+
 /** @file
  *
  * This file defines the option parsing interface of FUSE
  */
 
-#ifdef __cplusplus
-extern "C" {
-#endif
+EXTERN_C_BEGIN
 
 /**
  * Option description
@@ -73,21 +73,22 @@ extern "C" {
  * If the format is "%s", memory is allocated for the string unlike
  * with scanf().
  */
-struct fuse_opt {
-	/** Matching template and optional parameter formatting */
-	const char *templ;
+struct fuse_opt
+{
+  /** Matching template and optional parameter formatting */
+  const char *templ;
 
-	/**
-	 * Offset of variable within 'data' parameter of fuse_opt_parse()
-	 * or -1
-	 */
-	unsigned long offset;
+  /**
+   * Offset of variable within 'data' parameter of fuse_opt_parse()
+   * or -1
+   */
+  unsigned long offset;
 
-	/**
-	 * Value to set the variable to, or to be passed as 'key' to the
-	 * processing function.	 Ignored if template has a format
-	 */
-	int value;
+  /**
+   * Value to set the variable to, or to be passed as 'key' to the
+   * processing function.	 Ignored if template has a format
+   */
+  int value;
 };
 
 /**
@@ -105,15 +106,16 @@ struct fuse_opt {
 /**
  * Argument list
  */
-struct fuse_args {
-	/** Argument count */
-	int argc;
+struct fuse_args
+{
+  /** Argument count */
+  int argc;
 
-	/** Argument vector.  NULL terminated */
-	char **argv;
+  /** Argument vector.  NULL terminated */
+  char **argv;
 
-	/** Is 'argv' allocated? */
-	int allocated;
+  /** Is 'argv' allocated? */
+  int allocated;
 };
 
 /**
@@ -177,7 +179,7 @@ struct fuse_args {
  * @return -1 on error, 0 if arg is to be discarded, 1 if arg should be kept
  */
 typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
-			       struct fuse_args *outargs);
+                               struct fuse_args *outargs);
 
 /**
  * Option parsing function
@@ -200,7 +202,7 @@ typedef int (*fuse_opt_proc_t)(void *data, const char *arg, int key,
  * @return -1 on error, 0 on success
  */
 int fuse_opt_parse(struct fuse_args *args, void *data,
-		   const struct fuse_opt opts[], fuse_opt_proc_t proc);
+                   const struct fuse_opt opts[], fuse_opt_proc_t proc);
 
 /**
  * Add an option to a comma separated option list
@@ -263,8 +265,6 @@ void fuse_opt_free_args(struct fuse_args *args);
  */
 int fuse_opt_match(const struct fuse_opt opts[], const char *opt);
 
-#ifdef __cplusplus
-}
-#endif
+EXTERN_C_END
 
 #endif /* _FUSE_OPT_H_ */

libfuse/include/fuse_timeouts.h

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

libfuse/include/kvec.h

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

libfuse/include/linux_dirent64.h

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

libfuse/include/old/fuse.h

@@ -1,9 +0,0 @@
-/*
-   This header is for compatibility with older software using FUSE.
-
-   Please use 'pkg-config --cflags fuse' to set include path.  The
-   correct usage is still '#include <fuse.h>', not '#include
-   <fuse/fuse.h>'.
-*/
-
-#include "fuse/fuse.h"

libfuse/include/stat_utils.h

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

libfuse/include/ulockmgr.h

@@ -1,24 +0,0 @@
-/*
-  libulockmgr: Userspace Lock Manager Library
-  Copyright (C) 2006  Miklos Szeredi <miklos@szeredi.hu>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB.
-*/
-
-#include <stdint.h>
-#include <fcntl.h>
-#include <sys/types.h>
-
-/**
- * Perform POSIX locking operation
- *
- * @param fd the file descriptor
- * @param cmd the locking command (F_GETFL, F_SETLK or F_SETLKW)
- * @param lock the lock parameters
- * @param owner the lock owner ID cookie
- * @param owner_len length of the lock owner ID cookie
- * @return 0 on success -errno on error
- */
-int ulockmgr_op(int fd, int cmd, struct flock *lock, const void *owner,
-		size_t owner_len);

libfuse/lib/Makefile.am

@@ -1,42 +0,0 @@
-## Process this file with automake to produce Makefile.in
-
-AUTOMAKE_OPTIONS = subdir-objects
-AM_CPPFLAGS = -I$(top_srcdir)/include -DFUSERMOUNT_DIR=\"$(bindir)\" \
- -D_FILE_OFFSET_BITS=64 -D_REENTRANT -DFUSE_USE_VERSION=26
-
-lib_LTLIBRARIES = libfuse.la libulockmgr.la
-
-if BSD
-mount_source = mount_bsd.c
-else
-mount_source = mount.c mount_util.c mount_util.h
-endif
-
-libfuse_la_SOURCES = 		\
-	fuse.c			\
-	fuse_i.h		\
-	fuse_kern_chan.c	\
-	fuse_loop.c		\
-	fuse_loop_mt.c		\
-	fuse_lowlevel.c		\
-	fuse_misc.h		\
-	fuse_mt.c		\
-	fuse_opt.c		\
-	fuse_session.c		\
-	fuse_signals.c		\
-	buffer.c		\
-	cuse_lowlevel.c		\
-	helper.c                \
-	$(mount_source)
-
-libfuse_la_LDFLAGS = -pthread @libfuse_libs@ -version-number 2:9:7 \
-	-Wl,--version-script,$(srcdir)/fuse_versionscript
-
-if NETBSD
-libfuse_la_LIBADD = -lperfuse -lpuffs
-endif
-
-libulockmgr_la_SOURCES = ulockmgr.c
-libulockmgr_la_LDFLAGS = -pthread -version-number 1:0:1
-
-EXTRA_DIST = fuse_versionscript

libfuse/lib/buffer.c

@@ -18,140 +18,140 @@
 
 size_t fuse_buf_size(const struct fuse_bufvec *bufv)
 {
-	size_t i;
-	size_t size = 0;
+  size_t i;
+  size_t size = 0;
 
-	for (i = 0; i < bufv->count; i++) {
-		if (bufv->buf[i].size == SIZE_MAX)
-			size = SIZE_MAX;
-		else
-			size += bufv->buf[i].size;
-	}
+  for (i = 0; i < bufv->count; i++) {
+    if (bufv->buf[i].size == SIZE_MAX)
+      size = SIZE_MAX;
+    else
+      size += bufv->buf[i].size;
+  }
 
-	return size;
+  return size;
 }
 
 static size_t min_size(size_t s1, size_t s2)
 {
-	return s1 < s2 ? s1 : s2;
+  return s1 < s2 ? s1 : s2;
 }
 
 static ssize_t fuse_buf_write(const struct fuse_buf *dst, size_t dst_off,
 			      const struct fuse_buf *src, size_t src_off,
 			      size_t len)
 {
-	ssize_t res = 0;
-	size_t copied = 0;
+  ssize_t res = 0;
+  size_t copied = 0;
 
-	while (len) {
-		if (dst->flags & FUSE_BUF_FD_SEEK) {
-			res = pwrite(dst->fd, src->mem + src_off, len,
-				     dst->pos + dst_off);
-		} else {
-			res = write(dst->fd, src->mem + src_off, len);
-		}
-		if (res == -1) {
-			if (!copied)
-				return -errno;
-			break;
-		}
-		if (res == 0)
-			break;
+  while (len) {
+    if (dst->flags & FUSE_BUF_FD_SEEK) {
+      res = pwrite(dst->fd, src->mem + src_off, len,
+                   dst->pos + dst_off);
+    } else {
+      res = write(dst->fd, src->mem + src_off, len);
+    }
+    if (res == -1) {
+      if (!copied)
+        return -errno;
+      break;
+    }
+    if (res == 0)
+      break;
 
-		copied += res;
-		if (!(dst->flags & FUSE_BUF_FD_RETRY))
-			break;
+    copied += res;
+    if (!(dst->flags & FUSE_BUF_FD_RETRY))
+      break;
 
-		src_off += res;
-		dst_off += res;
-		len -= res;
-	}
+    src_off += res;
+    dst_off += res;
+    len -= res;
+  }
 
-	return copied;
+  return copied;
 }
 
 static ssize_t fuse_buf_read(const struct fuse_buf *dst, size_t dst_off,
 			     const struct fuse_buf *src, size_t src_off,
 			     size_t len)
 {
-	ssize_t res = 0;
-	size_t copied = 0;
+  ssize_t res = 0;
+  size_t copied = 0;
 
-	while (len) {
-		if (src->flags & FUSE_BUF_FD_SEEK) {
-			res = pread(src->fd, dst->mem + dst_off, len,
-				     src->pos + src_off);
-		} else {
-			res = read(src->fd, dst->mem + dst_off, len);
-		}
-		if (res == -1) {
-			if (!copied)
-				return -errno;
-			break;
-		}
-		if (res == 0)
-			break;
+  while (len) {
+    if (src->flags & FUSE_BUF_FD_SEEK) {
+      res = pread(src->fd, dst->mem + dst_off, len,
+                  src->pos + src_off);
+    } else {
+      res = read(src->fd, dst->mem + dst_off, len);
+    }
+    if (res == -1) {
+      if (!copied)
+        return -errno;
+      break;
+    }
+    if (res == 0)
+      break;
 
-		copied += res;
-		if (!(src->flags & FUSE_BUF_FD_RETRY))
-			break;
+    copied += res;
+    if (!(src->flags & FUSE_BUF_FD_RETRY))
+      break;
 
-		dst_off += res;
-		src_off += res;
-		len -= res;
-	}
+    dst_off += res;
+    src_off += res;
+    len -= res;
+  }
 
-	return copied;
+  return copied;
 }
 
 static ssize_t fuse_buf_fd_to_fd(const struct fuse_buf *dst, size_t dst_off,
 				 const struct fuse_buf *src, size_t src_off,
 				 size_t len)
 {
-	char buf[4096];
-	struct fuse_buf tmp = {
-		.size = sizeof(buf),
-		.flags = 0,
-	};
-	ssize_t res;
-	size_t copied = 0;
+  char buf[4096];
+  struct fuse_buf tmp = {
+    .size = sizeof(buf),
+    .flags = 0,
+  };
+  ssize_t res;
+  size_t copied = 0;
 
-	tmp.mem = buf;
+  tmp.mem = buf;
 
-	while (len) {
-		size_t this_len = min_size(tmp.size, len);
-		size_t read_len;
+  while (len) {
+    size_t this_len = min_size(tmp.size, len);
+    size_t read_len;
 
-		res = fuse_buf_read(&tmp, 0, src, src_off, this_len);
-		if (res < 0) {
-			if (!copied)
-				return res;
-			break;
-		}
-		if (res == 0)
-			break;
+    res = fuse_buf_read(&tmp, 0, src, src_off, this_len);
+    if (res < 0) {
+      if (!copied)
+        return res;
+      break;
+    }
+    if (res == 0)
+      break;
 
-		read_len = res;
-		res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);
-		if (res < 0) {
-			if (!copied)
-				return res;
-			break;
-		}
-		if (res == 0)
-			break;
+    read_len = res;
+    res = fuse_buf_write(dst, dst_off, &tmp, 0, read_len);
+    if (res < 0) {
+      if (!copied)
+        return res;
+      break;
+    }
+    if (res == 0)
+      break;
 
-		copied += res;
+    copied += res;
 
-		if (res < this_len)
-			break;
+    if (res < this_len)
+      break;
 
-		dst_off += res;
-		src_off += res;
-		len -= res;
-	}
+    dst_off += res;
+    src_off += res;
+    len -= res;
+  }
 
-	return copied;
+  return copied;
 }
 
 #ifdef HAVE_SPLICE
@@ -159,64 +159,64 @@ static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
 			       const struct fuse_buf *src, size_t src_off,
 			       size_t len, enum fuse_buf_copy_flags flags)
 {
-	int splice_flags = 0;
-	off_t *srcpos = NULL;
-	off_t *dstpos = NULL;
-	off_t srcpos_val;
-	off_t dstpos_val;
-	ssize_t res;
-	size_t copied = 0;
+  int splice_flags = 0;
+  off_t *srcpos = NULL;
+  off_t *dstpos = NULL;
+  off_t srcpos_val;
+  off_t dstpos_val;
+  ssize_t res;
+  size_t copied = 0;
 
-	if (flags & FUSE_BUF_SPLICE_MOVE)
-		splice_flags |= SPLICE_F_MOVE;
-	if (flags & FUSE_BUF_SPLICE_NONBLOCK)
-		splice_flags |= SPLICE_F_NONBLOCK;
+  if (flags & FUSE_BUF_SPLICE_MOVE)
+    splice_flags |= SPLICE_F_MOVE;
+  if (flags & FUSE_BUF_SPLICE_NONBLOCK)
+    splice_flags |= SPLICE_F_NONBLOCK;
 
-	if (src->flags & FUSE_BUF_FD_SEEK) {
-		srcpos_val = src->pos + src_off;
-		srcpos = &srcpos_val;
-	}
-	if (dst->flags & FUSE_BUF_FD_SEEK) {
-		dstpos_val = dst->pos + dst_off;
-		dstpos = &dstpos_val;
-	}
+  if (src->flags & FUSE_BUF_FD_SEEK) {
+    srcpos_val = src->pos + src_off;
+    srcpos = &srcpos_val;
+  }
+  if (dst->flags & FUSE_BUF_FD_SEEK) {
+    dstpos_val = dst->pos + dst_off;
+    dstpos = &dstpos_val;
+  }
 
-	while (len) {
-		res = splice(src->fd, srcpos, dst->fd, dstpos, len,
-			     splice_flags);
-		if (res == -1) {
-			if (copied)
-				break;
+  while (len) {
+    res = splice(src->fd, srcpos, dst->fd, dstpos, len,
+                 splice_flags);
+    if (res == -1) {
+      if (copied)
+        break;
 
-			if (errno != EINVAL || (flags & FUSE_BUF_FORCE_SPLICE))
-				return -errno;
+      if (errno != EINVAL || (flags & FUSE_BUF_FORCE_SPLICE))
+        return -errno;
 
-			/* Maybe splice is not supported for this combination */
-			return fuse_buf_fd_to_fd(dst, dst_off, src, src_off,
-						 len);
-		}
-		if (res == 0)
-			break;
+      /* Maybe splice is not supported for this combination */
+      return fuse_buf_fd_to_fd(dst, dst_off, src, src_off,
+                               len);
+    }
+    if (res == 0)
+      break;
 
-		copied += res;
-		if (!(src->flags & FUSE_BUF_FD_RETRY) &&
-		    !(dst->flags & FUSE_BUF_FD_RETRY)) {
-			break;
-		}
+    copied += res;
+    if (!(src->flags & FUSE_BUF_FD_RETRY) &&
+        !(dst->flags & FUSE_BUF_FD_RETRY)) {
+      break;
+    }
 
-		len -= res;
-	}
+    len -= res;
+  }
 
-	return copied;
+  return copied;
 }
 #else
 static ssize_t fuse_buf_splice(const struct fuse_buf *dst, size_t dst_off,
 			       const struct fuse_buf *src, size_t src_off,
 			       size_t len, enum fuse_buf_copy_flags flags)
 {
-	(void) flags;
+  (void) flags;
 
-	return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
+  return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
 }
 #endif
 
@@ -225,94 +225,94 @@ static ssize_t fuse_buf_copy_one(const struct fuse_buf *dst, size_t dst_off,
 				 const struct fuse_buf *src, size_t src_off,
 				 size_t len, enum fuse_buf_copy_flags flags)
 {
-	int src_is_fd = src->flags & FUSE_BUF_IS_FD;
-	int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;
+  int src_is_fd = src->flags & FUSE_BUF_IS_FD;
+  int dst_is_fd = dst->flags & FUSE_BUF_IS_FD;
 
-	if (!src_is_fd && !dst_is_fd) {
-		void *dstmem = dst->mem + dst_off;
-		void *srcmem = src->mem + src_off;
+  if (!src_is_fd && !dst_is_fd) {
+    char *dstmem = dst->mem + dst_off;
+    char *srcmem = src->mem + src_off;
 
-		if (dstmem != srcmem) {
-			if (dstmem + len <= srcmem || srcmem + len <= dstmem)
-				memcpy(dstmem, srcmem, len);
-			else
-				memmove(dstmem, srcmem, len);
-		}
+    if (dstmem != srcmem) {
+      if (dstmem + len <= srcmem || srcmem + len <= dstmem)
+        memcpy(dstmem, srcmem, len);
+      else
+        memmove(dstmem, srcmem, len);
+    }
 
-		return len;
-	} else if (!src_is_fd) {
-		return fuse_buf_write(dst, dst_off, src, src_off, len);
-	} else if (!dst_is_fd) {
-		return fuse_buf_read(dst, dst_off, src, src_off, len);
-	} else if (flags & FUSE_BUF_NO_SPLICE) {
-		return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
-	} else {
-		return fuse_buf_splice(dst, dst_off, src, src_off, len, flags);
-	}
+    return len;
+  } else if (!src_is_fd) {
+    return fuse_buf_write(dst, dst_off, src, src_off, len);
+  } else if (!dst_is_fd) {
+    return fuse_buf_read(dst, dst_off, src, src_off, len);
+  } else if (flags & FUSE_BUF_NO_SPLICE) {
+    return fuse_buf_fd_to_fd(dst, dst_off, src, src_off, len);
+  } else {
+    return fuse_buf_splice(dst, dst_off, src, src_off, len, flags);
+  }
 }
 
 static const struct fuse_buf *fuse_bufvec_current(struct fuse_bufvec *bufv)
 {
-	if (bufv->idx < bufv->count)
-		return &bufv->buf[bufv->idx];
-	else
-		return NULL;
+  if (bufv->idx < bufv->count)
+    return &bufv->buf[bufv->idx];
+  else
+    return NULL;
 }
 
 static int fuse_bufvec_advance(struct fuse_bufvec *bufv, size_t len)
 {
-	const struct fuse_buf *buf = fuse_bufvec_current(bufv);
+  const struct fuse_buf *buf = fuse_bufvec_current(bufv);
 
-	bufv->off += len;
-	assert(bufv->off <= buf->size);
-	if (bufv->off == buf->size) {
-		assert(bufv->idx < bufv->count);
-		bufv->idx++;
-		if (bufv->idx == bufv->count)
-			return 0;
-		bufv->off = 0;
-	}
-	return 1;
+  bufv->off += len;
+  assert(bufv->off <= buf->size);
+  if (bufv->off == buf->size) {
+    assert(bufv->idx < bufv->count);
+    bufv->idx++;
+    if (bufv->idx == bufv->count)
+      return 0;
+    bufv->off = 0;
+  }
+  return 1;
 }
 
 ssize_t fuse_buf_copy(struct fuse_bufvec *dstv, struct fuse_bufvec *srcv,
 		      enum fuse_buf_copy_flags flags)
 {
-	size_t copied = 0;
+  size_t copied = 0;
 
-	if (dstv == srcv)
-		return fuse_buf_size(dstv);
+  if (dstv == srcv)
+    return fuse_buf_size(dstv);
 
-	for (;;) {
-		const struct fuse_buf *src = fuse_bufvec_current(srcv);
-		const struct fuse_buf *dst = fuse_bufvec_current(dstv);
-		size_t src_len;
-		size_t dst_len;
-		size_t len;
-		ssize_t res;
+  for (;;) {
+    const struct fuse_buf *src = fuse_bufvec_current(srcv);
+    const struct fuse_buf *dst = fuse_bufvec_current(dstv);
+    size_t src_len;
+    size_t dst_len;
+    size_t len;
+    ssize_t res;
 
-		if (src == NULL || dst == NULL)
-			break;
+    if (src == NULL || dst == NULL)
+      break;
 
-		src_len = src->size - srcv->off;
-		dst_len = dst->size - dstv->off;
-		len = min_size(src_len, dst_len);
+    src_len = src->size - srcv->off;
+    dst_len = dst->size - dstv->off;
+    len = min_size(src_len, dst_len);
 
-		res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len, flags);
-		if (res < 0) {
-			if (!copied)
-				return res;
-			break;
-		}
-		copied += res;
+    res = fuse_buf_copy_one(dst, dstv->off, src, srcv->off, len, flags);
+    if (res < 0) {
+      if (!copied)
+        return res;
+      break;
+    }
+    copied += res;
 
-		if (!fuse_bufvec_advance(srcv, res) ||
-		    !fuse_bufvec_advance(dstv, res))
-			break;
+    if (!fuse_bufvec_advance(srcv, res) ||
+        !fuse_bufvec_advance(dstv, res))
+      break;
 
-		if (res < len)
-			break;
-	}
+    if (res < len)
+      break;
+  }
 
-	return copied;
+  return copied;
 }

libfuse/lib/cuse_lowlevel.c

@@ -1,371 +0,0 @@
-/*
-  CUSE: Character device in Userspace
-  Copyright (C) 2008       SUSE Linux Products GmbH
-  Copyright (C) 2008       Tejun Heo <teheo@suse.de>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB.
-*/
-
-#include "cuse_lowlevel.h"
-#include "fuse_kernel.h"
-#include "fuse_i.h"
-#include "fuse_opt.h"
-#include "fuse_misc.h"
-
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include <stddef.h>
-#include <errno.h>
-#include <unistd.h>
-
-struct cuse_data {
-	struct cuse_lowlevel_ops	clop;
-	unsigned			max_read;
-	unsigned			dev_major;
-	unsigned			dev_minor;
-	unsigned			flags;
-	unsigned			dev_info_len;
-	char				dev_info[];
-};
-
-static struct cuse_lowlevel_ops *req_clop(fuse_req_t req)
-{
-	return &req->f->cuse_data->clop;
-}
-
-static void cuse_fll_open(fuse_req_t req, fuse_ino_t ino,
-			  struct fuse_file_info *fi)
-{
-	(void)ino;
-	req_clop(req)->open(req, fi);
-}
-
-static void cuse_fll_read(fuse_req_t req, fuse_ino_t ino, size_t size,
-			  off_t off, struct fuse_file_info *fi)
-{
-	(void)ino;
-	req_clop(req)->read(req, size, off, fi);
-}
-
-static void cuse_fll_write(fuse_req_t req, fuse_ino_t ino, const char *buf,
-			   size_t size, off_t off, struct fuse_file_info *fi)
-{
-	(void)ino;
-	req_clop(req)->write(req, buf, size, off, fi);
-}
-
-static void cuse_fll_flush(fuse_req_t req, fuse_ino_t ino,
-			   struct fuse_file_info *fi)
-{
-	(void)ino;
-	req_clop(req)->flush(req, fi);
-}
-
-static void cuse_fll_release(fuse_req_t req, fuse_ino_t ino,
-			     struct fuse_file_info *fi)
-{
-	(void)ino;
-	req_clop(req)->release(req, fi);
-}
-
-static void cuse_fll_fsync(fuse_req_t req, fuse_ino_t ino, int datasync,
-			   struct fuse_file_info *fi)
-{
-	(void)ino;
-	req_clop(req)->fsync(req, datasync, fi);
-}
-
-static void cuse_fll_ioctl(fuse_req_t req, fuse_ino_t ino, int cmd, void *arg,
-		       struct fuse_file_info *fi, unsigned int flags,
-		       const void *in_buf, size_t in_bufsz, size_t out_bufsz)
-{
-	(void)ino;
-	req_clop(req)->ioctl(req, cmd, arg, fi, flags, in_buf, in_bufsz,
-			     out_bufsz);
-}
-
-static void cuse_fll_poll(fuse_req_t req, fuse_ino_t ino,
-			  struct fuse_file_info *fi, struct fuse_pollhandle *ph)
-{
-	(void)ino;
-	req_clop(req)->poll(req, fi, ph);
-}
-
-static size_t cuse_pack_info(int argc, const char **argv, char *buf)
-{
-	size_t size = 0;
-	int i;
-
-	for (i = 0; i < argc; i++) {
-		size_t len;
-
-		len = strlen(argv[i]) + 1;
-		size += len;
-		if (buf) {
-			memcpy(buf, argv[i], len);
-			buf += len;
-		}
-	}
-
-	return size;
-}
-
-static struct cuse_data *cuse_prep_data(const struct cuse_info *ci,
-					const struct cuse_lowlevel_ops *clop)
-{
-	struct cuse_data *cd;
-	size_t dev_info_len;
-
-	dev_info_len = cuse_pack_info(ci->dev_info_argc, ci->dev_info_argv,
-				      NULL);
-
-	if (dev_info_len > CUSE_INIT_INFO_MAX) {
-		fprintf(stderr, "cuse: dev_info (%zu) too large, limit=%u\n",
-			dev_info_len, CUSE_INIT_INFO_MAX);
-		return NULL;
-	}
-
-	cd = calloc(1, sizeof(*cd) + dev_info_len);
-	if (!cd) {
-		fprintf(stderr, "cuse: failed to allocate cuse_data\n");
-		return NULL;
-	}
-
-	memcpy(&cd->clop, clop, sizeof(cd->clop));
-	cd->max_read = 131072;
-	cd->dev_major = ci->dev_major;
-	cd->dev_minor = ci->dev_minor;
-	cd->dev_info_len = dev_info_len;
-	cd->flags = ci->flags;
-	cuse_pack_info(ci->dev_info_argc, ci->dev_info_argv, cd->dev_info);
-
-	return cd;
-}
-
-struct fuse_session *cuse_lowlevel_new(struct fuse_args *args,
-				       const struct cuse_info *ci,
-				       const struct cuse_lowlevel_ops *clop,
-				       void *userdata)
-{
-	struct fuse_lowlevel_ops lop;
-	struct cuse_data *cd;
-	struct fuse_session *se;
-	struct fuse_ll *ll;
-
-	cd = cuse_prep_data(ci, clop);
-	if (!cd)
-		return NULL;
-
-	memset(&lop, 0, sizeof(lop));
-	lop.init	= clop->init;
-	lop.destroy	= clop->destroy;
-	lop.open	= clop->open		? cuse_fll_open		: NULL;
-	lop.read	= clop->read		? cuse_fll_read		: NULL;
-	lop.write	= clop->write		? cuse_fll_write	: NULL;
-	lop.flush	= clop->flush		? cuse_fll_flush	: NULL;
-	lop.release	= clop->release		? cuse_fll_release	: NULL;
-	lop.fsync	= clop->fsync		? cuse_fll_fsync	: NULL;
-	lop.ioctl	= clop->ioctl		? cuse_fll_ioctl	: NULL;
-	lop.poll	= clop->poll		? cuse_fll_poll		: NULL;
-
-	se = fuse_lowlevel_new_common(args, &lop, sizeof(lop), userdata);
-	if (!se) {
-		free(cd);
-		return NULL;
-	}
-	ll = se->data;
-	ll->cuse_data = cd;
-
-	return se;
-}
-
-static int cuse_reply_init(fuse_req_t req, struct cuse_init_out *arg,
-			   char *dev_info, unsigned dev_info_len)
-{
-	struct iovec iov[3];
-
-	iov[1].iov_base = arg;
-	iov[1].iov_len = sizeof(struct cuse_init_out);
-	iov[2].iov_base = dev_info;
-	iov[2].iov_len = dev_info_len;
-
-	return fuse_send_reply_iov_nofree(req, 0, iov, 3);
-}
-
-void cuse_lowlevel_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
-{
-	struct fuse_init_in *arg = (struct fuse_init_in *) inarg;
-	struct cuse_init_out outarg;
-	struct fuse_ll *f = req->f;
-	struct cuse_data *cd = f->cuse_data;
-	size_t bufsize = fuse_chan_bufsize(req->ch);
-	struct cuse_lowlevel_ops *clop = req_clop(req);
-
-	(void) nodeid;
-	if (f->debug) {
-		fprintf(stderr, "CUSE_INIT: %u.%u\n", arg->major, arg->minor);
-		fprintf(stderr, "flags=0x%08x\n", arg->flags);
-	}
-	f->conn.proto_major = arg->major;
-	f->conn.proto_minor = arg->minor;
-	f->conn.capable = 0;
-	f->conn.want = 0;
-
-	if (arg->major < 7) {
-		fprintf(stderr, "cuse: unsupported protocol version: %u.%u\n",
-			arg->major, arg->minor);
-		fuse_reply_err(req, EPROTO);
-		return;
-	}
-
-	if (bufsize < FUSE_MIN_READ_BUFFER) {
-		fprintf(stderr, "cuse: warning: buffer size too small: %zu\n",
-			bufsize);
-		bufsize = FUSE_MIN_READ_BUFFER;
-	}
-
-	bufsize -= 4096;
-	if (bufsize < f->conn.max_write)
-		f->conn.max_write = bufsize;
-
-	f->got_init = 1;
-	if (f->op.init)
-		f->op.init(f->userdata, &f->conn);
-
-	memset(&outarg, 0, sizeof(outarg));
-	outarg.major = FUSE_KERNEL_VERSION;
-	outarg.minor = FUSE_KERNEL_MINOR_VERSION;
-	outarg.flags = cd->flags;
-	outarg.max_read = cd->max_read;
-	outarg.max_write = f->conn.max_write;
-	outarg.dev_major = cd->dev_major;
-	outarg.dev_minor = cd->dev_minor;
-
-	if (f->debug) {
-		fprintf(stderr, "   CUSE_INIT: %u.%u\n",
-			outarg.major, outarg.minor);
-		fprintf(stderr, "   flags=0x%08x\n", outarg.flags);
-		fprintf(stderr, "   max_read=0x%08x\n", outarg.max_read);
-		fprintf(stderr, "   max_write=0x%08x\n", outarg.max_write);
-		fprintf(stderr, "   dev_major=%u\n", outarg.dev_major);
-		fprintf(stderr, "   dev_minor=%u\n", outarg.dev_minor);
-		fprintf(stderr, "   dev_info: %.*s\n", cd->dev_info_len,
-			cd->dev_info);
-	}
-
-	cuse_reply_init(req, &outarg, cd->dev_info, cd->dev_info_len);
-
-	if (clop->init_done)
-		clop->init_done(f->userdata);
-
-	fuse_free_req(req);
-}
-
-struct fuse_session *cuse_lowlevel_setup(int argc, char *argv[],
-					 const struct cuse_info *ci,
-					 const struct cuse_lowlevel_ops *clop,
-					 int *multithreaded, void *userdata)
-{
-	const char *devname = "/dev/cuse";
-	static const struct fuse_opt kill_subtype_opts[] = {
-		FUSE_OPT_KEY("subtype=",  FUSE_OPT_KEY_DISCARD),
-		FUSE_OPT_END
-	};
-	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
-	struct fuse_session *se;
-	struct fuse_chan *ch;
-	int fd;
-	int foreground;
-	int res;
-
-	res = fuse_parse_cmdline(&args, NULL, multithreaded, &foreground);
-	if (res == -1)
-		goto err_args;
-
-	res = fuse_opt_parse(&args, NULL, kill_subtype_opts, NULL);
-	if (res == -1)
-		goto err_args;
-
-	/*
-	 * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
-	 * would ensue.
-	 */
-	do {
-		fd = open("/dev/null", O_RDWR);
-		if (fd > 2)
-			close(fd);
-	} while (fd >= 0 && fd <= 2);
-
-	se = cuse_lowlevel_new(&args, ci, clop, userdata);
-	fuse_opt_free_args(&args);
-	if (se == NULL)
-		goto err_args;
-
-	fd = open(devname, O_RDWR);
-	if (fd == -1) {
-		if (errno == ENODEV || errno == ENOENT)
-			fprintf(stderr, "cuse: device not found, try 'modprobe cuse' first\n");
-		else
-			fprintf(stderr, "cuse: failed to open %s: %s\n",
-				devname, strerror(errno));
-		goto err_se;
-	}
-
-	ch = fuse_kern_chan_new(fd);
-	if (!ch) {
-		close(fd);
-		goto err_se;
-	}
-
-	fuse_session_add_chan(se, ch);
-
-	res = fuse_set_signal_handlers(se);
-	if (res == -1)
-		goto err_se;
-
-	res = fuse_daemonize(foreground);
-	if (res == -1)
-		goto err_sig;
-
-	return se;
-
-err_sig:
-	fuse_remove_signal_handlers(se);
-err_se:
-	fuse_session_destroy(se);
-err_args:
-	fuse_opt_free_args(&args);
-	return NULL;
-}
-
-void cuse_lowlevel_teardown(struct fuse_session *se)
-{
-	fuse_remove_signal_handlers(se);
-	fuse_session_destroy(se);
-}
-
-int cuse_lowlevel_main(int argc, char *argv[], const struct cuse_info *ci,
-		       const struct cuse_lowlevel_ops *clop, void *userdata)
-{
-	struct fuse_session *se;
-	int multithreaded;
-	int res;
-
-	se = cuse_lowlevel_setup(argc, argv, ci, clop, &multithreaded,
-				 userdata);
-	if (se == NULL)
-		return 1;
-
-	if (multithreaded)
-                res = fuse_session_loop_mt(se, 0);
-	else
-		res = fuse_session_loop(se);
-
-	cuse_lowlevel_teardown(se);
-	if (res == -1)
-		return 1;
-
-	return 0;
-}

libfuse/lib/fuse_dirents.c

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

libfuse/lib/fuse_i.h

@@ -6,106 +6,108 @@
   See the file COPYING.LIB
 */
 
+#pragma once
+
 #include "fuse.h"
 #include "fuse_lowlevel.h"
 
 struct fuse_chan;
 struct fuse_ll;
 
-struct fuse_session {
-	struct fuse_session_ops op;
+struct fuse_session
+{
+  struct fuse_session_ops op;
 
-	int (*receive_buf)(struct fuse_session *se, struct fuse_buf *buf,
-			   struct fuse_chan **chp);
+  int (*receive_buf)(struct fuse_session *se, struct fuse_buf *buf,
+                     struct fuse_chan **chp);
 
-	void (*process_buf)(void *data, const struct fuse_buf *buf,
-			    struct fuse_chan *ch);
+  void (*process_buf)(void *data, const struct fuse_buf *buf,
+                      struct fuse_chan *ch);
 
-	void *data;
+  void *data;
 
-	volatile int exited;
+  volatile int exited;
 
-	struct fuse_chan *ch;
+  struct fuse_chan *ch;
 };
 
-struct fuse_req {
-	struct fuse_ll *f;
-	uint64_t unique;
-	int ctr;
-	pthread_mutex_t lock;
-	struct fuse_ctx ctx;
-	struct fuse_chan *ch;
-	int interrupted;
-	unsigned int ioctl_64bit : 1;
-	union {
-		struct {
-			uint64_t unique;
-		} i;
-		struct {
-			fuse_interrupt_func_t func;
-			void *data;
-		} ni;
-	} u;
-	struct fuse_req *next;
-	struct fuse_req *prev;
+struct fuse_req
+{
+  struct fuse_ll *f;
+  uint64_t unique;
+  int ctr;
+  pthread_mutex_t lock;
+  struct fuse_ctx ctx;
+  struct fuse_chan *ch;
+  int interrupted;
+  unsigned int ioctl_64bit : 1;
+  union {
+    struct {
+      uint64_t unique;
+    } i;
+    struct {
+      fuse_interrupt_func_t func;
+      void *data;
+    } ni;
+  } u;
+  struct fuse_req *next;
+  struct fuse_req *prev;
 };
 
-struct fuse_notify_req {
-	uint64_t unique;
-	void (*reply)(struct fuse_notify_req *, fuse_req_t, fuse_ino_t,
-		      const void *, const struct fuse_buf *);
-	struct fuse_notify_req *next;
-	struct fuse_notify_req *prev;
+struct fuse_notify_req
+{
+  uint64_t unique;
+  void (*reply)(struct fuse_notify_req *, fuse_req_t, fuse_ino_t,
+                const void *, const struct fuse_buf *);
+  struct fuse_notify_req *next;
+  struct fuse_notify_req *prev;
 };
 
-struct fuse_ll {
-	int debug;
-	int allow_root;
-	int atomic_o_trunc;
-	int no_remote_posix_lock;
-	int no_remote_flock;
-	int big_writes;
-	int splice_write;
-	int splice_move;
-	int splice_read;
-	int no_splice_write;
-	int no_splice_move;
-	int no_splice_read;
-	struct fuse_lowlevel_ops op;
-	int got_init;
-	struct cuse_data *cuse_data;
-	void *userdata;
-	uid_t owner;
-	struct fuse_conn_info conn;
-	struct fuse_req list;
-	struct fuse_req interrupts;
-	pthread_mutex_t lock;
-	int got_destroy;
-	pthread_key_t pipe_key;
-	int broken_splice_nonblock;
-	uint64_t notify_ctr;
-	struct fuse_notify_req notify_list;
+struct fuse_ll
+{
+  int debug;
+  int allow_root;
+  int no_remote_posix_lock;
+  int no_remote_flock;
+  int big_writes;
+  int splice_write;
+  int splice_move;
+  int splice_read;
+  int no_splice_write;
+  int no_splice_move;
+  int no_splice_read;
+  struct fuse_lowlevel_ops op;
+  int got_init;
+  void *userdata;
+  uid_t owner;
+  struct fuse_conn_info conn;
+  struct fuse_req list;
+  struct fuse_req interrupts;
+  pthread_mutex_t lock;
+  int got_destroy;
+  pthread_key_t pipe_key;
+  int broken_splice_nonblock;
+  uint64_t notify_ctr;
+  struct fuse_notify_req notify_list;
 };
 
-struct fuse_cmd {
-	char *buf;
-	size_t buflen;
-	struct fuse_chan *ch;
+struct fuse_cmd
+{
+  char *buf;
+  size_t buflen;
+  struct fuse_chan *ch;
 };
 
 struct fuse *fuse_new_common(struct fuse_chan *ch, struct fuse_args *args,
 			     const struct fuse_operations *op,
-			     size_t op_size, void *user_data, int compat);
-
-int fuse_sync_compat_args(struct fuse_args *args);
+			     size_t op_size, void *user_data);
 
 struct fuse_chan *fuse_kern_chan_new(int fd);
 
 struct fuse_session *fuse_lowlevel_new_common(struct fuse_args *args,
-					const struct fuse_lowlevel_ops *op,
-					size_t op_size, void *userdata);
+                                              const struct fuse_lowlevel_ops *op,
+                                              size_t op_size, void *userdata);
 
-void fuse_kern_unmount_compat22(const char *mountpoint);
 int fuse_chan_clearfd(struct fuse_chan *ch);
 
 void fuse_kern_unmount(const char *mountpoint, int fd);
@@ -120,11 +122,7 @@ struct fuse *fuse_setup_common(int argc, char *argv[],
 			       const struct fuse_operations *op,
 			       size_t op_size,
 			       char **mountpoint,
-			       int *multithreaded,
 			       int *fd,
-			       void *user_data,
-			       int compat);
-
-void cuse_lowlevel_init(fuse_req_t req, fuse_ino_t nodeide, const void *inarg);
+			       void *user_data);
 
 int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg);

libfuse/lib/fuse_kern_chan.c

@@ -18,81 +18,86 @@
 static int fuse_kern_chan_receive(struct fuse_chan **chp, char *buf,
 				  size_t size)
 {
-	struct fuse_chan *ch = *chp;
-	int err;
-	ssize_t res;
-	struct fuse_session *se = fuse_chan_session(ch);
-	assert(se != NULL);
+  struct fuse_chan *ch = *chp;
+  int err;
+  ssize_t res;
+  struct fuse_session *se = fuse_chan_session(ch);
+  assert(se != NULL);
 
-restart:
-	res = read(fuse_chan_fd(ch), buf, size);
-	err = errno;
+ restart:
+  res = read(fuse_chan_fd(ch), buf, size);
+  err = errno;
 
-	if (fuse_session_exited(se))
-		return 0;
-	if (res == -1) {
-		/* ENOENT means the operation was interrupted, it's safe
-		   to restart */
-		if (err == ENOENT)
-			goto restart;
+  if (fuse_session_exited(se))
+    return 0;
+  if (res == -1) {
+    /* ENOENT means the operation was interrupted, it's safe
+       to restart */
+    if (err == ENOENT)
+      goto restart;
 
-		if (err == ENODEV) {
-			fuse_session_exit(se);
-			return 0;
-		}
-		/* Errors occurring during normal operation: EINTR (read
-		   interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
-		   umounted) */
-		if (err != EINTR && err != EAGAIN)
-			perror("fuse: reading device");
-		return -err;
-	}
-	if ((size_t) res < sizeof(struct fuse_in_header)) {
-		fprintf(stderr, "short read on fuse device\n");
-		return -EIO;
-	}
-	return res;
+    if (err == ENODEV) {
+      fuse_session_exit(se);
+      return 0;
+    }
+    /* Errors occurring during normal operation: EINTR (read
+       interrupted), EAGAIN (nonblocking I/O), ENODEV (filesystem
+       umounted) */
+    if (err != EINTR && err != EAGAIN)
+      perror("fuse: reading device");
+    return -err;
+  }
+  if ((size_t) res < sizeof(struct fuse_in_header)) {
+    fprintf(stderr, "short read on fuse device\n");
+    return -EIO;
+  }
+  return res;
 }
 
 static int fuse_kern_chan_send(struct fuse_chan *ch, const struct iovec iov[],
 			       size_t count)
 {
-	if (iov) {
-		ssize_t res = writev(fuse_chan_fd(ch), iov, count);
-		int err = errno;
+  if (iov) {
+    ssize_t res = writev(fuse_chan_fd(ch), iov, count);
+    int err = errno;
 
-		if (res == -1) {
-			struct fuse_session *se = fuse_chan_session(ch);
+    if (res == -1) {
+      struct fuse_session *se = fuse_chan_session(ch);
 
-			assert(se != NULL);
+      assert(se != NULL);
 
-			/* ENOENT means the operation was interrupted */
-			if (!fuse_session_exited(se) && err != ENOENT)
-				perror("fuse: writing device");
-			return -err;
-		}
-	}
-	return 0;
+      /* ENOENT means the operation was interrupted */
+      if (!fuse_session_exited(se) && err != ENOENT)
+        perror("fuse: writing device");
+      return -err;
+    }
+  }
+  return 0;
 }
 
 static void fuse_kern_chan_destroy(struct fuse_chan *ch)
 {
-	int fd = fuse_chan_fd(ch);
+  int fd = fuse_chan_fd(ch);
 
-	if (fd != -1)
-		close(fd);
+  if (fd != -1)
+    close(fd);
 }
 
-#define MIN_BUFSIZE 0x21000
-
-struct fuse_chan *fuse_kern_chan_new(int fd)
+struct fuse_chan *
+fuse_kern_chan_new(int fd_)
 {
-	struct fuse_chan_ops op = {
-		.receive = fuse_kern_chan_receive,
-		.send = fuse_kern_chan_send,
-		.destroy = fuse_kern_chan_destroy,
-	};
-	size_t bufsize = getpagesize() + 0x1000;
-	bufsize = bufsize < MIN_BUFSIZE ? MIN_BUFSIZE : bufsize;
-	return fuse_chan_new(&op, fd, bufsize, NULL);
+  long pagesize;
+  size_t bufsize;
+  struct fuse_chan_ops op =
+    {
+      .receive = fuse_kern_chan_receive,
+      .send    = fuse_kern_chan_send,
+      .destroy = fuse_kern_chan_destroy,
+    };
+
+  pagesize = sysconf(_SC_PAGESIZE);
+
+  bufsize = ((FUSE_MAX_MAX_PAGES * pagesize) + 0x1000);
+
+  return fuse_chan_new(&op, fd_, bufsize, NULL);
 }

libfuse/lib/fuse_loop.c

@@ -1,46 +0,0 @@
-/*
-  FUSE: Filesystem in Userspace
-  Copyright (C) 2001-2007  Miklos Szeredi <miklos@szeredi.hu>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB
-*/
-
-#include "fuse_lowlevel.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <errno.h>
-
-int fuse_session_loop(struct fuse_session *se)
-{
-	int res = 0;
-	struct fuse_chan *ch = fuse_session_next_chan(se, NULL);
-	size_t bufsize = fuse_chan_bufsize(ch);
-	char *buf = (char *) malloc(bufsize);
-	if (!buf) {
-		fprintf(stderr, "fuse: failed to allocate read buffer\n");
-		return -1;
-	}
-
-	while (!fuse_session_exited(se)) {
-		struct fuse_chan *tmpch = ch;
-		struct fuse_buf fbuf = {
-			.mem = buf,
-			.size = bufsize,
-		};
-
-		res = fuse_session_receive_buf(se, &fbuf, &tmpch);
-
-		if (res == -EINTR)
-			continue;
-		if (res <= 0)
-			break;
-
-		fuse_session_process_buf(se, &fbuf, tmpch);
-	}
-
-	free(buf);
-	fuse_session_reset(se);
-	return res < 0 ? -1 : 0;
-}

libfuse/lib/fuse_loop_mt.c

@@ -25,147 +25,147 @@
 #define ENVNAME_THREAD_STACK "FUSE_THREAD_STACK"
 
 struct fuse_worker {
-	struct fuse_worker *prev;
-	struct fuse_worker *next;
-	pthread_t thread_id;
-	size_t bufsize;
-	char *buf;
-	struct fuse_mt *mt;
+  struct fuse_worker *prev;
+  struct fuse_worker *next;
+  pthread_t thread_id;
+  size_t bufsize;
+  char *buf;
+  struct fuse_mt *mt;
 };
 
 struct fuse_mt {
-	struct fuse_session *se;
-	struct fuse_chan *prevch;
-	struct fuse_worker main;
-	sem_t finish;
-	int exit;
-	int error;
+  struct fuse_session *se;
+  struct fuse_chan *prevch;
+  struct fuse_worker main;
+  sem_t finish;
+  int exit;
+  int error;
 };
 
 static void list_add_worker(struct fuse_worker *w, struct fuse_worker *next)
 {
-	struct fuse_worker *prev = next->prev;
-	w->next = next;
-	w->prev = prev;
-	prev->next = w;
-	next->prev = w;
+  struct fuse_worker *prev = next->prev;
+  w->next = next;
+  w->prev = prev;
+  prev->next = w;
+  next->prev = w;
 }
 
 static void list_del_worker(struct fuse_worker *w)
 {
-	struct fuse_worker *prev = w->prev;
-	struct fuse_worker *next = w->next;
-	prev->next = next;
-	next->prev = prev;
+  struct fuse_worker *prev = w->prev;
+  struct fuse_worker *next = w->next;
+  prev->next = next;
+  next->prev = prev;
 }
 
 static int fuse_loop_start_thread(struct fuse_mt *mt);
 
 static void *fuse_do_work(void *data)
 {
-	struct fuse_worker *w  = (struct fuse_worker *) data;
-	struct fuse_mt     *mt = w->mt;
+  struct fuse_worker *w  = (struct fuse_worker *) data;
+  struct fuse_mt     *mt = w->mt;
 
-	while (!fuse_session_exited(mt->se)) {
-		struct fuse_chan *ch = mt->prevch;
-		struct fuse_buf fbuf = {
-			.mem = w->buf,
-			.size = w->bufsize,
-		};
-		int res;
+  while (!fuse_session_exited(mt->se)) {
+    struct fuse_chan *ch = mt->prevch;
+    struct fuse_buf fbuf = {
+      .mem = w->buf,
+      .size = w->bufsize,
+    };
+    int res;
 
-		pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
-		res = fuse_session_receive_buf(mt->se, &fbuf, &ch);
-		pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
-		if (res == -EINTR)
-			continue;
-		if (res <= 0) {
-			if (res < 0) {
-				fuse_session_exit(mt->se);
-				mt->error = -1;
-			}
-			break;
-		}
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
+    res = fuse_session_receive_buf(mt->se, &fbuf, &ch);
+    pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+    if (res == -EINTR)
+      continue;
+    if (res <= 0) {
+      if (res < 0) {
+        fuse_session_exit(mt->se);
+        mt->error = -1;
+      }
+      break;
+    }
 
-		if (mt->exit)
-			return NULL;
+    if (mt->exit)
+      return NULL;
 
-		fuse_session_process_buf(mt->se, &fbuf, ch);
-	}
+    fuse_session_process_buf(mt->se, &fbuf, ch);
+  }
 
-	sem_post(&mt->finish);
+  sem_post(&mt->finish);
 
-	return NULL;
+  return NULL;
 }
 
 int fuse_start_thread(pthread_t *thread_id, void *(*func)(void *), void *arg)
 {
-	sigset_t oldset;
-	sigset_t newset;
-	int res;
-	pthread_attr_t attr;
-	char *stack_size;
+  sigset_t oldset;
+  sigset_t newset;
+  int res;
+  pthread_attr_t attr;
+  char *stack_size;
 
-	/* Override default stack size */
-	pthread_attr_init(&attr);
-	stack_size = getenv(ENVNAME_THREAD_STACK);
-	if (stack_size && pthread_attr_setstacksize(&attr, atoi(stack_size)))
-		fprintf(stderr, "fuse: invalid stack size: %s\n", stack_size);
+  /* Override default stack size */
+  pthread_attr_init(&attr);
+  stack_size = getenv(ENVNAME_THREAD_STACK);
+  if (stack_size && pthread_attr_setstacksize(&attr, atoi(stack_size)))
+    fprintf(stderr, "fuse: invalid stack size: %s\n", stack_size);
 
-	/* Disallow signal reception in worker threads */
-	sigemptyset(&newset);
-	sigaddset(&newset, SIGTERM);
-	sigaddset(&newset, SIGINT);
-	sigaddset(&newset, SIGHUP);
-	sigaddset(&newset, SIGQUIT);
-	pthread_sigmask(SIG_BLOCK, &newset, &oldset);
-	res = pthread_create(thread_id, &attr, func, arg);
-	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-	pthread_attr_destroy(&attr);
-	if (res != 0) {
-		fprintf(stderr, "fuse: error creating thread: %s\n",
-			strerror(res));
-		return -1;
-	}
+  /* Disallow signal reception in worker threads */
+  sigemptyset(&newset);
+  sigaddset(&newset, SIGTERM);
+  sigaddset(&newset, SIGINT);
+  sigaddset(&newset, SIGHUP);
+  sigaddset(&newset, SIGQUIT);
+  pthread_sigmask(SIG_BLOCK, &newset, &oldset);
+  res = pthread_create(thread_id, &attr, func, arg);
+  pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+  pthread_attr_destroy(&attr);
+  if (res != 0) {
+    fprintf(stderr, "fuse: error creating thread: %s\n",
+            strerror(res));
+    return -1;
+  }
 
-	return 0;
+  return 0;
 }
 
 static int fuse_loop_start_thread(struct fuse_mt *mt)
 {
-	int res;
-	struct fuse_worker *w = malloc(sizeof(struct fuse_worker));
-	if (!w) {
-		fprintf(stderr, "fuse: failed to allocate worker structure\n");
-		return -1;
-	}
-	memset(w, 0, sizeof(struct fuse_worker));
-	w->bufsize = fuse_chan_bufsize(mt->prevch);
-	w->buf = malloc(w->bufsize);
-	w->mt = mt;
-	if (!w->buf) {
-		fprintf(stderr, "fuse: failed to allocate read buffer\n");
-		free(w);
-		return -1;
-	}
+  int res;
+  struct fuse_worker *w = malloc(sizeof(struct fuse_worker));
+  if (!w) {
+    fprintf(stderr, "fuse: failed to allocate worker structure\n");
+    return -1;
+  }
+  memset(w, 0, sizeof(struct fuse_worker));
+  w->bufsize = fuse_chan_bufsize(mt->prevch);
+  w->buf = calloc(w->bufsize,1);
+  w->mt = mt;
+  if (!w->buf) {
+    fprintf(stderr, "fuse: failed to allocate read buffer\n");
+    free(w);
+    return -1;
+  }
 
-	res = fuse_start_thread(&w->thread_id, fuse_do_work, w);
-	if (res == -1) {
-		free(w->buf);
-		free(w);
-		return -1;
-	}
-	list_add_worker(w, &mt->main);
+  res = fuse_start_thread(&w->thread_id, fuse_do_work, w);
+  if (res == -1) {
+    free(w->buf);
+    free(w);
+    return -1;
+  }
+  list_add_worker(w, &mt->main);
 
-	return 0;
+  return 0;
 }
 
 static void fuse_join_worker(struct fuse_worker *w)
 {
-	pthread_join(w->thread_id, NULL);
-	list_del_worker(w);
-	free(w->buf);
-	free(w);
+  pthread_join(w->thread_id, NULL);
+  list_del_worker(w);
+  free(w->buf);
+  free(w);
 }
 
 static int number_of_threads(void)
@@ -180,46 +180,46 @@ static int number_of_threads(void)
 int fuse_session_loop_mt(struct fuse_session *se,
                          const int            _threads)
 {
-        int i;
-	int err;
-        int threads;
-	struct fuse_mt mt;
-	struct fuse_worker *w;
+  int i;
+  int err;
+  int threads;
+  struct fuse_mt mt;
+  struct fuse_worker *w;
 
-	memset(&mt, 0, sizeof(struct fuse_mt));
-	mt.se = se;
-	mt.prevch = fuse_session_next_chan(se, NULL);
-	mt.error = 0;
-	mt.main.thread_id = pthread_self();
-	mt.main.prev = mt.main.next = &mt.main;
-	sem_init(&mt.finish, 0, 0);
+  memset(&mt, 0, sizeof(struct fuse_mt));
+  mt.se = se;
+  mt.prevch = fuse_session_next_chan(se, NULL);
+  mt.error = 0;
+  mt.main.thread_id = pthread_self();
+  mt.main.prev = mt.main.next = &mt.main;
+  sem_init(&mt.finish, 0, 0);
 
-        threads = ((_threads > 0) ? _threads : number_of_threads());
-        if(_threads < 0)
-          threads /= -_threads;
-        if(threads == 0)
-          threads = 1;
+  threads = ((_threads > 0) ? _threads : number_of_threads());
+  if(_threads < 0)
+    threads /= -_threads;
+  if(threads == 0)
+    threads = 1;
 
-        err = 0;
-        for(i = 0; (i < threads) && !err; i++)
-          err = fuse_loop_start_thread(&mt);
+  err = 0;
+  for(i = 0; (i < threads) && !err; i++)
+    err = fuse_loop_start_thread(&mt);
 
-	if (!err) {
-		/* sem_wait() is interruptible */
-		while (!fuse_session_exited(se))
-			sem_wait(&mt.finish);
+  if (!err) {
+    /* sem_wait() is interruptible */
+    while (!fuse_session_exited(se))
+      sem_wait(&mt.finish);
 
-		for (w = mt.main.next; w != &mt.main; w = w->next)
-			pthread_cancel(w->thread_id);
-		mt.exit = 1;
+    for (w = mt.main.next; w != &mt.main; w = w->next)
+      pthread_cancel(w->thread_id);
+    mt.exit = 1;
 
-		while (mt.main.next != &mt.main)
-			fuse_join_worker(mt.main.next);
+    while (mt.main.next != &mt.main)
+      fuse_join_worker(mt.main.next);
 
-		err = mt.error;
-	}
+    err = mt.error;
+  }
 
-	sem_destroy(&mt.finish);
-	fuse_session_reset(se);
-	return err;
+  sem_destroy(&mt.finish);
+  fuse_session_reset(se);
+  return err;
 }

libfuse/lib/fuse_misc.h

@@ -6,13 +6,16 @@
   See the file COPYING.LIB
 */
 
+#pragma once
+
 #include "config.h"
+
 #include <pthread.h>
 
 /*
   Versioned symbols cannot be used in some cases because it
-    - confuse the dynamic linker in uClibc
-    - not supported on MacOSX (in MachO binary format)
+  - confuse the dynamic linker in uClibc
+  - not supported on MacOSX (in MachO binary format)
 */
 #if (!defined(__UCLIBC__) && !defined(__APPLE__))
 #define FUSE_SYMVER(x) __asm__(x)
@@ -26,32 +29,35 @@
 /* Is this hack still needed? */
 static inline void fuse_mutex_init(pthread_mutex_t *mut)
 {
-	pthread_mutexattr_t attr;
-	pthread_mutexattr_init(&attr);
-	pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
-	pthread_mutex_init(mut, &attr);
-	pthread_mutexattr_destroy(&attr);
+  pthread_mutexattr_t attr;
+  pthread_mutexattr_init(&attr);
+  pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_ADAPTIVE_NP);
+  pthread_mutex_init(mut, &attr);
+  pthread_mutexattr_destroy(&attr);
 }
 #endif
 
 #ifdef HAVE_STRUCT_STAT_ST_ATIM
 /* Linux */
-#define ST_ATIM_NSEC(stbuf) ((stbuf)->st_atim.tv_nsec)
-#define ST_CTIM_NSEC(stbuf) ((stbuf)->st_ctim.tv_nsec)
-#define ST_MTIM_NSEC(stbuf) ((stbuf)->st_mtim.tv_nsec)
-#define ST_ATIM_NSEC_SET(stbuf, val) (stbuf)->st_atim.tv_nsec = (val)
-#define ST_MTIM_NSEC_SET(stbuf, val) (stbuf)->st_mtim.tv_nsec = (val)
+#define ST_ATIM_NSEC(stbuf)         ((stbuf)->st_atim.tv_nsec)
+#define ST_CTIM_NSEC(stbuf)         ((stbuf)->st_ctim.tv_nsec)
+#define ST_MTIM_NSEC(stbuf)         ((stbuf)->st_mtim.tv_nsec)
+#define ST_ATIM_NSEC_SET(stbuf,val) ((stbuf)->st_atim.tv_nsec = (val))
+#define ST_CTIM_NSEC_SET(stbuf,val) ((stbuf)->st_ctim.tv_nsec = (val))
+#define ST_MTIM_NSEC_SET(stbuf,val) ((stbuf)->st_mtim.tv_nsec = (val))
 #elif defined(HAVE_STRUCT_STAT_ST_ATIMESPEC)
 /* FreeBSD */
-#define ST_ATIM_NSEC(stbuf) ((stbuf)->st_atimespec.tv_nsec)
-#define ST_CTIM_NSEC(stbuf) ((stbuf)->st_ctimespec.tv_nsec)
-#define ST_MTIM_NSEC(stbuf) ((stbuf)->st_mtimespec.tv_nsec)
-#define ST_ATIM_NSEC_SET(stbuf, val) (stbuf)->st_atimespec.tv_nsec = (val)
-#define ST_MTIM_NSEC_SET(stbuf, val) (stbuf)->st_mtimespec.tv_nsec = (val)
+#define ST_ATIM_NSEC(stbuf)         ((stbuf)->st_atimespec.tv_nsec)
+#define ST_CTIM_NSEC(stbuf)         ((stbuf)->st_ctimespec.tv_nsec)
+#define ST_MTIM_NSEC(stbuf)         ((stbuf)->st_mtimespec.tv_nsec)
+#define ST_ATIM_NSEC_SET(stbuf,val) ((stbuf)->st_atimespec.tv_nsec = (val))
+#define ST_CTIM_NSEC_SET(stbuf,val) ((stbuf)->st_ctimespec.tv_nsec = (val))
+#define ST_MTIM_NSEC_SET(stbuf,val) ((stbuf)->st_mtimespec.tv_nsec = (val))
 #else
 #define ST_ATIM_NSEC(stbuf) 0
 #define ST_CTIM_NSEC(stbuf) 0
 #define ST_MTIM_NSEC(stbuf) 0
-#define ST_ATIM_NSEC_SET(stbuf, val) do { } while (0)
-#define ST_MTIM_NSEC_SET(stbuf, val) do { } while (0)
+#define ST_ATIM_NSEC_SET(stbuf,val) do { } while (0)
+#define ST_CTIM_NSEC_SET(stbuf,val) do { } while (0)
+#define ST_MTIM_NSEC_SET(stbuf,val) do { } while (0)
 #endif

libfuse/lib/fuse_mt.c

@@ -16,109 +16,108 @@
 #include <pthread.h>
 #include <assert.h>
 
-struct procdata {
-	struct fuse *f;
-	struct fuse_chan *prevch;
-	struct fuse_session *prevse;
-	fuse_processor_t proc;
-	void *data;
+struct procdata
+{
+  struct fuse *f;
+  struct fuse_chan *prevch;
+  struct fuse_session *prevse;
+  fuse_processor_t proc;
+  void *data;
 };
 
 static void mt_session_proc(void *data, const char *buf, size_t len,
 			    struct fuse_chan *ch)
 {
-	struct procdata *pd = (struct procdata *) data;
-	struct fuse_cmd *cmd = *(struct fuse_cmd **) buf;
+  struct procdata *pd = (struct procdata *) data;
+  struct fuse_cmd *cmd = *(struct fuse_cmd **) buf;
 
-	(void) len;
-	(void) ch;
-	pd->proc(pd->f, cmd, pd->data);
+  (void) len;
+  (void) ch;
+  pd->proc(pd->f, cmd, pd->data);
 }
 
 static void mt_session_exit(void *data, int val)
 {
-	struct procdata *pd = (struct procdata *) data;
-	if (val)
-		fuse_session_exit(pd->prevse);
-	else
-		fuse_session_reset(pd->prevse);
+  struct procdata *pd = (struct procdata *) data;
+  if (val)
+    fuse_session_exit(pd->prevse);
+  else
+    fuse_session_reset(pd->prevse);
 }
 
 static int mt_session_exited(void *data)
 {
-	struct procdata *pd = (struct procdata *) data;
-	return fuse_session_exited(pd->prevse);
+  struct procdata *pd = (struct procdata *) data;
+  return fuse_session_exited(pd->prevse);
 }
 
 static int mt_chan_receive(struct fuse_chan **chp, char *buf, size_t size)
 {
-	struct fuse_cmd *cmd;
-	struct procdata *pd = (struct procdata *) fuse_chan_data(*chp);
+  struct fuse_cmd *cmd;
+  struct procdata *pd = (struct procdata *) fuse_chan_data(*chp);
 
-	assert(size >= sizeof(cmd));
+  assert(size >= sizeof(cmd));
 
-	cmd = fuse_read_cmd(pd->f);
-	if (cmd == NULL)
-		return 0;
+  cmd = fuse_read_cmd(pd->f);
+  if (cmd == NULL)
+    return 0;
 
-	*(struct fuse_cmd **) buf = cmd;
+  *(struct fuse_cmd **)buf = cmd;
 
-	return sizeof(cmd);
+  return sizeof(cmd);
 }
 
 int fuse_loop_mt_proc(struct fuse *f, fuse_processor_t proc, void *data)
 {
-	int res;
-	struct procdata pd;
-	struct fuse_session *prevse = fuse_get_session(f);
-	struct fuse_session *se;
-	struct fuse_chan *prevch = fuse_session_next_chan(prevse, NULL);
-	struct fuse_chan *ch;
-	struct fuse_session_ops sop = {
-		.exit = mt_session_exit,
-		.exited = mt_session_exited,
-		.process = mt_session_proc,
-	};
-	struct fuse_chan_ops cop = {
-		.receive = mt_chan_receive,
-	};
+  int res;
+  struct procdata pd;
+  struct fuse_session *prevse = fuse_get_session(f);
+  struct fuse_session *se;
+  struct fuse_chan *prevch = fuse_session_next_chan(prevse, NULL);
+  struct fuse_chan *ch;
+  struct fuse_session_ops sop = {
+    .exit = mt_session_exit,
+    .exited = mt_session_exited,
+    .process = mt_session_proc,
+  };
+  struct fuse_chan_ops cop = {
+    .receive = mt_chan_receive,
+  };
 
-	pd.f = f;
-	pd.prevch = prevch;
-	pd.prevse = prevse;
-	pd.proc = proc;
-	pd.data = data;
+  pd.f = f;
+  pd.prevch = prevch;
+  pd.prevse = prevse;
+  pd.proc = proc;
+  pd.data = data;
 
-	se = fuse_session_new(&sop, &pd);
-	if (se == NULL)
-		return -1;
+  se = fuse_session_new(&sop, &pd);
+  if (se == NULL)
+    return -1;
 
-	ch = fuse_chan_new(&cop, fuse_chan_fd(prevch),
-			   sizeof(struct fuse_cmd *), &pd);
-	if (ch == NULL) {
-		fuse_session_destroy(se);
-		return -1;
-	}
-	fuse_session_add_chan(se, ch);
-	res = fuse_session_loop_mt(se,
-                                   fuse_config_num_threads(f));
-	fuse_session_destroy(se);
-	return res;
+  ch = fuse_chan_new(&cop, fuse_chan_fd(prevch),
+                     sizeof(struct fuse_cmd *), &pd);
+  if (ch == NULL) {
+    fuse_session_destroy(se);
+    return -1;
+  }
+  fuse_session_add_chan(se, ch);
+  res = fuse_session_loop_mt(se,
+                             fuse_config_num_threads(f));
+  fuse_session_destroy(se);
+  return res;
 }
 
 int fuse_loop_mt(struct fuse *f)
 {
-	if (f == NULL)
-		return -1;
+  if (f == NULL)
+    return -1;
 
-	int res = fuse_start_cleanup_thread(f);
-	if (res)
-		return -1;
+  int res = fuse_start_cleanup_thread(f);
+  if (res)
+    return -1;
 
-	res = fuse_session_loop_mt(fuse_get_session(f),
-                                   fuse_config_num_threads(f));
-	fuse_stop_cleanup_thread(f);
-	return res;
+  res = fuse_session_loop_mt(fuse_get_session(f),
+                             fuse_config_num_threads(f));
+  fuse_stop_cleanup_thread(f);
+  return res;
 }
-
-FUSE_SYMVER(".symver fuse_loop_mt_proc,__fuse_loop_mt@");

libfuse/lib/fuse_opt.c

@@ -14,413 +14,408 @@
 #include <string.h>
 #include <assert.h>
 
-struct fuse_opt_context {
-	void *data;
-	const struct fuse_opt *opt;
-	fuse_opt_proc_t proc;
-	int argctr;
-	int argc;
-	char **argv;
-	struct fuse_args outargs;
-	char *opts;
-	int nonopt;
+struct fuse_opt_context
+{
+  void *data;
+  const struct fuse_opt *opt;
+  fuse_opt_proc_t proc;
+  int argctr;
+  int argc;
+  char **argv;
+  struct fuse_args outargs;
+  char *opts;
+  int nonopt;
 };
 
-void fuse_opt_free_args(struct fuse_args *args)
+void
+fuse_opt_free_args(struct fuse_args *args)
 {
-	if (args) {
-		if (args->argv && args->allocated) {
-			int i;
-			for (i = 0; i < args->argc; i++)
-				free(args->argv[i]);
-			free(args->argv);
-		}
-		args->argc = 0;
-		args->argv = NULL;
-		args->allocated = 0;
-	}
+  if (args) {
+    if (args->argv && args->allocated) {
+      int i;
+      for (i = 0; i < args->argc; i++)
+        free(args->argv[i]);
+      free(args->argv);
+    }
+    args->argc = 0;
+    args->argv = NULL;
+    args->allocated = 0;
+  }
 }
 
-static int alloc_failed(void)
+static
+int
+alloc_failed(void)
 {
-	fprintf(stderr, "fuse: memory allocation failed\n");
-	return -1;
+  fprintf(stderr, "fuse: memory allocation failed\n");
+  return -1;
 }
 
-int fuse_opt_add_arg(struct fuse_args *args, const char *arg)
+int
+fuse_opt_add_arg(struct fuse_args *args, const char *arg)
 {
-	char **newargv;
-	char *newarg;
+  char **newargv;
+  char *newarg;
 
-	assert(!args->argv || args->allocated);
+  assert(!args->argv || args->allocated);
 
-	newarg = strdup(arg);
-	if (!newarg)
-		return alloc_failed();
+  newarg = strdup(arg);
+  if (!newarg)
+    return alloc_failed();
 
-	newargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));
-	if (!newargv) {
-		free(newarg);
-		return alloc_failed();
-	}
+  newargv = realloc(args->argv, (args->argc + 2) * sizeof(char *));
+  if (!newargv) {
+    free(newarg);
+    return alloc_failed();
+  }
 
-	args->argv = newargv;
-	args->allocated = 1;
-	args->argv[args->argc++] = newarg;
-	args->argv[args->argc] = NULL;
-	return 0;
+  args->argv = newargv;
+  args->allocated = 1;
+  args->argv[args->argc++] = newarg;
+  args->argv[args->argc] = NULL;
+  return 0;
 }
 
 static int fuse_opt_insert_arg_common(struct fuse_args *args, int pos,
 				      const char *arg)
 {
-	assert(pos <= args->argc);
-	if (fuse_opt_add_arg(args, arg) == -1)
-		return -1;
+  assert(pos <= args->argc);
+  if (fuse_opt_add_arg(args, arg) == -1)
+    return -1;
 
-	if (pos != args->argc - 1) {
-		char *newarg = args->argv[args->argc - 1];
-		memmove(&args->argv[pos + 1], &args->argv[pos],
-			sizeof(char *) * (args->argc - pos - 1));
-		args->argv[pos] = newarg;
-	}
-	return 0;
+  if (pos != args->argc - 1) {
+    char *newarg = args->argv[args->argc - 1];
+    memmove(&args->argv[pos + 1], &args->argv[pos],
+            sizeof(char *) * (args->argc - pos - 1));
+    args->argv[pos] = newarg;
+  }
+  return 0;
 }
 
 int fuse_opt_insert_arg(struct fuse_args *args, int pos, const char *arg)
 {
-	return fuse_opt_insert_arg_common(args, pos, arg);
-}
-
-int fuse_opt_insert_arg_compat(struct fuse_args *args, int pos,
-			       const char *arg);
-int fuse_opt_insert_arg_compat(struct fuse_args *args, int pos, const char *arg)
-{
-	return fuse_opt_insert_arg_common(args, pos, arg);
+  return fuse_opt_insert_arg_common(args, pos, arg);
 }
 
 static int next_arg(struct fuse_opt_context *ctx, const char *opt)
 {
-	if (ctx->argctr + 1 >= ctx->argc) {
-		fprintf(stderr, "fuse: missing argument after `%s'\n", opt);
-		return -1;
-	}
-	ctx->argctr++;
-	return 0;
+  if (ctx->argctr + 1 >= ctx->argc) {
+    fprintf(stderr, "fuse: missing argument after `%s'\n", opt);
+    return -1;
+  }
+  ctx->argctr++;
+  return 0;
 }
 
 static int add_arg(struct fuse_opt_context *ctx, const char *arg)
 {
-	return fuse_opt_add_arg(&ctx->outargs, arg);
+  return fuse_opt_add_arg(&ctx->outargs, arg);
 }
 
 static int add_opt_common(char **opts, const char *opt, int esc)
 {
-	unsigned oldlen = *opts ? strlen(*opts) : 0;
-	char *d = realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);
+  unsigned oldlen = *opts ? strlen(*opts) : 0;
+  char *d = realloc(*opts, oldlen + 1 + strlen(opt) * 2 + 1);
 
-	if (!d)
-		return alloc_failed();
+  if (!d)
+    return alloc_failed();
 
-	*opts = d;
-	if (oldlen) {
-		d += oldlen;
-		*d++ = ',';
-	}
+  *opts = d;
+  if (oldlen) {
+    d += oldlen;
+    *d++ = ',';
+  }
 
-	for (; *opt; opt++) {
-		if (esc && (*opt == ',' || *opt == '\\'))
-			*d++ = '\\';
-		*d++ = *opt;
-	}
-	*d = '\0';
+  for (; *opt; opt++) {
+    if (esc && (*opt == ',' || *opt == '\\'))
+      *d++ = '\\';
+    *d++ = *opt;
+  }
+  *d = '\0';
 
-	return 0;
+  return 0;
 }
 
 int fuse_opt_add_opt(char **opts, const char *opt)
 {
-	return add_opt_common(opts, opt, 0);
+  return add_opt_common(opts, opt, 0);
 }
 
 int fuse_opt_add_opt_escaped(char **opts, const char *opt)
 {
-	return add_opt_common(opts, opt, 1);
+  return add_opt_common(opts, opt, 1);
 }
 
 static int add_opt(struct fuse_opt_context *ctx, const char *opt)
 {
-	return add_opt_common(&ctx->opts, opt, 1);
+  return add_opt_common(&ctx->opts, opt, 1);
 }
 
 static int call_proc(struct fuse_opt_context *ctx, const char *arg, int key,
 		     int iso)
 {
-	if (key == FUSE_OPT_KEY_DISCARD)
-		return 0;
+  if (key == FUSE_OPT_KEY_DISCARD)
+    return 0;
 
-	if (key != FUSE_OPT_KEY_KEEP && ctx->proc) {
-		int res = ctx->proc(ctx->data, arg, key, &ctx->outargs);
-		if (res == -1 || !res)
-			return res;
-	}
-	if (iso)
-		return add_opt(ctx, arg);
-	else
-		return add_arg(ctx, arg);
+  if (key != FUSE_OPT_KEY_KEEP && ctx->proc) {
+    int res = ctx->proc(ctx->data, arg, key, &ctx->outargs);
+    if (res == -1 || !res)
+      return res;
+  }
+  if (iso)
+    return add_opt(ctx, arg);
+  else
+    return add_arg(ctx, arg);
 }
 
 static int match_template(const char *t, const char *arg, unsigned *sepp)
 {
-	int arglen = strlen(arg);
-	const char *sep = strchr(t, '=');
-	sep = sep ? sep : strchr(t, ' ');
-	if (sep && (!sep[1] || sep[1] == '%')) {
-		int tlen = sep - t;
-		if (sep[0] == '=')
-			tlen ++;
-		if (arglen >= tlen && strncmp(arg, t, tlen) == 0) {
-			*sepp = sep - t;
-			return 1;
-		}
-	}
-	if (strcmp(t, arg) == 0) {
-		*sepp = 0;
-		return 1;
-	}
-	return 0;
+  int arglen = strlen(arg);
+  const char *sep = strchr(t, '=');
+  sep = sep ? sep : strchr(t, ' ');
+  if (sep && (!sep[1] || sep[1] == '%')) {
+    int tlen = sep - t;
+    if (sep[0] == '=')
+      tlen ++;
+    if (arglen >= tlen && strncmp(arg, t, tlen) == 0) {
+      *sepp = sep - t;
+      return 1;
+    }
+  }
+  if (strcmp(t, arg) == 0) {
+    *sepp = 0;
+    return 1;
+  }
+  return 0;
 }
 
 static const struct fuse_opt *find_opt(const struct fuse_opt *opt,
 				       const char *arg, unsigned *sepp)
 {
-	for (; opt && opt->templ; opt++)
-		if (match_template(opt->templ, arg, sepp))
-			return opt;
-	return NULL;
+  for (; opt && opt->templ; opt++)
+    if (match_template(opt->templ, arg, sepp))
+      return opt;
+  return NULL;
 }
 
 int fuse_opt_match(const struct fuse_opt *opts, const char *opt)
 {
-	unsigned dummy;
-	return find_opt(opts, opt, &dummy) ? 1 : 0;
+  unsigned dummy;
+  return find_opt(opts, opt, &dummy) ? 1 : 0;
 }
 
 static int process_opt_param(void *var, const char *format, const char *param,
 			     const char *arg)
 {
-	assert(format[0] == '%');
-	if (format[1] == 's') {
-		char *copy = strdup(param);
-		if (!copy)
-			return alloc_failed();
+  assert(format[0] == '%');
+  if (format[1] == 's') {
+    char *copy = strdup(param);
+    if (!copy)
+      return alloc_failed();
 
-		*(char **) var = copy;
-	} else {
-		if (sscanf(param, format, var) != 1) {
-			fprintf(stderr, "fuse: invalid parameter in option `%s'\n", arg);
-			return -1;
-		}
-	}
-	return 0;
+    *(char **) var = copy;
+  } else {
+    if (sscanf(param, format, var) != 1) {
+      fprintf(stderr, "fuse: invalid parameter in option `%s'\n", arg);
+      return -1;
+    }
+  }
+  return 0;
 }
 
 static int process_opt(struct fuse_opt_context *ctx,
 		       const struct fuse_opt *opt, unsigned sep,
 		       const char *arg, int iso)
 {
-	if (opt->offset == -1U) {
-		if (call_proc(ctx, arg, opt->value, iso) == -1)
-			return -1;
-	} else {
-		void *var = ctx->data + opt->offset;
-		if (sep && opt->templ[sep + 1]) {
-			const char *param = arg + sep;
-			if (opt->templ[sep] == '=')
-				param ++;
-			if (process_opt_param(var, opt->templ + sep + 1,
-					      param, arg) == -1)
-				return -1;
-		} else
-			*(int *)var = opt->value;
-	}
-	return 0;
+  if (opt->offset == -1U) {
+    if (call_proc(ctx, arg, opt->value, iso) == -1)
+      return -1;
+  } else {
+    void *var = ctx->data + opt->offset;
+    if (sep && opt->templ[sep + 1]) {
+      const char *param = arg + sep;
+      if (opt->templ[sep] == '=')
+        param ++;
+      if (process_opt_param(var, opt->templ + sep + 1,
+                            param, arg) == -1)
+        return -1;
+    } else
+      *(int *)var = opt->value;
+  }
+  return 0;
 }
 
 static int process_opt_sep_arg(struct fuse_opt_context *ctx,
 			       const struct fuse_opt *opt, unsigned sep,
 			       const char *arg, int iso)
 {
-	int res;
-	char *newarg;
-	char *param;
+  int res;
+  char *newarg;
+  char *param;
 
-	if (next_arg(ctx, arg) == -1)
-		return -1;
+  if (next_arg(ctx, arg) == -1)
+    return -1;
 
-	param = ctx->argv[ctx->argctr];
-	newarg = malloc(sep + strlen(param) + 1);
-	if (!newarg)
-		return alloc_failed();
+  param = ctx->argv[ctx->argctr];
+  newarg = malloc(sep + strlen(param) + 1);
+  if (!newarg)
+    return alloc_failed();
 
-	memcpy(newarg, arg, sep);
-	strcpy(newarg + sep, param);
-	res = process_opt(ctx, opt, sep, newarg, iso);
-	free(newarg);
+  memcpy(newarg, arg, sep);
+  strcpy(newarg + sep, param);
+  res = process_opt(ctx, opt, sep, newarg, iso);
+  free(newarg);
 
-	return res;
+  return res;
 }
 
 static int process_gopt(struct fuse_opt_context *ctx, const char *arg, int iso)
 {
-	unsigned sep;
-	const struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep);
-	if (opt) {
-		for (; opt; opt = find_opt(opt + 1, arg, &sep)) {
-			int res;
-			if (sep && opt->templ[sep] == ' ' && !arg[sep])
-				res = process_opt_sep_arg(ctx, opt, sep, arg,
-							  iso);
-			else
-				res = process_opt(ctx, opt, sep, arg, iso);
-			if (res == -1)
-				return -1;
-		}
-		return 0;
-	} else
-		return call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);
+  unsigned sep;
+  const struct fuse_opt *opt = find_opt(ctx->opt, arg, &sep);
+  if (opt) {
+    for (; opt; opt = find_opt(opt + 1, arg, &sep)) {
+      int res;
+      if (sep && opt->templ[sep] == ' ' && !arg[sep])
+        res = process_opt_sep_arg(ctx, opt, sep, arg,
+                                  iso);
+      else
+        res = process_opt(ctx, opt, sep, arg, iso);
+      if (res == -1)
+        return -1;
+    }
+    return 0;
+  } else
+    return call_proc(ctx, arg, FUSE_OPT_KEY_OPT, iso);
 }
 
 static int process_real_option_group(struct fuse_opt_context *ctx, char *opts)
 {
-	char *s = opts;
-	char *d = s;
-	int end = 0;
+  char *s = opts;
+  char *d = s;
+  int end = 0;
 
-	while (!end) {
-		if (*s == '\0')
-			end = 1;
-		if (*s == ',' || end) {
-			int res;
+  while (!end) {
+    if (*s == '\0')
+      end = 1;
+    if (*s == ',' || end) {
+      int res;
 
-			*d = '\0';
-			res = process_gopt(ctx, opts, 1);
-			if (res == -1)
-				return -1;
-			d = opts;
-		} else {
-			if (s[0] == '\\' && s[1] != '\0') {
-				s++;
-				if (s[0] >= '0' && s[0] <= '3' &&
-				    s[1] >= '0' && s[1] <= '7' &&
-				    s[2] >= '0' && s[2] <= '7') {
-					*d++ = (s[0] - '0') * 0100 +
-						(s[1] - '0') * 0010 +
-						(s[2] - '0');
-					s += 2;
-				} else {
-					*d++ = *s;
-				}
-			} else {
-				*d++ = *s;
-			}
-		}
-		s++;
-	}
+      *d = '\0';
+      res = process_gopt(ctx, opts, 1);
+      if (res == -1)
+        return -1;
+      d = opts;
+    } else {
+      if (s[0] == '\\' && s[1] != '\0') {
+        s++;
+        if (s[0] >= '0' && s[0] <= '3' &&
+            s[1] >= '0' && s[1] <= '7' &&
+            s[2] >= '0' && s[2] <= '7') {
+          *d++ = (s[0] - '0') * 0100 +
+            (s[1] - '0') * 0010 +
+            (s[2] - '0');
+          s += 2;
+        } else {
+          *d++ = *s;
+        }
+      } else {
+        *d++ = *s;
+      }
+    }
+    s++;
+  }
 
-	return 0;
+  return 0;
 }
 
 static int process_option_group(struct fuse_opt_context *ctx, const char *opts)
 {
-	int res;
-	char *copy = strdup(opts);
+  int res;
+  char *copy = strdup(opts);
 
-	if (!copy) {
-		fprintf(stderr, "fuse: memory allocation failed\n");
-		return -1;
-	}
-	res = process_real_option_group(ctx, copy);
-	free(copy);
-	return res;
+  if (!copy) {
+    fprintf(stderr, "fuse: memory allocation failed\n");
+    return -1;
+  }
+  res = process_real_option_group(ctx, copy);
+  free(copy);
+  return res;
 }
 
 static int process_one(struct fuse_opt_context *ctx, const char *arg)
 {
-	if (ctx->nonopt || arg[0] != '-')
-		return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
-	else if (arg[1] == 'o') {
-		if (arg[2])
-			return process_option_group(ctx, arg + 2);
-		else {
-			if (next_arg(ctx, arg) == -1)
-				return -1;
+  if (ctx->nonopt || arg[0] != '-')
+    return call_proc(ctx, arg, FUSE_OPT_KEY_NONOPT, 0);
+  else if (arg[1] == 'o') {
+    if (arg[2])
+      return process_option_group(ctx, arg + 2);
+    else {
+      if (next_arg(ctx, arg) == -1)
+        return -1;
 
-			return process_option_group(ctx,
-						    ctx->argv[ctx->argctr]);
-		}
-	} else if (arg[1] == '-' && !arg[2]) {
-		if (add_arg(ctx, arg) == -1)
-			return -1;
-		ctx->nonopt = ctx->outargs.argc;
-		return 0;
-	} else
-		return process_gopt(ctx, arg, 0);
+      return process_option_group(ctx,
+                                  ctx->argv[ctx->argctr]);
+    }
+  } else if (arg[1] == '-' && !arg[2]) {
+    if (add_arg(ctx, arg) == -1)
+      return -1;
+    ctx->nonopt = ctx->outargs.argc;
+    return 0;
+  } else
+    return process_gopt(ctx, arg, 0);
 }
 
 static int opt_parse(struct fuse_opt_context *ctx)
 {
-	if (ctx->argc) {
-		if (add_arg(ctx, ctx->argv[0]) == -1)
-			return -1;
-	}
+  if (ctx->argc) {
+    if (add_arg(ctx, ctx->argv[0]) == -1)
+      return -1;
+  }
 
-	for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
-		if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
-			return -1;
+  for (ctx->argctr = 1; ctx->argctr < ctx->argc; ctx->argctr++)
+    if (process_one(ctx, ctx->argv[ctx->argctr]) == -1)
+      return -1;
 
-	if (ctx->opts) {
-		if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
-		    fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
-			return -1;
-	}
+  if (ctx->opts) {
+    if (fuse_opt_insert_arg(&ctx->outargs, 1, "-o") == -1 ||
+        fuse_opt_insert_arg(&ctx->outargs, 2, ctx->opts) == -1)
+      return -1;
+  }
 
-	/* If option separator ("--") is the last argument, remove it */
-	if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
-	    strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
-		free(ctx->outargs.argv[ctx->outargs.argc - 1]);
-		ctx->outargs.argv[--ctx->outargs.argc] = NULL;
-	}
+  /* If option separator ("--") is the last argument, remove it */
+  if (ctx->nonopt && ctx->nonopt == ctx->outargs.argc &&
+      strcmp(ctx->outargs.argv[ctx->outargs.argc - 1], "--") == 0) {
+    free(ctx->outargs.argv[ctx->outargs.argc - 1]);
+    ctx->outargs.argv[--ctx->outargs.argc] = NULL;
+  }
 
-	return 0;
+  return 0;
 }
 
 int fuse_opt_parse(struct fuse_args *args, void *data,
 		   const struct fuse_opt opts[], fuse_opt_proc_t proc)
 {
-	int res;
-	struct fuse_opt_context ctx = {
-		.data = data,
-		.opt = opts,
-		.proc = proc,
-	};
+  int res;
+  struct fuse_opt_context ctx = {
+    .data = data,
+    .opt = opts,
+    .proc = proc,
+  };
 
-	if (!args || !args->argv || !args->argc)
-		return 0;
+  if (!args || !args->argv || !args->argc)
+    return 0;
 
-	ctx.argc = args->argc;
-	ctx.argv = args->argv;
+  ctx.argc = args->argc;
+  ctx.argv = args->argv;
 
-	res = opt_parse(&ctx);
-	if (res != -1) {
-		struct fuse_args tmp = *args;
-		*args = ctx.outargs;
-		ctx.outargs = tmp;
-	}
-	free(ctx.opts);
-	fuse_opt_free_args(&ctx.outargs);
-	return res;
+  res = opt_parse(&ctx);
+  if (res != -1) {
+    struct fuse_args tmp = *args;
+    *args = ctx.outargs;
+    ctx.outargs = tmp;
+  }
+  free(ctx.opts);
+  fuse_opt_free_args(&ctx.outargs);
+  return res;
 }
-
-/* This symbol version was mistakenly added to the version script */
-FUSE_SYMVER(".symver fuse_opt_insert_arg_compat,fuse_opt_insert_arg@FUSE_2.5");

libfuse/lib/fuse_session.c

@@ -8,8 +8,6 @@
 
 #include "fuse_i.h"
 #include "fuse_misc.h"
-#include "fuse_common_compat.h"
-#include "fuse_lowlevel_compat.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -17,224 +15,203 @@
 #include <assert.h>
 #include <errno.h>
 
-struct fuse_chan {
-	struct fuse_chan_ops op;
-
-	struct fuse_session *se;
-
-	int fd;
-
-	size_t bufsize;
-
-	void *data;
-
-	int compat;
+struct fuse_chan
+{
+  struct fuse_chan_ops op;
+  struct fuse_session *se;
+  int fd;
+  size_t bufsize;
+  void *data;
 };
 
 struct fuse_session *fuse_session_new(struct fuse_session_ops *op, void *data)
 {
-	struct fuse_session *se = (struct fuse_session *) malloc(sizeof(*se));
-	if (se == NULL) {
-		fprintf(stderr, "fuse: failed to allocate session\n");
-		return NULL;
-	}
+  struct fuse_session *se = (struct fuse_session *) malloc(sizeof(*se));
+  if (se == NULL) {
+    fprintf(stderr, "fuse: failed to allocate session\n");
+    return NULL;
+  }
 
-	memset(se, 0, sizeof(*se));
-	se->op = *op;
-	se->data = data;
+  memset(se, 0, sizeof(*se));
+  se->op = *op;
+  se->data = data;
 
-	return se;
+  return se;
 }
 
 void fuse_session_add_chan(struct fuse_session *se, struct fuse_chan *ch)
 {
-	assert(se->ch == NULL);
-	assert(ch->se == NULL);
-	se->ch = ch;
-	ch->se = se;
+  assert(se->ch == NULL);
+  assert(ch->se == NULL);
+  se->ch = ch;
+  ch->se = se;
 }
 
 void fuse_session_remove_chan(struct fuse_chan *ch)
 {
-	struct fuse_session *se = ch->se;
-	if (se) {
-		assert(se->ch == ch);
-		se->ch = NULL;
-		ch->se = NULL;
-	}
+  struct fuse_session *se = ch->se;
+  if (se) {
+    assert(se->ch == ch);
+    se->ch = NULL;
+    ch->se = NULL;
+  }
 }
 
 struct fuse_chan *fuse_session_next_chan(struct fuse_session *se,
 					 struct fuse_chan *ch)
 {
-	assert(ch == NULL || ch == se->ch);
-	if (ch == NULL)
-		return se->ch;
-	else
-		return NULL;
+  assert(ch == NULL || ch == se->ch);
+  if (ch == NULL)
+    return se->ch;
+  else
+    return NULL;
 }
 
 void fuse_session_process(struct fuse_session *se, const char *buf, size_t len,
 			  struct fuse_chan *ch)
 {
-	se->op.process(se->data, buf, len, ch);
+  se->op.process(se->data, buf, len, ch);
 }
 
 void fuse_session_process_buf(struct fuse_session *se,
 			      const struct fuse_buf *buf, struct fuse_chan *ch)
 {
-	if (se->process_buf) {
-		se->process_buf(se->data, buf, ch);
-	} else {
-		assert(!(buf->flags & FUSE_BUF_IS_FD));
-		fuse_session_process(se->data, buf->mem, buf->size, ch);
-	}
+  if (se->process_buf) {
+    se->process_buf(se->data, buf, ch);
+  } else {
+    assert(!(buf->flags & FUSE_BUF_IS_FD));
+    fuse_session_process(se->data, buf->mem, buf->size, ch);
+  }
 }
 
 int fuse_session_receive_buf(struct fuse_session *se, struct fuse_buf *buf,
 			     struct fuse_chan **chp)
 {
-	int res;
+  int res;
 
-	if (se->receive_buf) {
-		res = se->receive_buf(se, buf, chp);
-	} else {
-		res = fuse_chan_recv(chp, buf->mem, buf->size);
-		if (res > 0)
-			buf->size = res;
-	}
+  if (se->receive_buf) {
+    res = se->receive_buf(se, buf, chp);
+  } else {
+    res = fuse_chan_recv(chp, buf->mem, buf->size);
+    if (res > 0)
+      buf->size = res;
+  }
 
-	return res;
+  return res;
 }
 
 
 void fuse_session_destroy(struct fuse_session *se)
 {
-	if (se->op.destroy)
-		se->op.destroy(se->data);
-	if (se->ch != NULL)
-		fuse_chan_destroy(se->ch);
-	free(se);
+  if (se->op.destroy)
+    se->op.destroy(se->data);
+  if (se->ch != NULL)
+    fuse_chan_destroy(se->ch);
+  free(se);
 }
 
 void fuse_session_exit(struct fuse_session *se)
 {
-	if (se->op.exit)
-		se->op.exit(se->data, 1);
-	se->exited = 1;
+  if (se->op.exit)
+    se->op.exit(se->data, 1);
+  se->exited = 1;
 }
 
 void fuse_session_reset(struct fuse_session *se)
 {
-	if (se->op.exit)
-		se->op.exit(se->data, 0);
-	se->exited = 0;
+  if (se->op.exit)
+    se->op.exit(se->data, 0);
+  se->exited = 0;
 }
 
 int fuse_session_exited(struct fuse_session *se)
 {
-	if (se->op.exited)
-		return se->op.exited(se->data);
-	else
-		return se->exited;
+  if (se->op.exited)
+    return se->op.exited(se->data);
+  else
+    return se->exited;
 }
 
 void *fuse_session_data(struct fuse_session *se)
 {
-	return se->data;
+  return se->data;
 }
 
 static struct fuse_chan *fuse_chan_new_common(struct fuse_chan_ops *op, int fd,
-					      size_t bufsize, void *data,
-					      int compat)
+					      size_t bufsize, void *data)
 {
-	struct fuse_chan *ch = (struct fuse_chan *) malloc(sizeof(*ch));
-	if (ch == NULL) {
-		fprintf(stderr, "fuse: failed to allocate channel\n");
-		return NULL;
-	}
+  struct fuse_chan *ch = (struct fuse_chan *) malloc(sizeof(*ch));
+  if (ch == NULL) {
+    fprintf(stderr, "fuse: failed to allocate channel\n");
+    return NULL;
+  }
 
-	memset(ch, 0, sizeof(*ch));
-	ch->op = *op;
-	ch->fd = fd;
-	ch->bufsize = bufsize;
-	ch->data = data;
-	ch->compat = compat;
+  memset(ch, 0, sizeof(*ch));
+  ch->op = *op;
+  ch->fd = fd;
+  ch->bufsize = bufsize;
+  ch->data = data;
 
-	return ch;
+  return ch;
 }
 
 struct fuse_chan *fuse_chan_new(struct fuse_chan_ops *op, int fd,
 				size_t bufsize, void *data)
 {
-	return fuse_chan_new_common(op, fd, bufsize, data, 0);
-}
-
-struct fuse_chan *fuse_chan_new_compat24(struct fuse_chan_ops_compat24 *op,
-					 int fd, size_t bufsize, void *data)
-{
-	return fuse_chan_new_common((struct fuse_chan_ops *) op, fd, bufsize,
-				    data, 24);
+  return fuse_chan_new_common(op, fd, bufsize, data);
 }
 
 int fuse_chan_fd(struct fuse_chan *ch)
 {
-	return ch->fd;
+  return ch->fd;
 }
 
 int fuse_chan_clearfd(struct fuse_chan *ch)
 {
-       int fd = ch->fd;
-       ch->fd = -1;
-       return fd;
+  int fd = ch->fd;
+  ch->fd = -1;
+  return fd;
 }
 
 size_t fuse_chan_bufsize(struct fuse_chan *ch)
 {
-	return ch->bufsize;
+  return ch->bufsize;
 }
 
 void *fuse_chan_data(struct fuse_chan *ch)
 {
-	return ch->data;
+  return ch->data;
 }
 
 struct fuse_session *fuse_chan_session(struct fuse_chan *ch)
 {
-	return ch->se;
+  return ch->se;
 }
 
 int fuse_chan_recv(struct fuse_chan **chp, char *buf, size_t size)
 {
-	struct fuse_chan *ch = *chp;
-	if (ch->compat)
-		return ((struct fuse_chan_ops_compat24 *) &ch->op)
-			->receive(ch, buf, size);
-	else
-		return ch->op.receive(chp, buf, size);
+  struct fuse_chan *ch = *chp;
+
+  return ch->op.receive(chp, buf, size);
 }
 
 int fuse_chan_receive(struct fuse_chan *ch, char *buf, size_t size)
 {
-	int res;
+  int res;
 
-	res = fuse_chan_recv(&ch, buf, size);
-	return res >= 0 ? res : (res != -EINTR && res != -EAGAIN) ? -1 : 0;
+  res = fuse_chan_recv(&ch, buf, size);
+  return res >= 0 ? res : (res != -EINTR && res != -EAGAIN) ? -1 : 0;
 }
 
 int fuse_chan_send(struct fuse_chan *ch, const struct iovec iov[], size_t count)
 {
-	return ch->op.send(ch, iov, count);
+  return ch->op.send(ch, iov, count);
 }
 
 void fuse_chan_destroy(struct fuse_chan *ch)
 {
-	fuse_session_remove_chan(ch);
-	if (ch->op.destroy)
-		ch->op.destroy(ch);
-	free(ch);
+  fuse_session_remove_chan(ch);
+  if (ch->op.destroy)
+    ch->op.destroy(ch);
+  free(ch);
 }
-
-#ifndef __FreeBSD__
-FUSE_SYMVER(".symver fuse_chan_new_compat24,fuse_chan_new@FUSE_2.4");
-#endif

libfuse/lib/fuse_signals.c

@@ -16,57 +16,56 @@ static struct fuse_session *fuse_instance;
 
 static void exit_handler(int sig)
 {
-	(void) sig;
-	if (fuse_instance)
-		fuse_session_exit(fuse_instance);
+  (void) sig;
+  if (fuse_instance)
+    fuse_session_exit(fuse_instance);
 }
 
 static int set_one_signal_handler(int sig, void (*handler)(int), int remove)
 {
-	struct sigaction sa;
-	struct sigaction old_sa;
+  struct sigaction sa;
+  struct sigaction old_sa;
 
-	memset(&sa, 0, sizeof(struct sigaction));
-	sa.sa_handler = remove ? SIG_DFL : handler;
-	sigemptyset(&(sa.sa_mask));
-	sa.sa_flags = 0;
+  memset(&sa, 0, sizeof(struct sigaction));
+  sa.sa_handler = remove ? SIG_DFL : handler;
+  sigemptyset(&(sa.sa_mask));
+  sa.sa_flags = 0;
 
-	if (sigaction(sig, NULL, &old_sa) == -1) {
-		perror("fuse: cannot get old signal handler");
-		return -1;
-	}
+  if (sigaction(sig, NULL, &old_sa) == -1) {
+    perror("fuse: cannot get old signal handler");
+    return -1;
+  }
 
-	if (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&
-	    sigaction(sig, &sa, NULL) == -1) {
-		perror("fuse: cannot set signal handler");
-		return -1;
-	}
-	return 0;
+  if (old_sa.sa_handler == (remove ? handler : SIG_DFL) &&
+      sigaction(sig, &sa, NULL) == -1) {
+    perror("fuse: cannot set signal handler");
+    return -1;
+  }
+  return 0;
 }
 
 int fuse_set_signal_handlers(struct fuse_session *se)
 {
-	if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
-	    set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
-	    set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
-	    set_one_signal_handler(SIGPIPE, SIG_IGN, 0) == -1)
-		return -1;
+  if (set_one_signal_handler(SIGHUP, exit_handler, 0) == -1 ||
+      set_one_signal_handler(SIGINT, exit_handler, 0) == -1 ||
+      set_one_signal_handler(SIGTERM, exit_handler, 0) == -1 ||
+      set_one_signal_handler(SIGPIPE, SIG_IGN, 0) == -1)
+    return -1;
 
-	fuse_instance = se;
-	return 0;
+  fuse_instance = se;
+  return 0;
 }
 
 void fuse_remove_signal_handlers(struct fuse_session *se)
 {
-	if (fuse_instance != se)
-		fprintf(stderr,
-			"fuse: fuse_remove_signal_handlers: unknown session\n");
-	else
-		fuse_instance = NULL;
+  if (fuse_instance != se)
+    fprintf(stderr,
+            "fuse: fuse_remove_signal_handlers: unknown session\n");
+  else
+    fuse_instance = NULL;
 
-	set_one_signal_handler(SIGHUP, exit_handler, 1);
-	set_one_signal_handler(SIGINT, exit_handler, 1);
-	set_one_signal_handler(SIGTERM, exit_handler, 1);
-	set_one_signal_handler(SIGPIPE, SIG_IGN, 1);
+  set_one_signal_handler(SIGHUP, exit_handler, 1);
+  set_one_signal_handler(SIGINT, exit_handler, 1);
+  set_one_signal_handler(SIGTERM, exit_handler, 1);
+  set_one_signal_handler(SIGPIPE, SIG_IGN, 1);
 }
-

libfuse/lib/fuse_versionscript

@@ -1,207 +0,0 @@
-FUSE_2.2 {
-	global:
-		fuse_destroy;
-		fuse_exit;
-		fuse_exited;
-		fuse_invalidate;
-		fuse_is_lib_option;
-		fuse_loop;
-		fuse_loop_mt;
-		fuse_loop_mt_proc;
-		fuse_main;
-		fuse_main_compat1;
-		fuse_main_compat2;
-		fuse_mount_compat1;
-		fuse_new_compat1;
-		fuse_new_compat2;
-		fuse_process_cmd;
-		fuse_read_cmd;
-		fuse_set_getcontext_func;
-		fuse_setup_compat2;
-};
-
-FUSE_2.4 {
-	global:
-		fuse_add_dirent;
-		fuse_chan_bufsize;
-		fuse_chan_data;
-		fuse_chan_destroy;
-		fuse_chan_fd;
-		fuse_chan_receive;
-		fuse_chan_send;
-		fuse_chan_session;
-		fuse_dirent_size;
-		fuse_kern_chan_new;
-		fuse_lowlevel_is_lib_option;
-		fuse_reply_attr;
-		fuse_reply_buf;
-		fuse_reply_entry;
-		fuse_reply_err;
-		fuse_reply_none;
-		fuse_reply_readlink;
-		fuse_reply_write;
-		fuse_reply_xattr;
-		fuse_req_userdata;
-		fuse_session_add_chan;
-		fuse_session_destroy;
-		fuse_session_exit;
-		fuse_session_exited;
-		fuse_session_loop;
-		fuse_session_loop_mt;
-		fuse_session_new;
-		fuse_session_next_chan;
-		fuse_session_process;
-		fuse_session_reset;
-} FUSE_2.2;
-
-FUSE_2.5 {
-	global:
-		fuse_lowlevel_new_compat;
-		fuse_main_real_compat22;
-		fuse_mount_compat22;
-		fuse_new_compat22;
-		fuse_opt_parse;
-		fuse_opt_add_opt;
-		fuse_opt_add_arg;
-		fuse_opt_free_args;
-		fuse_opt_match;
-		fuse_parse_cmdline;
-		fuse_remove_signal_handlers;
-		fuse_reply_create;
-		fuse_reply_open;
-		fuse_reply_open_compat;
-		fuse_reply_statfs;
-		fuse_reply_statfs_compat;
-		fuse_setup_compat22;
-		fuse_set_signal_handlers;
-} FUSE_2.4;
-
-FUSE_2.6 {
-	global:
-		fuse_add_direntry;
-		fuse_chan_new;
-		fuse_chan_new_compat24;
-		fuse_chan_recv;
-		fuse_daemonize;
-		fuse_get_session;
-		fuse_interrupted;
-		fuse_lowlevel_new;
-		fuse_lowlevel_new_compat25;
-		fuse_main_real;
-		fuse_main_real_compat25;
-		fuse_mount;
-		fuse_mount_compat25;
-		fuse_new;
-		fuse_new_compat25;
-		fuse_opt_insert_arg;
-		fuse_reply_lock;
-		fuse_req_interrupt_func;
-		fuse_req_interrupted;
-		fuse_session_remove_chan;
-		fuse_setup;
-		fuse_setup_compat25;
-		fuse_teardown;
-		fuse_teardown_compat22;
-		fuse_unmount;
-		fuse_unmount_compat22;
-} FUSE_2.5;
-
-FUSE_2.7 {
-	global:
-		fuse_fs_access;
-		fuse_fs_bmap;
-		fuse_fs_chmod;
-		fuse_fs_chown;
-		fuse_fs_create;
-		fuse_fs_destroy;
-		fuse_fs_fgetattr;
-		fuse_fs_flush;
-		fuse_fs_fsync;
-		fuse_fs_fsyncdir;
-		fuse_fs_ftruncate;
-		fuse_fs_getattr;
-		fuse_fs_getxattr;
-		fuse_fs_init;
-		fuse_fs_link;
-		fuse_fs_listxattr;
-		fuse_fs_lock;
-		fuse_fs_mkdir;
-		fuse_fs_mknod;
-		fuse_fs_new;
-		fuse_fs_open;
-		fuse_fs_opendir;
-		fuse_fs_read;
-		fuse_fs_readdir;
-		fuse_fs_readlink;
-		fuse_fs_release;
-		fuse_fs_releasedir;
-		fuse_fs_removexattr;
-		fuse_fs_rename;
-		fuse_fs_rmdir;
-		fuse_fs_setxattr;
-		fuse_fs_statfs;
-		fuse_fs_symlink;
-		fuse_fs_truncate;
-		fuse_fs_unlink;
-		fuse_fs_utimens;
-		fuse_fs_write;
-		fuse_register_module;
-		fuse_reply_iov;
-		fuse_version;
-} FUSE_2.6;
-
-FUSE_2.7.5 {
-	global:
-		fuse_reply_bmap;
-} FUSE_2.7;
-
-FUSE_2.8 {
-	global:
-		cuse_lowlevel_new;
-		cuse_lowlevel_main;
-		cuse_lowlevel_setup;
-		cuse_lowlevel_teardown;
-		fuse_fs_ioctl;
-		fuse_fs_poll;
-		fuse_get_context;
-		fuse_getgroups;
-		fuse_lowlevel_notify_inval_entry;
-		fuse_lowlevel_notify_inval_inode;
-		fuse_lowlevel_notify_poll;
-		fuse_notify_poll;
-		fuse_opt_add_opt_escaped;
-		fuse_pollhandle_destroy;
-		fuse_reply_ioctl;
-		fuse_reply_ioctl_iov;
-		fuse_reply_ioctl_retry;
-		fuse_reply_poll;
-		fuse_req_ctx;
-		fuse_req_getgroups;
-		fuse_session_data;
-} FUSE_2.7.5;
-
-FUSE_2.9 {
-	global:
-		fuse_buf_copy;
-		fuse_buf_size;
-		fuse_fs_read_buf;
-		fuse_fs_write_buf;
-		fuse_lowlevel_notify_retrieve;
-		fuse_lowlevel_notify_store;
-		fuse_reply_data;
-		fuse_session_process_buf;
-		fuse_session_receive_buf;
-		fuse_start_cleanup_thread;
-		fuse_stop_cleanup_thread;
-		fuse_clean_cache;
-		fuse_lowlevel_notify_delete;
-		fuse_fs_flock;
-} FUSE_2.8;
-
-FUSE_2.9.1 {
-	global:
-		fuse_fs_fallocate;
-
-	local:
-		*;
-} FUSE_2.9;

libfuse/lib/helper.c

@@ -11,7 +11,6 @@
 #include "fuse_misc.h"
 #include "fuse_opt.h"
 #include "fuse_lowlevel.h"
-#include "fuse_common_compat.h"
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -23,472 +22,381 @@
 #include <sys/param.h>
 
 enum  {
-	KEY_HELP,
-	KEY_HELP_NOHEADER,
-	KEY_VERSION,
+  KEY_HELP,
+  KEY_HELP_NOHEADER,
+  KEY_VERSION,
 };
 
-struct helper_opts {
-	int singlethread;
-	int foreground;
-	int nodefault_subtype;
-	char *mountpoint;
+struct helper_opts
+{
+  int foreground;
+  int nodefault_subtype;
+  char *mountpoint;
 };
 
 #define FUSE_HELPER_OPT(t, p) { t, offsetof(struct helper_opts, p), 1 }
 
-static const struct fuse_opt fuse_helper_opts[] = {
-	FUSE_HELPER_OPT("-d",		foreground),
-	FUSE_HELPER_OPT("debug",	foreground),
-	FUSE_HELPER_OPT("-f",		foreground),
-	FUSE_HELPER_OPT("-s",		singlethread),
-	FUSE_HELPER_OPT("fsname=",	nodefault_subtype),
-	FUSE_HELPER_OPT("subtype=",	nodefault_subtype),
-
-	FUSE_OPT_KEY("-h",		KEY_HELP),
-	FUSE_OPT_KEY("--help",		KEY_HELP),
-	FUSE_OPT_KEY("-ho",		KEY_HELP_NOHEADER),
-	FUSE_OPT_KEY("-V",		KEY_VERSION),
-	FUSE_OPT_KEY("--version",	KEY_VERSION),
-	FUSE_OPT_KEY("-d",		FUSE_OPT_KEY_KEEP),
-	FUSE_OPT_KEY("debug",		FUSE_OPT_KEY_KEEP),
-	FUSE_OPT_KEY("fsname=",		FUSE_OPT_KEY_KEEP),
-	FUSE_OPT_KEY("subtype=",	FUSE_OPT_KEY_KEEP),
-	FUSE_OPT_END
-};
+static
+const
+struct fuse_opt fuse_helper_opts[] =
+  {
+    FUSE_HELPER_OPT("-d",	foreground),
+    FUSE_HELPER_OPT("debug",	foreground),
+    FUSE_HELPER_OPT("-f",	foreground),
+    FUSE_HELPER_OPT("fsname=",	nodefault_subtype),
+    FUSE_HELPER_OPT("subtype=",	nodefault_subtype),
+    FUSE_OPT_KEY("-h",		KEY_HELP),
+    FUSE_OPT_KEY("--help",	KEY_HELP),
+    FUSE_OPT_KEY("-ho",		KEY_HELP_NOHEADER),
+    FUSE_OPT_KEY("-V",		KEY_VERSION),
+    FUSE_OPT_KEY("--version",	KEY_VERSION),
+    FUSE_OPT_KEY("-d",		FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_KEY("debug",	FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_KEY("fsname=",	FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_KEY("subtype=",	FUSE_OPT_KEY_KEEP),
+    FUSE_OPT_END
+  };
 
 static void usage(const char *progname)
 {
-	fprintf(stderr,
-		"usage: %s mountpoint [options]\n\n", progname);
-	fprintf(stderr,
-		"general options:\n"
-		"    -o opt,[opt...]        mount options\n"
-		"    -h   --help            print help\n"
-		"    -V   --version         print version\n"
-		"\n");
+  fprintf(stderr,
+          "usage: %s mountpoint [options]\n\n", progname);
+  fprintf(stderr,
+          "general options:\n"
+          "    -o opt,[opt...]        mount options\n"
+          "    -h   --help            print help\n"
+          "    -V   --version         print version\n"
+          "\n");
 }
 
 static void helper_help(void)
 {
-	fprintf(stderr,
-		"FUSE options:\n"
-		"    -d   -o debug          enable debug output (implies -f)\n"
-		"    -f                     foreground operation\n"
-		"    -s                     disable multi-threaded operation\n"
-		"\n"
-		);
+  fprintf(stderr,
+          "FUSE options:\n"
+          "    -d   -o debug          enable debug output (implies -f)\n"
+          "    -f                     foreground operation\n"
+          "\n"
+          );
 }
 
 static void helper_version(void)
 {
-	fprintf(stderr, "FUSE library version: %s\n", PACKAGE_VERSION);
+  fprintf(stderr, "FUSE library version: %s\n", PACKAGE_VERSION);
 }
 
 static int fuse_helper_opt_proc(void *data, const char *arg, int key,
 				struct fuse_args *outargs)
 {
-	struct helper_opts *hopts = data;
+  struct helper_opts *hopts = data;
 
-	switch (key) {
-	case KEY_HELP:
-		usage(outargs->argv[0]);
-		/* fall through */
+  switch (key) {
+  case KEY_HELP:
+    usage(outargs->argv[0]);
+    /* fall through */
 
-	case KEY_HELP_NOHEADER:
-		helper_help();
-		return fuse_opt_add_arg(outargs, "-h");
+  case KEY_HELP_NOHEADER:
+    helper_help();
+    return fuse_opt_add_arg(outargs, "-h");
 
-	case KEY_VERSION:
-		helper_version();
-		return 1;
+  case KEY_VERSION:
+    helper_version();
+    return 1;
 
-	case FUSE_OPT_KEY_NONOPT:
-		if (!hopts->mountpoint) {
-			char mountpoint[PATH_MAX];
-			if (realpath(arg, mountpoint) == NULL) {
-				fprintf(stderr,
-					"fuse: bad mount point `%s': %s\n",
-					arg, strerror(errno));
-				return -1;
-			}
-			return fuse_opt_add_opt(&hopts->mountpoint, mountpoint);
-		} else {
-			fprintf(stderr, "fuse: invalid argument `%s'\n", arg);
-			return -1;
-		}
+  case FUSE_OPT_KEY_NONOPT:
+    if (!hopts->mountpoint) {
+      char mountpoint[PATH_MAX];
+      if (realpath(arg, mountpoint) == NULL) {
+        fprintf(stderr,
+                "fuse: bad mount point `%s': %s\n",
+                arg, strerror(errno));
+        return -1;
+      }
+      return fuse_opt_add_opt(&hopts->mountpoint, mountpoint);
+    } else {
+      fprintf(stderr, "fuse: invalid argument `%s'\n", arg);
+      return -1;
+    }
 
-	default:
-		return 1;
-	}
+  default:
+    return 1;
+  }
 }
 
 static int add_default_subtype(const char *progname, struct fuse_args *args)
 {
-	int res;
-	char *subtype_opt;
-	const char *basename = strrchr(progname, '/');
-	if (basename == NULL)
-		basename = progname;
-	else if (basename[1] != '\0')
-		basename++;
+  int res;
+  char *subtype_opt;
+  const char *basename = strrchr(progname, '/');
+  if (basename == NULL)
+    basename = progname;
+  else if (basename[1] != '\0')
+    basename++;
 
-	subtype_opt = (char *) malloc(strlen(basename) + 64);
-	if (subtype_opt == NULL) {
-		fprintf(stderr, "fuse: memory allocation failed\n");
-		return -1;
-	}
-	sprintf(subtype_opt, "-osubtype=%s", basename);
-	res = fuse_opt_add_arg(args, subtype_opt);
-	free(subtype_opt);
-	return res;
+  subtype_opt = (char *) malloc(strlen(basename) + 64);
+  if (subtype_opt == NULL) {
+    fprintf(stderr, "fuse: memory allocation failed\n");
+    return -1;
+  }
+  sprintf(subtype_opt, "-osubtype=%s", basename);
+  res = fuse_opt_add_arg(args, subtype_opt);
+  free(subtype_opt);
+  return res;
 }
 
-int fuse_parse_cmdline(struct fuse_args *args, char **mountpoint,
-		       int *multithreaded, int *foreground)
+int
+fuse_parse_cmdline(struct fuse_args  *args_,
+                   char             **mountpoint_,
+                   int               *foreground_)
 {
-	int res;
-	struct helper_opts hopts;
+  int res;
+  struct helper_opts hopts;
 
-	memset(&hopts, 0, sizeof(hopts));
-	res = fuse_opt_parse(args, &hopts, fuse_helper_opts,
-			     fuse_helper_opt_proc);
-	if (res == -1)
-		return -1;
+  memset(&hopts, 0, sizeof(hopts));
 
-	if (!hopts.nodefault_subtype) {
-		res = add_default_subtype(args->argv[0], args);
-		if (res == -1)
-			goto err;
-	}
-	if (mountpoint)
-		*mountpoint = hopts.mountpoint;
-	else
-		free(hopts.mountpoint);
+  res = fuse_opt_parse(args_,
+                       &hopts,
+                       fuse_helper_opts,
+                       fuse_helper_opt_proc);
+  if(res == -1)
+    return -1;
 
-	if (multithreaded)
-		*multithreaded = !hopts.singlethread;
-	if (foreground)
-		*foreground = hopts.foreground;
-	return 0;
+  if(!hopts.nodefault_subtype)
+    {
+      res = add_default_subtype(args_->argv[0], args_);
+      if(res == -1)
+        goto err;
+    }
 
-err:
-	free(hopts.mountpoint);
-	return -1;
+  if(mountpoint_)
+    *mountpoint_ = hopts.mountpoint;
+  else
+    free(hopts.mountpoint);
+
+  if(foreground_)
+    *foreground_ = hopts.foreground;
+
+  return 0;
+
+ err:
+  free(hopts.mountpoint);
+  return -1;
 }
 
 int fuse_daemonize(int foreground)
 {
-	if (!foreground) {
-		int nullfd;
-		int waiter[2];
-		char completed;
+  if (!foreground) {
+    int nullfd;
+    int waiter[2];
+    char completed;
 
-		if (pipe(waiter)) {
-			perror("fuse_daemonize: pipe");
-			return -1;
-		}
+    if (pipe(waiter)) {
+      perror("fuse_daemonize: pipe");
+      return -1;
+    }
 
-		/*
-		 * demonize current process by forking it and killing the
-		 * parent.  This makes current process as a child of 'init'.
-		 */
-		switch(fork()) {
-		case -1:
-			perror("fuse_daemonize: fork");
-			return -1;
-		case 0:
-			break;
-		default:
-			read(waiter[0], &completed, sizeof(completed));
-			_exit(0);
-		}
+    /*
+     * demonize current process by forking it and killing the
+     * parent.  This makes current process as a child of 'init'.
+     */
+    switch(fork()) {
+    case -1:
+      perror("fuse_daemonize: fork");
+      return -1;
+    case 0:
+      break;
+    default:
+      read(waiter[0], &completed, sizeof(completed));
+      _exit(0);
+    }
 
-		if (setsid() == -1) {
-			perror("fuse_daemonize: setsid");
-			return -1;
-		}
+    if (setsid() == -1) {
+      perror("fuse_daemonize: setsid");
+      return -1;
+    }
 
-		(void) chdir("/");
+    (void) chdir("/");
 
-		nullfd = open("/dev/null", O_RDWR, 0);
-		if (nullfd != -1) {
-			(void) dup2(nullfd, 0);
-			(void) dup2(nullfd, 1);
-			(void) dup2(nullfd, 2);
-			if (nullfd > 2)
-				close(nullfd);
-		}
+    nullfd = open("/dev/null", O_RDWR, 0);
+    if (nullfd != -1) {
+      (void) dup2(nullfd, 0);
+      (void) dup2(nullfd, 1);
+      (void) dup2(nullfd, 2);
+      if (nullfd > 2)
+        close(nullfd);
+    }
 
-		/* Propagate completion of daemon initializatation */
-		completed = 1;
-		write(waiter[1], &completed, sizeof(completed));
-		close(waiter[0]);
-		close(waiter[1]);
-	}
-	return 0;
+    /* Propagate completion of daemon initializatation */
+    completed = 1;
+    write(waiter[1], &completed, sizeof(completed));
+    close(waiter[0]);
+    close(waiter[1]);
+  }
+  return 0;
 }
 
-static struct fuse_chan *fuse_mount_common(const char *mountpoint,
-					   struct fuse_args *args)
+static
+struct fuse_chan *
+fuse_mount_common(const char       *mountpoint_,
+                  struct fuse_args *args_)
 {
-	struct fuse_chan *ch;
-	int fd;
+  struct fuse_chan *ch;
+  int fd;
 
-	/*
-	 * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
-	 * would ensue.
-	 */
-	do {
-		fd = open("/dev/null", O_RDWR);
-		if (fd > 2)
-			close(fd);
-	} while (fd >= 0 && fd <= 2);
+  /*
+   * Make sure file descriptors 0, 1 and 2 are open, otherwise chaos
+   * would ensue.
+   */
+  do
+    {
+      fd = open("/dev/null", O_RDWR);
+      if(fd > 2)
+        close(fd);
+    } while(fd >= 0 && fd <= 2);
 
-	fd = fuse_mount_compat25(mountpoint, args);
-	if (fd == -1)
-		return NULL;
+  fd = fuse_kern_mount(mountpoint_,args_);
+  if(fd == -1)
+    return NULL;
 
-	ch = fuse_kern_chan_new(fd);
-	if (!ch)
-		fuse_kern_unmount(mountpoint, fd);
+  ch = fuse_kern_chan_new(fd);
+  if(!ch)
+    fuse_kern_unmount(mountpoint_, fd);
 
-	return ch;
+  return ch;
 }
 
-struct fuse_chan *fuse_mount(const char *mountpoint, struct fuse_args *args)
+struct fuse_chan *
+fuse_mount(const char       *mountpoint_,
+           struct fuse_args *args_)
 {
-	return fuse_mount_common(mountpoint, args);
+  return fuse_mount_common(mountpoint_,args_);
 }
 
 static void fuse_unmount_common(const char *mountpoint, struct fuse_chan *ch)
 {
-	if (mountpoint) {
-		int fd = ch ? fuse_chan_clearfd(ch) : -1;
-		fuse_kern_unmount(mountpoint, fd);
-		if (ch)
-			fuse_chan_destroy(ch);
-	}
+  if (mountpoint) {
+    int fd = ch ? fuse_chan_clearfd(ch) : -1;
+    fuse_kern_unmount(mountpoint, fd);
+    if (ch)
+      fuse_chan_destroy(ch);
+  }
 }
 
 void fuse_unmount(const char *mountpoint, struct fuse_chan *ch)
 {
-	fuse_unmount_common(mountpoint, ch);
+  fuse_unmount_common(mountpoint, ch);
 }
 
 struct fuse *fuse_setup_common(int argc, char *argv[],
 			       const struct fuse_operations *op,
 			       size_t op_size,
 			       char **mountpoint,
-			       int *multithreaded,
 			       int *fd,
-			       void *user_data,
-			       int compat)
+			       void *user_data)
 {
-	struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
-	struct fuse_chan *ch;
-	struct fuse *fuse;
-	int foreground;
-	int res;
+  struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
+  struct fuse_chan *ch;
+  struct fuse *fuse;
+  int foreground;
+  int res;
 
-	res = fuse_parse_cmdline(&args, mountpoint, multithreaded, &foreground);
-	if (res == -1)
-		return NULL;
+  res = fuse_parse_cmdline(&args, mountpoint, &foreground);
+  if (res == -1)
+    return NULL;
 
-	ch = fuse_mount_common(*mountpoint, &args);
-	if (!ch) {
-		fuse_opt_free_args(&args);
-		goto err_free;
-	}
+  ch = fuse_mount_common(*mountpoint, &args);
+  if (!ch) {
+    fuse_opt_free_args(&args);
+    goto err_free;
+  }
 
-	fuse = fuse_new_common(ch, &args, op, op_size, user_data, compat);
-	fuse_opt_free_args(&args);
-	if (fuse == NULL)
-		goto err_unmount;
+  fuse = fuse_new_common(ch, &args, op, op_size, user_data);
+  fuse_opt_free_args(&args);
+  if (fuse == NULL)
+    goto err_unmount;
 
-	res = fuse_daemonize(foreground);
-	if (res == -1)
-		goto err_unmount;
+  res = fuse_daemonize(foreground);
+  if (res == -1)
+    goto err_unmount;
 
-	res = fuse_set_signal_handlers(fuse_get_session(fuse));
-	if (res == -1)
-		goto err_unmount;
+  res = fuse_set_signal_handlers(fuse_get_session(fuse));
+  if (res == -1)
+    goto err_unmount;
 
-	if (fd)
-		*fd = fuse_chan_fd(ch);
+  if (fd)
+    *fd = fuse_chan_fd(ch);
 
-	return fuse;
+  return fuse;
 
-err_unmount:
-	fuse_unmount_common(*mountpoint, ch);
-	if (fuse)
-		fuse_destroy(fuse);
-err_free:
-	free(*mountpoint);
-	return NULL;
+ err_unmount:
+  fuse_unmount_common(*mountpoint, ch);
+  if (fuse)
+    fuse_destroy(fuse);
+ err_free:
+  free(*mountpoint);
+  return NULL;
 }
 
 struct fuse *fuse_setup(int argc, char *argv[],
 			const struct fuse_operations *op, size_t op_size,
-			char **mountpoint, int *multithreaded, void *user_data)
+			char **mountpoint, void *user_data)
 {
-	return fuse_setup_common(argc, argv, op, op_size, mountpoint,
-				 multithreaded, NULL, user_data, 0);
+  return fuse_setup_common(argc, argv, op, op_size, mountpoint,
+                           NULL, user_data);
 }
 
 static void fuse_teardown_common(struct fuse *fuse, char *mountpoint)
 {
-	struct fuse_session *se = fuse_get_session(fuse);
-	struct fuse_chan *ch = fuse_session_next_chan(se, NULL);
-	fuse_remove_signal_handlers(se);
-	fuse_unmount_common(mountpoint, ch);
-	fuse_destroy(fuse);
-	free(mountpoint);
+  struct fuse_session *se = fuse_get_session(fuse);
+  struct fuse_chan *ch = fuse_session_next_chan(se, NULL);
+  fuse_remove_signal_handlers(se);
+  fuse_unmount_common(mountpoint, ch);
+  fuse_destroy(fuse);
+  free(mountpoint);
 }
 
 void fuse_teardown(struct fuse *fuse, char *mountpoint)
 {
-	fuse_teardown_common(fuse, mountpoint);
+  fuse_teardown_common(fuse, mountpoint);
 }
 
 static int fuse_main_common(int argc, char *argv[],
 			    const struct fuse_operations *op, size_t op_size,
-			    void *user_data, int compat)
+			    void *user_data)
 {
-	struct fuse *fuse;
-	char *mountpoint;
-	int multithreaded;
-	int res;
+  struct fuse *fuse;
+  char *mountpoint;
+  int res;
 
-	fuse = fuse_setup_common(argc, argv, op, op_size, &mountpoint,
-				 &multithreaded, NULL, user_data, compat);
-	if (fuse == NULL)
-		return 1;
+  fuse = fuse_setup_common(argc, argv, op, op_size,
+                           &mountpoint,
+                           NULL, user_data);
+  if (fuse == NULL)
+    return 1;
 
-	if (multithreaded)
-		res = fuse_loop_mt(fuse);
-	else
-		res = fuse_loop(fuse);
+  res = fuse_loop_mt(fuse);
 
-	fuse_teardown_common(fuse, mountpoint);
-	if (res == -1)
-		return 1;
+  fuse_teardown_common(fuse, mountpoint);
+  if (res == -1)
+    return 1;
 
-	return 0;
+  return 0;
 }
 
 int fuse_main_real(int argc, char *argv[], const struct fuse_operations *op,
 		   size_t op_size, void *user_data)
 {
-	return fuse_main_common(argc, argv, op, op_size, user_data, 0);
+  return fuse_main_common(argc, argv, op, op_size, user_data);
 }
 
 #undef fuse_main
 int fuse_main(void);
 int fuse_main(void)
 {
-	fprintf(stderr, "fuse_main(): This function does not exist\n");
-	return -1;
+  fprintf(stderr, "fuse_main(): This function does not exist\n");
+  return -1;
 }
 
 int fuse_version(void)
 {
-	return FUSE_VERSION;
+  return FUSE_VERSION;
 }
-
-#include "fuse_compat.h"
-
-#if !defined(__FreeBSD__) && !defined(__NetBSD__)
-
-struct fuse *fuse_setup_compat22(int argc, char *argv[],
-				 const struct fuse_operations_compat22 *op,
-				 size_t op_size, char **mountpoint,
-				 int *multithreaded, int *fd)
-{
-	return fuse_setup_common(argc, argv, (struct fuse_operations *) op,
-				 op_size, mountpoint, multithreaded, fd, NULL,
-				 22);
-}
-
-struct fuse *fuse_setup_compat2(int argc, char *argv[],
-				const struct fuse_operations_compat2 *op,
-				char **mountpoint, int *multithreaded,
-				int *fd)
-{
-	return fuse_setup_common(argc, argv, (struct fuse_operations *) op,
-				 sizeof(struct fuse_operations_compat2),
-				 mountpoint, multithreaded, fd, NULL, 21);
-}
-
-int fuse_main_real_compat22(int argc, char *argv[],
-			    const struct fuse_operations_compat22 *op,
-			    size_t op_size)
-{
-	return fuse_main_common(argc, argv, (struct fuse_operations *) op,
-				op_size, NULL, 22);
-}
-
-void fuse_main_compat1(int argc, char *argv[],
-		       const struct fuse_operations_compat1 *op)
-{
-	fuse_main_common(argc, argv, (struct fuse_operations *) op,
-			 sizeof(struct fuse_operations_compat1), NULL, 11);
-}
-
-int fuse_main_compat2(int argc, char *argv[],
-		      const struct fuse_operations_compat2 *op)
-{
-	return fuse_main_common(argc, argv, (struct fuse_operations *) op,
-				sizeof(struct fuse_operations_compat2), NULL,
-				21);
-}
-
-int fuse_mount_compat1(const char *mountpoint, const char *args[])
-{
-	/* just ignore mount args for now */
-	(void) args;
-	return fuse_mount_compat22(mountpoint, NULL);
-}
-
-FUSE_SYMVER(".symver fuse_setup_compat2,__fuse_setup@");
-FUSE_SYMVER(".symver fuse_setup_compat22,fuse_setup@FUSE_2.2");
-FUSE_SYMVER(".symver fuse_teardown,__fuse_teardown@");
-FUSE_SYMVER(".symver fuse_main_compat2,fuse_main@");
-FUSE_SYMVER(".symver fuse_main_real_compat22,fuse_main_real@FUSE_2.2");
-
-#endif /* __FreeBSD__ || __NetBSD__ */
-
-
-struct fuse *fuse_setup_compat25(int argc, char *argv[],
-				 const struct fuse_operations_compat25 *op,
-				 size_t op_size, char **mountpoint,
-				 int *multithreaded, int *fd)
-{
-	return fuse_setup_common(argc, argv, (struct fuse_operations *) op,
-				 op_size, mountpoint, multithreaded, fd, NULL,
-				 25);
-}
-
-int fuse_main_real_compat25(int argc, char *argv[],
-			    const struct fuse_operations_compat25 *op,
-			    size_t op_size)
-{
-	return fuse_main_common(argc, argv, (struct fuse_operations *) op,
-				op_size, NULL, 25);
-}
-
-void fuse_teardown_compat22(struct fuse *fuse, int fd, char *mountpoint)
-{
-	(void) fd;
-	fuse_teardown_common(fuse, mountpoint);
-}
-
-int fuse_mount_compat25(const char *mountpoint, struct fuse_args *args)
-{
-	return fuse_kern_mount(mountpoint, args);
-}
-
-FUSE_SYMVER(".symver fuse_setup_compat25,fuse_setup@FUSE_2.5");
-FUSE_SYMVER(".symver fuse_teardown_compat22,fuse_teardown@FUSE_2.2");
-FUSE_SYMVER(".symver fuse_main_real_compat25,fuse_main_real@FUSE_2.5");
-FUSE_SYMVER(".symver fuse_mount_compat25,fuse_mount@FUSE_2.5");

libfuse/lib/mount_bsd.c

@@ -28,364 +28,315 @@
 #define FUSE_DEV_TRUNK		"/dev/fuse"
 
 enum {
-	KEY_ALLOW_ROOT,
-	KEY_RO,
-	KEY_HELP,
-	KEY_VERSION,
-	KEY_KERN
+  KEY_ALLOW_ROOT,
+  KEY_RO,
+  KEY_HELP,
+  KEY_VERSION,
+  KEY_KERN
 };
 
 struct mount_opts {
-	int allow_other;
-	int allow_root;
-	int ishelp;
-	char *kernel_opts;
+  int allow_other;
+  int allow_root;
+  int ishelp;
+  char *kernel_opts;
 };
 
 #define FUSE_DUAL_OPT_KEY(templ, key) 				\
-	FUSE_OPT_KEY(templ, key), FUSE_OPT_KEY("no" templ, key)
+  FUSE_OPT_KEY(templ, key), FUSE_OPT_KEY("no" templ, key)
 
 static const struct fuse_opt fuse_mount_opts[] = {
-	{ "allow_other", offsetof(struct mount_opts, allow_other), 1 },
-	{ "allow_root", offsetof(struct mount_opts, allow_root), 1 },
-	FUSE_OPT_KEY("allow_root",		KEY_ALLOW_ROOT),
-	FUSE_OPT_KEY("-r",			KEY_RO),
-	FUSE_OPT_KEY("-h",			KEY_HELP),
-	FUSE_OPT_KEY("--help",			KEY_HELP),
-	FUSE_OPT_KEY("-V",			KEY_VERSION),
-	FUSE_OPT_KEY("--version",		KEY_VERSION),
-	/* standard FreeBSD mount options */
-	FUSE_DUAL_OPT_KEY("dev",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("async",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("atime",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("dev",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("exec",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("suid",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("symfollow",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("rdonly",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("sync",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("union",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("userquota",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("groupquota",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("clusterr",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("clusterw",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("suiddir",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("snapshot",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("multilabel",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("acls",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("force",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("update",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("ro",			KEY_KERN),
-	FUSE_DUAL_OPT_KEY("rw",			KEY_KERN),
-	FUSE_DUAL_OPT_KEY("auto",		KEY_KERN),
-	/* options supported under both Linux and FBSD */
-	FUSE_DUAL_OPT_KEY("allow_other",	KEY_KERN),
-	FUSE_DUAL_OPT_KEY("default_permissions",KEY_KERN),
-	FUSE_OPT_KEY("max_read=",		KEY_KERN),
-	FUSE_OPT_KEY("subtype=",		KEY_KERN),
-	/* FBSD FUSE specific mount options */
-	FUSE_DUAL_OPT_KEY("private",		KEY_KERN),
-	FUSE_DUAL_OPT_KEY("neglect_shares",	KEY_KERN),
-	FUSE_DUAL_OPT_KEY("push_symlinks_in",	KEY_KERN),
-	FUSE_OPT_KEY("nosync_unmount",		KEY_KERN),
-	/* stock FBSD mountopt parsing routine lets anything be negated... */
-	/*
-	 * Linux specific mount options, but let just the mount util
-	 * handle them
-	 */
-	FUSE_OPT_KEY("fsname=",			KEY_KERN),
-	FUSE_OPT_KEY("nonempty",		KEY_KERN),
-	FUSE_OPT_KEY("large_read",		KEY_KERN),
-	FUSE_OPT_END
+  { "allow_other", offsetof(struct mount_opts, allow_other), 1 },
+  { "allow_root", offsetof(struct mount_opts, allow_root), 1 },
+  FUSE_OPT_KEY("allow_root",		KEY_ALLOW_ROOT),
+  FUSE_OPT_KEY("-r",			KEY_RO),
+  FUSE_OPT_KEY("-h",			KEY_HELP),
+  FUSE_OPT_KEY("--help",			KEY_HELP),
+  FUSE_OPT_KEY("-V",			KEY_VERSION),
+  FUSE_OPT_KEY("--version",		KEY_VERSION),
+  /* standard FreeBSD mount options */
+  FUSE_DUAL_OPT_KEY("dev",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("async",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("atime",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("dev",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("exec",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("suid",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("symfollow",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("rdonly",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("sync",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("union",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("userquota",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("groupquota",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("clusterr",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("clusterw",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("suiddir",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("snapshot",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("multilabel",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("acls",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("force",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("update",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("ro",			KEY_KERN),
+  FUSE_DUAL_OPT_KEY("rw",			KEY_KERN),
+  FUSE_DUAL_OPT_KEY("auto",		KEY_KERN),
+  /* options supported under both Linux and FBSD */
+  FUSE_DUAL_OPT_KEY("allow_other",	KEY_KERN),
+  FUSE_DUAL_OPT_KEY("default_permissions",KEY_KERN),
+  FUSE_OPT_KEY("max_read=",		KEY_KERN),
+  FUSE_OPT_KEY("subtype=",		KEY_KERN),
+  /* FBSD FUSE specific mount options */
+  FUSE_DUAL_OPT_KEY("private",		KEY_KERN),
+  FUSE_DUAL_OPT_KEY("neglect_shares",	KEY_KERN),
+  FUSE_DUAL_OPT_KEY("push_symlinks_in",	KEY_KERN),
+  FUSE_OPT_KEY("nosync_unmount",		KEY_KERN),
+  /* stock FBSD mountopt parsing routine lets anything be negated... */
+  /*
+   * Linux specific mount options, but let just the mount util
+   * handle them
+   */
+  FUSE_OPT_KEY("fsname=",			KEY_KERN),
+  FUSE_OPT_KEY("nonempty",		KEY_KERN),
+  FUSE_OPT_KEY("large_read",		KEY_KERN),
+  FUSE_OPT_END
 };
 
 static void mount_help(void)
 {
-	fprintf(stderr,
-		"    -o allow_root          allow access to root\n"
-		);
-	system(FUSERMOUNT_PROG " --help");
-	fputc('\n', stderr);
+  fprintf(stderr,
+          "    -o allow_root          allow access to root\n"
+          );
+  system(FUSERMOUNT_PROG " --help");
+  fputc('\n', stderr);
 }
 
 static void mount_version(void)
 {
-	system(FUSERMOUNT_PROG " --version");
+  system(FUSERMOUNT_PROG " --version");
 }
 
 static int fuse_mount_opt_proc(void *data, const char *arg, int key,
 			       struct fuse_args *outargs)
 {
-	struct mount_opts *mo = data;
+  struct mount_opts *mo = data;
 
-	switch (key) {
-	case KEY_ALLOW_ROOT:
-		if (fuse_opt_add_opt(&mo->kernel_opts, "allow_other") == -1 ||
-		    fuse_opt_add_arg(outargs, "-oallow_root") == -1)
-			return -1;
-		return 0;
+  switch (key) {
+  case KEY_ALLOW_ROOT:
+    if (fuse_opt_add_opt(&mo->kernel_opts, "allow_other") == -1 ||
+        fuse_opt_add_arg(outargs, "-oallow_root") == -1)
+      return -1;
+    return 0;
 
-	case KEY_RO:
-		arg = "ro";
-		/* fall through */
+  case KEY_RO:
+    arg = "ro";
+    /* fall through */
 
-	case KEY_KERN:
-		return fuse_opt_add_opt(&mo->kernel_opts, arg);
+  case KEY_KERN:
+    return fuse_opt_add_opt(&mo->kernel_opts, arg);
 
-	case KEY_HELP:
-		mount_help();
-		mo->ishelp = 1;
-		break;
+  case KEY_HELP:
+    mount_help();
+    mo->ishelp = 1;
+    break;
 
-	case KEY_VERSION:
-		mount_version();
-		mo->ishelp = 1;
-		break;
-	}
-	return 1;
-}
-
-void fuse_unmount_compat22(const char *mountpoint)
-{
-	char dev[128];
-	char *ssc, *umount_cmd;
-	FILE *sf;
-	int rv;
-	char seekscript[] =
-		/* error message is annoying in help output */
-		"exec 2>/dev/null; "
-		"/usr/bin/fstat " FUSE_DEV_TRUNK "* | "
-		"/usr/bin/awk 'BEGIN{ getline; if (! ($3 == \"PID\" && $10 == \"NAME\")) exit 1; }; "
-		"              { if ($3 == %d) print $10; }' | "
-		"/usr/bin/sort | "
-		"/usr/bin/uniq | "
-		"/usr/bin/awk '{ i += 1; if (i > 1){ exit 1; }; printf; }; END{ if (i == 0) exit 1; }'";
-
-	(void) mountpoint;
-
-	/*
-	 * If we don't know the fd, we have to resort to the scripted
-	 * solution -- iterating over the fd-s is unpractical, as we
-	 * don't know how many of open files we have. (This could be
-	 * looked up in procfs -- however, that's optional on FBSD; or
-	 * read out from the kmem -- however, that's bound to
-	 * privileges (in fact, that's what happens when we call the
-	 * setgid kmem fstat(1) utility).
-	 */
-	if (asprintf(&ssc, seekscript, getpid()) == -1)
-		return;
-
-	errno = 0;
-	sf = popen(ssc, "r");
-	free(ssc);
-	if (! sf)
-		return;
-
-	fgets(dev, sizeof(dev), sf);
-	rv = pclose(sf);
-	if (rv)
-		return;
-
-	if (asprintf(&umount_cmd, "/sbin/umount %s", dev) == -1)
-		return;
-	system(umount_cmd);
-	free(umount_cmd);
+  case KEY_VERSION:
+    mount_version();
+    mo->ishelp = 1;
+    break;
+  }
+  return 1;
 }
 
 static void do_unmount(char *dev, int fd)
 {
-	char device_path[SPECNAMELEN + 12];
-	const char *argv[4];
-	const char umount_cmd[] = "/sbin/umount";
-	pid_t pid;
+  char device_path[SPECNAMELEN + 12];
+  const char *argv[4];
+  const char umount_cmd[] = "/sbin/umount";
+  pid_t pid;
 
-	snprintf(device_path, SPECNAMELEN + 12, _PATH_DEV "%s", dev);
+  snprintf(device_path, SPECNAMELEN + 12, _PATH_DEV "%s", dev);
 
-	argv[0] = umount_cmd;
-	argv[1] = "-f";
-	argv[2] = device_path;
-	argv[3] = NULL;
+  argv[0] = umount_cmd;
+  argv[1] = "-f";
+  argv[2] = device_path;
+  argv[3] = NULL;
 
-	pid = fork();
+  pid = fork();
 
-	if (pid == -1)
-		return;
+  if (pid == -1)
+    return;
 
-	if (pid == 0) {
-		close(fd);
-		execvp(umount_cmd, (char **)argv);
-		exit(1);
-	}
+  if (pid == 0) {
+    close(fd);
+    execvp(umount_cmd, (char **)argv);
+    exit(1);
+  }
 
-	waitpid(pid, NULL, 0);
+  waitpid(pid, NULL, 0);
 }
 
 void fuse_kern_unmount(const char *mountpoint, int fd)
 {
-	char *ep, dev[128];
-	struct stat sbuf;
+  char *ep, dev[128];
+  struct stat sbuf;
 
-	(void)mountpoint;
+  (void)mountpoint;
 
-	if (fstat(fd, &sbuf) == -1)
-		goto out;
+  if (fstat(fd, &sbuf) == -1)
+    goto out;
 
-	devname_r(sbuf.st_rdev, S_IFCHR, dev, 128);
+  devname_r(sbuf.st_rdev, S_IFCHR, dev, 128);
 
-	if (strncmp(dev, "fuse", 4))
-		goto out;
+  if (strncmp(dev, "fuse", 4))
+    goto out;
 
-	strtol(dev + 4, &ep, 10);
-	if (*ep != '\0')
-		goto out;
+  strtol(dev + 4, &ep, 10);
+  if (*ep != '\0')
+    goto out;
 
-	do_unmount(dev, fd);
+  do_unmount(dev, fd);
 
-out:
-	close(fd);
+ out:
+  close(fd);
 }
 
 /* Check if kernel is doing init in background */
 static int init_backgrounded(void)
 {
-	unsigned ibg, len;
+  unsigned ibg, len;
 
-	len = sizeof(ibg);
+  len = sizeof(ibg);
 
-	if (sysctlbyname("vfs.fuse.init_backgrounded", &ibg, &len, NULL, 0))
-		return 0;
+  if (sysctlbyname("vfs.fuse.init_backgrounded", &ibg, &len, NULL, 0))
+    return 0;
 
-	return ibg;
+  return ibg;
 }
 
 
 static int fuse_mount_core(const char *mountpoint, const char *opts)
 {
-	const char *mountprog = FUSERMOUNT_PROG;
-	int fd;
-	char *fdnam, *dev;
-	pid_t pid, cpid;
-	int status;
+  const char *mountprog = FUSERMOUNT_PROG;
+  int fd;
+  char *fdnam, *dev;
+  pid_t pid, cpid;
+  int status;
 
-	fdnam = getenv("FUSE_DEV_FD");
+  fdnam = getenv("FUSE_DEV_FD");
 
-	if (fdnam) {
-		char *ep;
+  if (fdnam) {
+    char *ep;
 
-		fd = strtol(fdnam, &ep, 10);
+    fd = strtol(fdnam, &ep, 10);
 
-		if (*ep != '\0') {
-			fprintf(stderr, "invalid value given in FUSE_DEV_FD\n");
-			return -1;
-		}
+    if (*ep != '\0') {
+      fprintf(stderr, "invalid value given in FUSE_DEV_FD\n");
+      return -1;
+    }
 
-		if (fd < 0)
-			return -1;
+    if (fd < 0)
+      return -1;
 
-		goto mount;
-	}
+    goto mount;
+  }
 
-	dev = getenv("FUSE_DEV_NAME");
+  dev = getenv("FUSE_DEV_NAME");
 
-	if (! dev)
-		dev = (char *)FUSE_DEV_TRUNK;
+  if (! dev)
+    dev = (char *)FUSE_DEV_TRUNK;
 
-	if ((fd = open(dev, O_RDWR)) < 0) {
-		perror("fuse: failed to open fuse device");
-		return -1;
-	}
+  if ((fd = open(dev, O_RDWR)) < 0) {
+    perror("fuse: failed to open fuse device");
+    return -1;
+  }
 
-mount:
-	if (getenv("FUSE_NO_MOUNT") || ! mountpoint)
-		goto out;
+ mount:
+  if (getenv("FUSE_NO_MOUNT") || ! mountpoint)
+    goto out;
 
-	pid = fork();
-	cpid = pid;
+  pid = fork();
+  cpid = pid;
 
-	if (pid == -1) {
-		perror("fuse: fork() failed");
-		close(fd);
-		return -1;
-	}
+  if (pid == -1) {
+    perror("fuse: fork() failed");
+    close(fd);
+    return -1;
+  }
 
-	if (pid == 0) {
-		if (! init_backgrounded()) {
-			/*
-			 * If init is not backgrounded, we have to
-			 * call the mount util backgrounded, to avoid
-			 * deadlock.
-			 */
+  if (pid == 0) {
+    if (! init_backgrounded()) {
+      /*
+       * If init is not backgrounded, we have to
+       * call the mount util backgrounded, to avoid
+       * deadlock.
+       */
 
-			pid = fork();
+      pid = fork();
 
-			if (pid == -1) {
-				perror("fuse: fork() failed");
-				close(fd);
-				exit(1);
-			}
-		}
+      if (pid == -1) {
+        perror("fuse: fork() failed");
+        close(fd);
+        exit(1);
+      }
+    }
 
-		if (pid == 0) {
-			const char *argv[32];
-			int a = 0;
+    if (pid == 0) {
+      const char *argv[32];
+      int a = 0;
 
-			if (! fdnam && asprintf(&fdnam, "%d", fd) == -1) {
-				perror("fuse: failed to assemble mount arguments");
-				exit(1);
-			}
+      if (! fdnam && asprintf(&fdnam, "%d", fd) == -1) {
+        perror("fuse: failed to assemble mount arguments");
+        exit(1);
+      }
 
-			argv[a++] = mountprog;
-			if (opts) {
-				argv[a++] = "-o";
-				argv[a++] = opts;
-			}
-			argv[a++] = fdnam;
-			argv[a++] = mountpoint;
-			argv[a++] = NULL;
-			execvp(mountprog, (char **) argv);
-			perror("fuse: failed to exec mount program");
-			exit(1);
-		}
+      argv[a++] = mountprog;
+      if (opts) {
+        argv[a++] = "-o";
+        argv[a++] = opts;
+      }
+      argv[a++] = fdnam;
+      argv[a++] = mountpoint;
+      argv[a++] = NULL;
+      execvp(mountprog, (char **) argv);
+      perror("fuse: failed to exec mount program");
+      exit(1);
+    }
 
-		exit(0);
-	}
+    exit(0);
+  }
 
-	if (waitpid(cpid, &status, 0) == -1 || WEXITSTATUS(status) != 0) {
-		perror("fuse: failed to mount file system");
-		close(fd);
-		return -1;
-	}
+  if (waitpid(cpid, &status, 0) == -1 || WEXITSTATUS(status) != 0) {
+    perror("fuse: failed to mount file system");
+    close(fd);
+    return -1;
+  }
 
-out:
-	return fd;
+ out:
+  return fd;
 }
 
 int fuse_kern_mount(const char *mountpoint, struct fuse_args *args)
 {
-	struct mount_opts mo;
-	int res = -1;
+  struct mount_opts mo;
+  int res = -1;
 
-	memset(&mo, 0, sizeof(mo));
-	/* mount util should not try to spawn the daemon */
-	setenv("MOUNT_FUSEFS_SAFE", "1", 1);
-	/* to notify the mount util it's called from lib */
-	setenv("MOUNT_FUSEFS_CALL_BY_LIB", "1", 1);
+  memset(&mo, 0, sizeof(mo));
+  /* mount util should not try to spawn the daemon */
+  setenv("MOUNT_FUSEFS_SAFE", "1", 1);
+  /* to notify the mount util it's called from lib */
+  setenv("MOUNT_FUSEFS_CALL_BY_LIB", "1", 1);
 
-	if (args &&
-	    fuse_opt_parse(args, &mo, fuse_mount_opts, fuse_mount_opt_proc) == -1)
-		return -1;
+  if (args &&
+      fuse_opt_parse(args, &mo, fuse_mount_opts, fuse_mount_opt_proc) == -1)
+    return -1;
 
-	if (mo.allow_other && mo.allow_root) {
-		fprintf(stderr, "fuse: 'allow_other' and 'allow_root' options are mutually exclusive\n");
-		goto out;
-	}
-	if (mo.ishelp)
-		return 0;
+  if (mo.allow_other && mo.allow_root) {
+    fprintf(stderr, "fuse: 'allow_other' and 'allow_root' options are mutually exclusive\n");
+    goto out;
+  }
+  if (mo.ishelp)
+    return 0;
 
-	res = fuse_mount_core(mountpoint, mo.kernel_opts);
-out:
-	free(mo.kernel_opts);
-	return res;
+  res = fuse_mount_core(mountpoint, mo.kernel_opts);
+ out:
+  free(mo.kernel_opts);
+  return res;
 }
-
-FUSE_SYMVER(".symver fuse_unmount_compat22,fuse_unmount@FUSE_2.2");

libfuse/lib/mount_util.c

@@ -31,333 +31,333 @@
 #else
 static int mtab_needs_update(const char *mnt)
 {
-	int res;
-	struct stat stbuf;
+  int res;
+  struct stat stbuf;
 
-	/* If mtab is within new mount, don't touch it */
-	if (strncmp(mnt, _PATH_MOUNTED, strlen(mnt)) == 0 &&
-	    _PATH_MOUNTED[strlen(mnt)] == '/')
-		return 0;
+  /* If mtab is within new mount, don't touch it */
+  if (strncmp(mnt, _PATH_MOUNTED, strlen(mnt)) == 0 &&
+      _PATH_MOUNTED[strlen(mnt)] == '/')
+    return 0;
 
-	/*
-	 * Skip mtab update if /etc/mtab:
-	 *
-	 *  - doesn't exist,
-	 *  - is a symlink,
-	 *  - is on a read-only filesystem.
-	 */
-	res = lstat(_PATH_MOUNTED, &stbuf);
-	if (res == -1) {
-		if (errno == ENOENT)
-			return 0;
-	} else {
-		uid_t ruid;
-		int err;
+  /*
+   * Skip mtab update if /etc/mtab:
+   *
+   *  - doesn't exist,
+   *  - is a symlink,
+   *  - is on a read-only filesystem.
+   */
+  res = lstat(_PATH_MOUNTED, &stbuf);
+  if (res == -1) {
+    if (errno == ENOENT)
+      return 0;
+  } else {
+    uid_t ruid;
+    int err;
 
-		if (S_ISLNK(stbuf.st_mode))
-			return 0;
+    if (S_ISLNK(stbuf.st_mode))
+      return 0;
 
-		ruid = getuid();
-		if (ruid != 0)
-			setreuid(0, -1);
+    ruid = getuid();
+    if (ruid != 0)
+      setreuid(0, -1);
 
-		res = access(_PATH_MOUNTED, W_OK);
-		err = (res == -1) ? errno : 0;
-		if (ruid != 0)
-			setreuid(ruid, -1);
+    res = access(_PATH_MOUNTED, W_OK);
+    err = (res == -1) ? errno : 0;
+    if (ruid != 0)
+      setreuid(ruid, -1);
 
-		if (err == EROFS)
-			return 0;
-	}
+    if (err == EROFS)
+      return 0;
+  }
 
-	return 1;
+  return 1;
 }
 #endif /* __NetBSD__ */
 
 static int add_mount(const char *progname, const char *fsname,
-		       const char *mnt, const char *type, const char *opts)
+                     const char *mnt, const char *type, const char *opts)
 {
-	int res;
-	int status;
-	sigset_t blockmask;
-	sigset_t oldmask;
+  int res;
+  int status;
+  sigset_t blockmask;
+  sigset_t oldmask;
 
-	sigemptyset(&blockmask);
-	sigaddset(&blockmask, SIGCHLD);
-	res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
-	if (res == -1) {
-		fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
-		return -1;
-	}
+  sigemptyset(&blockmask);
+  sigaddset(&blockmask, SIGCHLD);
+  res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+  if (res == -1) {
+    fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+    return -1;
+  }
 
-	res = fork();
-	if (res == -1) {
-		fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
-		goto out_restore;
-	}
-	if (res == 0) {
-		char *env = NULL;
+  res = fork();
+  if (res == -1) {
+    fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+    goto out_restore;
+  }
+  if (res == 0) {
+    char *env = NULL;
 
-		sigprocmask(SIG_SETMASK, &oldmask, NULL);
-		setuid(geteuid());
-		execle("/bin/mount", "/bin/mount", "--no-canonicalize", "-i",
-		       "-f", "-t", type, "-o", opts, fsname, mnt, NULL, &env);
-		fprintf(stderr, "%s: failed to execute /bin/mount: %s\n",
-			progname, strerror(errno));
-		exit(1);
-	}
-	res = waitpid(res, &status, 0);
-	if (res == -1)
-		fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+    sigprocmask(SIG_SETMASK, &oldmask, NULL);
+    setuid(geteuid());
+    execle("/bin/mount", "/bin/mount", "--no-canonicalize", "-i",
+           "-f", "-t", type, "-o", opts, fsname, mnt, NULL, &env);
+    fprintf(stderr, "%s: failed to execute /bin/mount: %s\n",
+            progname, strerror(errno));
+    exit(1);
+  }
+  res = waitpid(res, &status, 0);
+  if (res == -1)
+    fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
 
-	if (status != 0)
-		res = -1;
+  if (status != 0)
+    res = -1;
 
  out_restore:
-	sigprocmask(SIG_SETMASK, &oldmask, NULL);
+  sigprocmask(SIG_SETMASK, &oldmask, NULL);
 
-	return res;
+  return res;
 }
 
 int fuse_mnt_add_mount(const char *progname, const char *fsname,
 		       const char *mnt, const char *type, const char *opts)
 {
-	if (!mtab_needs_update(mnt))
-		return 0;
+  if (!mtab_needs_update(mnt))
+    return 0;
 
-	return add_mount(progname, fsname, mnt, type, opts);
+  return add_mount(progname, fsname, mnt, type, opts);
 }
 
 static int exec_umount(const char *progname, const char *rel_mnt, int lazy)
 {
-	int res;
-	int status;
-	sigset_t blockmask;
-	sigset_t oldmask;
+  int res;
+  int status;
+  sigset_t blockmask;
+  sigset_t oldmask;
 
-	sigemptyset(&blockmask);
-	sigaddset(&blockmask, SIGCHLD);
-	res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
-	if (res == -1) {
-		fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
-		return -1;
-	}
+  sigemptyset(&blockmask);
+  sigaddset(&blockmask, SIGCHLD);
+  res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+  if (res == -1) {
+    fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+    return -1;
+  }
 
-	res = fork();
-	if (res == -1) {
-		fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
-		goto out_restore;
-	}
-	if (res == 0) {
-		char *env = NULL;
+  res = fork();
+  if (res == -1) {
+    fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+    goto out_restore;
+  }
+  if (res == 0) {
+    char *env = NULL;
 
-		sigprocmask(SIG_SETMASK, &oldmask, NULL);
-		setuid(geteuid());
-		if (lazy) {
-			execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
-			       "-l", NULL, &env);
-		} else {
-			execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
-			       NULL, &env);
-		}
-		fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
-			progname, strerror(errno));
-		exit(1);
-	}
-	res = waitpid(res, &status, 0);
-	if (res == -1)
-		fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+    sigprocmask(SIG_SETMASK, &oldmask, NULL);
+    setuid(geteuid());
+    if (lazy) {
+      execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
+             "-l", NULL, &env);
+    } else {
+      execle("/bin/umount", "/bin/umount", "-i", rel_mnt,
+             NULL, &env);
+    }
+    fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
+            progname, strerror(errno));
+    exit(1);
+  }
+  res = waitpid(res, &status, 0);
+  if (res == -1)
+    fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
 
-	if (status != 0) {
-		res = -1;
-	}
+  if (status != 0) {
+    res = -1;
+  }
 
  out_restore:
-	sigprocmask(SIG_SETMASK, &oldmask, NULL);
-	return res;
+  sigprocmask(SIG_SETMASK, &oldmask, NULL);
+  return res;
 
 }
 
 int fuse_mnt_umount(const char *progname, const char *abs_mnt,
 		    const char *rel_mnt, int lazy)
 {
-	int res;
+  int res;
 
-	if (!mtab_needs_update(abs_mnt)) {
-		res = umount2(rel_mnt, lazy ? 2 : 0);
-		if (res == -1)
-			fprintf(stderr, "%s: failed to unmount %s: %s\n",
-				progname, abs_mnt, strerror(errno));
-		return res;
-	}
+  if (!mtab_needs_update(abs_mnt)) {
+    res = umount2(rel_mnt, lazy ? 2 : 0);
+    if (res == -1)
+      fprintf(stderr, "%s: failed to unmount %s: %s\n",
+              progname, abs_mnt, strerror(errno));
+    return res;
+  }
 
-	return exec_umount(progname, rel_mnt, lazy);
+  return exec_umount(progname, rel_mnt, lazy);
 }
 
 static int remove_mount(const char *progname, const char *mnt)
 {
-	int res;
-	int status;
-	sigset_t blockmask;
-	sigset_t oldmask;
+  int res;
+  int status;
+  sigset_t blockmask;
+  sigset_t oldmask;
 
-	sigemptyset(&blockmask);
-	sigaddset(&blockmask, SIGCHLD);
-	res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
-	if (res == -1) {
-		fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
-		return -1;
-	}
+  sigemptyset(&blockmask);
+  sigaddset(&blockmask, SIGCHLD);
+  res = sigprocmask(SIG_BLOCK, &blockmask, &oldmask);
+  if (res == -1) {
+    fprintf(stderr, "%s: sigprocmask: %s\n", progname, strerror(errno));
+    return -1;
+  }
 
-	res = fork();
-	if (res == -1) {
-		fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
-		goto out_restore;
-	}
-	if (res == 0) {
-		char *env = NULL;
+  res = fork();
+  if (res == -1) {
+    fprintf(stderr, "%s: fork: %s\n", progname, strerror(errno));
+    goto out_restore;
+  }
+  if (res == 0) {
+    char *env = NULL;
 
-		sigprocmask(SIG_SETMASK, &oldmask, NULL);
-		setuid(geteuid());
-		execle("/bin/umount", "/bin/umount", "--no-canonicalize", "-i",
-		       "--fake", mnt, NULL, &env);
-		fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
-			progname, strerror(errno));
-		exit(1);
-	}
-	res = waitpid(res, &status, 0);
-	if (res == -1)
-		fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
+    sigprocmask(SIG_SETMASK, &oldmask, NULL);
+    setuid(geteuid());
+    execle("/bin/umount", "/bin/umount", "--no-canonicalize", "-i",
+           "--fake", mnt, NULL, &env);
+    fprintf(stderr, "%s: failed to execute /bin/umount: %s\n",
+            progname, strerror(errno));
+    exit(1);
+  }
+  res = waitpid(res, &status, 0);
+  if (res == -1)
+    fprintf(stderr, "%s: waitpid: %s\n", progname, strerror(errno));
 
-	if (status != 0)
-		res = -1;
+  if (status != 0)
+    res = -1;
 
  out_restore:
-	sigprocmask(SIG_SETMASK, &oldmask, NULL);
-	return res;
+  sigprocmask(SIG_SETMASK, &oldmask, NULL);
+  return res;
 }
 
 int fuse_mnt_remove_mount(const char *progname, const char *mnt)
 {
-	if (!mtab_needs_update(mnt))
-		return 0;
+  if (!mtab_needs_update(mnt))
+    return 0;
 
-	return remove_mount(progname, mnt);
+  return remove_mount(progname, mnt);
 }
 
 char *fuse_mnt_resolve_path(const char *progname, const char *orig)
 {
-	char buf[PATH_MAX];
-	char *copy;
-	char *dst;
-	char *end;
-	char *lastcomp;
-	const char *toresolv;
+  char buf[PATH_MAX];
+  char *copy;
+  char *dst;
+  char *end;
+  char *lastcomp;
+  const char *toresolv;
 
-	if (!orig[0]) {
-		fprintf(stderr, "%s: invalid mountpoint '%s'\n", progname,
-			orig);
-		return NULL;
-	}
+  if (!orig[0]) {
+    fprintf(stderr, "%s: invalid mountpoint '%s'\n", progname,
+            orig);
+    return NULL;
+  }
 
-	copy = strdup(orig);
-	if (copy == NULL) {
-		fprintf(stderr, "%s: failed to allocate memory\n", progname);
-		return NULL;
-	}
+  copy = strdup(orig);
+  if (copy == NULL) {
+    fprintf(stderr, "%s: failed to allocate memory\n", progname);
+    return NULL;
+  }
 
-	toresolv = copy;
-	lastcomp = NULL;
-	for (end = copy + strlen(copy) - 1; end > copy && *end == '/'; end --);
-	if (end[0] != '/') {
-		char *tmp;
-		end[1] = '\0';
-		tmp = strrchr(copy, '/');
-		if (tmp == NULL) {
-			lastcomp = copy;
-			toresolv = ".";
-		} else {
-			lastcomp = tmp + 1;
-			if (tmp == copy)
-				toresolv = "/";
-		}
-		if (strcmp(lastcomp, ".") == 0 || strcmp(lastcomp, "..") == 0) {
-			lastcomp = NULL;
-			toresolv = copy;
-		}
-		else if (tmp)
-			tmp[0] = '\0';
-	}
-	if (realpath(toresolv, buf) == NULL) {
-		fprintf(stderr, "%s: bad mount point %s: %s\n", progname, orig,
-			strerror(errno));
-		free(copy);
-		return NULL;
-	}
-	if (lastcomp == NULL)
-		dst = strdup(buf);
-	else {
-		dst = (char *) malloc(strlen(buf) + 1 + strlen(lastcomp) + 1);
-		if (dst) {
-			unsigned buflen = strlen(buf);
-			if (buflen && buf[buflen-1] == '/')
-				sprintf(dst, "%s%s", buf, lastcomp);
-			else
-				sprintf(dst, "%s/%s", buf, lastcomp);
-		}
-	}
-	free(copy);
-	if (dst == NULL)
-		fprintf(stderr, "%s: failed to allocate memory\n", progname);
-	return dst;
+  toresolv = copy;
+  lastcomp = NULL;
+  for (end = copy + strlen(copy) - 1; end > copy && *end == '/'; end --);
+  if (end[0] != '/') {
+    char *tmp;
+    end[1] = '\0';
+    tmp = strrchr(copy, '/');
+    if (tmp == NULL) {
+      lastcomp = copy;
+      toresolv = ".";
+    } else {
+      lastcomp = tmp + 1;
+      if (tmp == copy)
+        toresolv = "/";
+    }
+    if (strcmp(lastcomp, ".") == 0 || strcmp(lastcomp, "..") == 0) {
+      lastcomp = NULL;
+      toresolv = copy;
+    }
+    else if (tmp)
+      tmp[0] = '\0';
+  }
+  if (realpath(toresolv, buf) == NULL) {
+    fprintf(stderr, "%s: bad mount point %s: %s\n", progname, orig,
+            strerror(errno));
+    free(copy);
+    return NULL;
+  }
+  if (lastcomp == NULL)
+    dst = strdup(buf);
+  else {
+    dst = (char *) malloc(strlen(buf) + 1 + strlen(lastcomp) + 1);
+    if (dst) {
+      unsigned buflen = strlen(buf);
+      if (buflen && buf[buflen-1] == '/')
+        sprintf(dst, "%s%s", buf, lastcomp);
+      else
+        sprintf(dst, "%s/%s", buf, lastcomp);
+    }
+  }
+  free(copy);
+  if (dst == NULL)
+    fprintf(stderr, "%s: failed to allocate memory\n", progname);
+  return dst;
 }
 
 int fuse_mnt_check_empty(const char *progname, const char *mnt,
 			 mode_t rootmode, off_t rootsize)
 {
-	int isempty = 1;
+  int isempty = 1;
 
-	if (S_ISDIR(rootmode)) {
-		struct dirent *ent;
-		DIR *dp = opendir(mnt);
-		if (dp == NULL) {
-			fprintf(stderr,
-				"%s: failed to open mountpoint for reading: %s\n",
-				progname, strerror(errno));
-			return -1;
-		}
-		while ((ent = readdir(dp)) != NULL) {
-			if (strcmp(ent->d_name, ".") != 0 &&
-			    strcmp(ent->d_name, "..") != 0) {
-				isempty = 0;
-				break;
-			}
-		}
-		closedir(dp);
-	} else if (rootsize)
-		isempty = 0;
+  if (S_ISDIR(rootmode)) {
+    struct dirent *ent;
+    DIR *dp = opendir(mnt);
+    if (dp == NULL) {
+      fprintf(stderr,
+              "%s: failed to open mountpoint for reading: %s\n",
+              progname, strerror(errno));
+      return -1;
+    }
+    while ((ent = readdir(dp)) != NULL) {
+      if (strcmp(ent->d_name, ".") != 0 &&
+          strcmp(ent->d_name, "..") != 0) {
+        isempty = 0;
+        break;
+      }
+    }
+    closedir(dp);
+  } else if (rootsize)
+    isempty = 0;
 
-	if (!isempty) {
-		fprintf(stderr, "%s: mountpoint is not empty\n", progname);
-		fprintf(stderr, "%s: if you are sure this is safe, use the 'nonempty' mount option\n", progname);
-		return -1;
-	}
-	return 0;
+  if (!isempty) {
+    fprintf(stderr, "%s: mountpoint is not empty\n", progname);
+    fprintf(stderr, "%s: if you are sure this is safe, use the 'nonempty' mount option\n", progname);
+    return -1;
+  }
+  return 0;
 }
 
 int fuse_mnt_check_fuseblk(void)
 {
-	char buf[256];
-	FILE *f = fopen("/proc/filesystems", "r");
-	if (!f)
-		return 1;
+  char buf[256];
+  FILE *f = fopen("/proc/filesystems", "r");
+  if (!f)
+    return 1;
 
-	while (fgets(buf, sizeof(buf), f))
-		if (strstr(buf, "fuseblk\n")) {
-			fclose(f);
-			return 1;
-		}
+  while (fgets(buf, sizeof(buf), f))
+    if (strstr(buf, "fuseblk\n")) {
+      fclose(f);
+      return 1;
+    }
 
-	fclose(f);
-	return 0;
+  fclose(f);
+  return 0;
 }

libfuse/lib/mount_util.h

@@ -6,6 +6,8 @@
   See the file COPYING.LIB.
 */
 
+#pragma once
+
 #include <sys/types.h>
 
 int fuse_mnt_add_mount(const char *progname, const char *fsname,

libfuse/lib/ulockmgr.c

@@ -1,444 +0,0 @@
-/*
-  libulockmgr: Userspace Lock Manager Library
-  Copyright (C) 2006  Miklos Szeredi <miklos@szeredi.hu>
-
-  This program can be distributed under the terms of the GNU LGPLv2.
-  See the file COPYING.LIB
-*/
-
-/* #define DEBUG 1 */
-
-#include "ulockmgr.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <pthread.h>
-#include <errno.h>
-#include <assert.h>
-#include <signal.h>
-#include <sys/stat.h>
-#include <sys/socket.h>
-#include <sys/wait.h>
-
-struct message {
-	unsigned intr : 1;
-	unsigned nofd : 1;
-	pthread_t thr;
-	int cmd;
-	int fd;
-	struct flock lock;
-	int error;
-};
-
-struct fd_store {
-	struct fd_store *next;
-	int fd;
-	int inuse;
-};
-
-struct owner {
-	struct owner *next;
-	struct owner *prev;
-	struct fd_store *fds;
-	void *id;
-	size_t id_len;
-	int cfd;
-};
-
-static pthread_mutex_t ulockmgr_lock;
-static int ulockmgr_cfd = -1;
-static struct owner owner_list = { .next = &owner_list, .prev = &owner_list };
-
-#define MAX_SEND_FDS 2
-
-static void list_del_owner(struct owner *owner)
-{
-	struct owner *prev = owner->prev;
-	struct owner *next = owner->next;
-	prev->next = next;
-	next->prev = prev;
-}
-
-static void list_add_owner(struct owner *owner, struct owner *next)
-{
-	struct owner *prev = next->prev;
-	owner->next = next;
-	owner->prev = prev;
-	prev->next = owner;
-	next->prev = owner;
-}
-
-/*
- * There's a bug in the linux kernel (< 2.6.22) recv() implementation
- * on AF_UNIX, SOCK_STREAM sockets, that could cause it to return
- * zero, even if data was available.  Retrying the recv will return
- * the data in this case.
- */
-static int do_recv(int sock, void *buf, size_t len, int flags)
-{
-	int res = recv(sock, buf, len, flags);
-	if (res == 0)
-		res = recv(sock, buf, len, flags);
-
-	return res;
-}
-
-static int ulockmgr_send_message(int sock, void *buf, size_t buflen,
-				 int *fdp, int numfds)
-{
-	struct msghdr msg;
-	struct cmsghdr *p_cmsg;
-	struct iovec vec;
-	size_t cmsgbuf[CMSG_SPACE(sizeof(int) * MAX_SEND_FDS) / sizeof(size_t)];
-	int res;
-
-	assert(numfds <= MAX_SEND_FDS);
-	msg.msg_control = cmsgbuf;
-	msg.msg_controllen = sizeof(cmsgbuf);
-	p_cmsg = CMSG_FIRSTHDR(&msg);
-	p_cmsg->cmsg_level = SOL_SOCKET;
-	p_cmsg->cmsg_type = SCM_RIGHTS;
-	p_cmsg->cmsg_len = CMSG_LEN(sizeof(int) * numfds);
-	memcpy(CMSG_DATA(p_cmsg), fdp, sizeof(int) * numfds);
-	msg.msg_controllen = p_cmsg->cmsg_len;
-	msg.msg_name = NULL;
-	msg.msg_namelen = 0;
-	msg.msg_iov = &vec;
-	msg.msg_iovlen = 1;
-	msg.msg_flags = 0;
-	vec.iov_base = buf;
-	vec.iov_len = buflen;
-	res = sendmsg(sock, &msg, MSG_NOSIGNAL);
-	if (res == -1) {
-		perror("libulockmgr: sendmsg");
-		return -1;
-	}
-	if ((size_t) res != buflen) {
-		fprintf(stderr, "libulockmgr: sendmsg short\n");
-		return -1;
-	}
-	return 0;
-}
-
-static int ulockmgr_start_daemon(void)
-{
-	int sv[2];
-	int res;
-	char tmp[64];
-
-	res = socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
-	if (res == -1) {
-		perror("libulockmgr: socketpair");
-		return -1;
-	}
-	snprintf(tmp, sizeof(tmp), "exec ulockmgr_server %i", sv[0]);
-	res = system(tmp);
-	close(sv[0]);
-	if (res == -1 || !WIFEXITED(res) || WEXITSTATUS(res) != 0) {
-		close(sv[1]);
-		return -1;
-	}
-	ulockmgr_cfd = sv[1];
-	return 0;
-}
-
-static struct owner *ulockmgr_new_owner(const void *id, size_t id_len)
-{
-	int sv[2];
-	int res;
-	char c = 'm';
-	struct owner *o;
-
-	if (ulockmgr_cfd == -1 && ulockmgr_start_daemon() == -1)
-		return NULL;
-
-	o = calloc(1, sizeof(struct owner) + id_len);
-	if (!o) {
-		fprintf(stderr, "libulockmgr: failed to allocate memory\n");
-		return NULL;
-	}
-	o->id = o + 1;
-	o->id_len = id_len;
-	res = socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
-	if (res == -1) {
-		perror("libulockmgr: socketpair");
-		goto out_free;
-	}
-	res = ulockmgr_send_message(ulockmgr_cfd, &c, sizeof(c), &sv[0], 1);
-	close(sv[0]);
-	if (res == -1) {
-		close(ulockmgr_cfd);
-		ulockmgr_cfd = -1;
-		goto out_close;
-	}
-
-	o->cfd = sv[1];
-	memcpy(o->id, id, id_len);
-	list_add_owner(o, &owner_list);
-
-	return o;
-
-out_close:
-	close(sv[1]);
-out_free:
-	free(o);
-	return NULL;
-}
-
-static int ulockmgr_send_request(struct message *msg, const void *id,
-				 size_t id_len)
-{
-	int sv[2];
-	int cfd;
-	struct owner *o;
-	struct fd_store *f = NULL;
-	struct fd_store *newf = NULL;
-	struct fd_store **fp;
-	int fd = msg->fd;
-	int cmd = msg->cmd;
-	int res;
-	int unlockall = (cmd == F_SETLK && msg->lock.l_type == F_UNLCK &&
-			 msg->lock.l_start == 0 && msg->lock.l_len == 0);
-
-	for (o = owner_list.next; o != &owner_list; o = o->next)
-		if (o->id_len == id_len && memcmp(o->id, id, id_len) == 0)
-			break;
-
-	if (o == &owner_list)
-		o = NULL;
-
-	if (!o && cmd != F_GETLK && msg->lock.l_type != F_UNLCK)
-		o = ulockmgr_new_owner(id, id_len);
-
-	if (!o) {
-		if (cmd == F_GETLK) {
-			res = fcntl(msg->fd, F_GETLK, &msg->lock);
-			return (res == -1) ? -errno : 0;
-		} else if (msg->lock.l_type == F_UNLCK)
-			return 0;
-		else
-			return -ENOLCK;
-	}
-
-	if (unlockall)
-		msg->nofd = 1;
-	else {
-		for (fp = &o->fds; *fp; fp = &(*fp)->next) {
-			f = *fp;
-			if (f->fd == fd) {
-				msg->nofd = 1;
-				break;
-			}
-		}
-	}
-
-	if (!msg->nofd) {
-		newf = f = calloc(1, sizeof(struct fd_store));
-		if (!f) {
-			fprintf(stderr, "libulockmgr: failed to allocate memory\n");
-			return -ENOLCK;
-		}
-	}
-
-	res = socketpair(AF_UNIX, SOCK_STREAM, 0, sv);
-	if (res == -1) {
-		perror("libulockmgr: socketpair");
-		free(newf);
-		return -ENOLCK;
-	}
-
-	cfd = sv[1];
-	sv[1] = msg->fd;
-	res = ulockmgr_send_message(o->cfd, msg, sizeof(struct message), sv,
-				    msg->nofd ? 1 : 2);
-	close(sv[0]);
-	if (res == -1) {
-		free(newf);
-		close(cfd);
-		return -EIO;
-	}
-
-	if (newf) {
-		newf->fd = msg->fd;
-		newf->next = o->fds;
-		o->fds = newf;
-	}
-	if (f)
-		f->inuse++;
-
-	res = do_recv(cfd, msg, sizeof(struct message), MSG_WAITALL);
-	if (res == -1) {
-		perror("libulockmgr: recv");
-		msg->error = EIO;
-	} else if (res != sizeof(struct message)) {
-		fprintf(stderr, "libulockmgr: recv short\n");
-		msg->error = EIO;
-	} else if (cmd == F_SETLKW && msg->error == EAGAIN) {
-		pthread_mutex_unlock(&ulockmgr_lock);
-		while (1) {
-			sigset_t old;
-			sigset_t unblock;
-			int errno_save;
-
-			sigemptyset(&unblock);
-			sigaddset(&unblock, SIGUSR1);
-			pthread_sigmask(SIG_UNBLOCK, &unblock, &old);
-			res = do_recv(cfd, msg, sizeof(struct message),
-				      MSG_WAITALL);
-			errno_save = errno;
-			pthread_sigmask(SIG_SETMASK, &old, NULL);
-			if (res == sizeof(struct message))
-				break;
-			else if (res >= 0) {
-				fprintf(stderr, "libulockmgr: recv short\n");
-				msg->error = EIO;
-				break;
-			} else if (errno_save != EINTR) {
-				errno = errno_save;
-				perror("libulockmgr: recv");
-				msg->error = EIO;
-				break;
-			}
-			msg->intr = 1;
-			res = send(o->cfd, msg, sizeof(struct message),
-				   MSG_NOSIGNAL);
-			if (res == -1) {
-				perror("libulockmgr: send");
-				msg->error = EIO;
-				break;
-			}
-			if (res != sizeof(struct message)) {
-				fprintf(stderr, "libulockmgr: send short\n");
-				msg->error = EIO;
-				break;
-			}
-		}
-		pthread_mutex_lock(&ulockmgr_lock);
-
-	}
-	if (f)
-		f->inuse--;
-	close(cfd);
-	if (unlockall) {
-		for (fp = &o->fds; *fp;) {
-			f = *fp;
-			if (f->fd == fd && !f->inuse) {
-				*fp = f->next;
-				free(f);
-			} else
-				fp = &f->next;
-		}
-		if (!o->fds) {
-			list_del_owner(o);
-			close(o->cfd);
-			free(o);
-		}
-		/* Force OK on unlock-all, since it _will_ succeed once the
-		   owner is deleted */
-		msg->error = 0;
-	}
-
-	return -msg->error;
-}
-
-#ifdef DEBUG
-static uint32_t owner_hash(const unsigned char *id, size_t id_len)
-{
-	uint32_t h = 0;
-	size_t i;
-	for (i = 0; i < id_len; i++)
-		h = ((h << 8) | (h >> 24)) ^ id[i];
-
-	return h;
-}
-#endif
-
-static int ulockmgr_canonicalize(int fd, struct flock *lock)
-{
-	off_t offset;
-	if (lock->l_whence == SEEK_CUR) {
-		offset = lseek(fd, 0, SEEK_CUR);
-		if (offset == (off_t) -1)
-			return -errno;
-	} else if (lock->l_whence == SEEK_END) {
-		struct stat stbuf;
-		int res = fstat(fd, &stbuf);
-		if (res == -1)
-			return -errno;
-
-		offset = stbuf.st_size;
-	} else
-		offset = 0;
-
-	lock->l_whence = SEEK_SET;
-	lock->l_start += offset;
-
-	if (lock->l_start < 0)
-		return -EINVAL;
-
-	if (lock->l_len < 0) {
-		lock->l_start += lock->l_len;
-		if (lock->l_start < 0)
-			return -EINVAL;
-		lock->l_len = -lock->l_len;
-	}
-	if (lock->l_len && lock->l_start + lock->l_len - 1 < 0)
-		return -EINVAL;
-
-	return 0;
-}
-
-int ulockmgr_op(int fd, int cmd, struct flock *lock, const void *owner,
-		size_t owner_len)
-{
-	int err;
-	struct message msg;
-	sigset_t old;
-	sigset_t block;
-
-	if (cmd != F_GETLK && cmd != F_SETLK && cmd != F_SETLKW)
-		return -EINVAL;
-
-	if (lock->l_type != F_RDLCK && lock->l_type != F_WRLCK &&
-	    lock->l_type != F_UNLCK)
-		return -EINVAL;
-
-	if (lock->l_whence != SEEK_SET && lock->l_whence != SEEK_CUR &&
-	    lock->l_whence != SEEK_END)
-		return -EINVAL;
-
-#ifdef DEBUG
-	fprintf(stderr, "libulockmgr: %i %i %i %lli %lli own: 0x%08x\n",
-		cmd, lock->l_type, lock->l_whence, lock->l_start, lock->l_len,
-		owner_hash(owner, owner_len));
-#endif
-
-	/* Unlock should never block anyway */
-	if (cmd == F_SETLKW && lock->l_type == F_UNLCK)
-		cmd = F_SETLK;
-
-	memset(&msg, 0, sizeof(struct message));
-	msg.cmd = cmd;
-	msg.fd = fd;
-	msg.lock = *lock;
-	err = ulockmgr_canonicalize(fd, &msg.lock);
-	if (err)
-		return err;
-
-	sigemptyset(&block);
-	sigaddset(&block, SIGUSR1);
-	pthread_sigmask(SIG_BLOCK, &block, &old);
-	pthread_mutex_lock(&ulockmgr_lock);
-	err = ulockmgr_send_request(&msg, owner, owner_len);
-	pthread_mutex_unlock(&ulockmgr_lock);
-	pthread_sigmask(SIG_SETMASK, &old, NULL);
-	if (!err && cmd == F_GETLK) {
-		if (msg.lock.l_type == F_UNLCK)
-			lock->l_type = F_UNLCK;
-		else
-			*lock = msg.lock;
-	}
-
-	return err;
-}

libfuse/util/Makefile.am

@@ -1,58 +0,0 @@
-## Process this file with automake to produce Makefile.in
-
-AM_CPPFLAGS = -D_FILE_OFFSET_BITS=64 
-bin_PROGRAMS = fusermount ulockmgr_server
-noinst_PROGRAMS = mount.fuse
-
-# we re-use mount_util.c from the library, but do want to keep ourself
-# as stand-alone as possible. in order to make an out-of-source build
-# possible, we "generate" the file from its original location by
-# copying it over.
-fusermount_SOURCES = fusermount.c mount_util.c
-fusermount_CPPFLAGS = -I$(top_srcdir)/lib
-BUILT_SOURCES = mount_util.c
-mount_util.c: $(top_srcdir)/lib/mount_util.c
-	@cp $(top_srcdir)/lib/mount_util.c .
-
-mount_fuse_SOURCES = mount.fuse.c
-
-ulockmgr_server_SOURCES = ulockmgr_server.c
-ulockmgr_server_CPPFLAGS = -D_FILE_OFFSET_BITS=64 -D_REENTRANT 
-ulockmgr_server_LDFLAGS = -pthread
-
-install-exec-hook:
-	-chmod u+s $(DESTDIR)$(bindir)/fusermount
-	@if test ! -e $(DESTDIR)/dev/fuse; then \
-		$(MKDIR_P) $(DESTDIR)/dev; \
-		echo "mknod $(DESTDIR)/dev/fuse -m 0666 c 10 229 || true"; \
-		mknod $(DESTDIR)/dev/fuse -m 0666 c 10 229 || true; \
-	fi
-
-EXTRA_DIST = udev.rules init_script
-
-MOUNT_FUSE_PATH = @MOUNT_FUSE_PATH@
-UDEV_RULES_PATH = @UDEV_RULES_PATH@
-INIT_D_PATH = @INIT_D_PATH@
-
-install-exec-local:
-	$(MKDIR_P) $(DESTDIR)$(MOUNT_FUSE_PATH)
-	$(INSTALL_PROGRAM) $(builddir)/mount.fuse $(DESTDIR)$(MOUNT_FUSE_PATH)/mount.fuse
-	$(MKDIR_P) $(DESTDIR)$(INIT_D_PATH)
-	$(INSTALL_SCRIPT) $(srcdir)/init_script $(DESTDIR)$(INIT_D_PATH)/fuse
-	@if test -x /usr/sbin/update-rc.d; then \
-		echo "/usr/sbin/update-rc.d fuse start 34 S . start 41 0 6 . || true"; \
-		/usr/sbin/update-rc.d fuse start 34 S . start 41 0 6 . || true; \
-	fi
-
-install-data-local:
-	$(MKDIR_P) $(DESTDIR)$(UDEV_RULES_PATH)
-	$(INSTALL_DATA) $(srcdir)/udev.rules $(DESTDIR)$(UDEV_RULES_PATH)/99-fuse.rules
-
-uninstall-local:
-	rm -f $(DESTDIR)$(MOUNT_FUSE_PATH)/mount.fuse
-	rm -f $(DESTDIR)$(UDEV_RULES_PATH)/99-fuse.rules
-	rm -f $(DESTDIR)$(INIT_D_PATH)/fuse
-	@if test -x /usr/sbin/update-rc.d; then \
-		echo "/usr/sbin/update-rc.d fuse remove || true"; \
-		/usr/sbin/update-rc.d fuse remove || true; \
-	fi

libfuse/util/fusermount.c

@@ -1293,7 +1293,7 @@ int main(int argc, char *argv[])
 		return 0;
 
 	/* Become a daemon and wait for the parent to exit or die.
-	   ie For the control socket to get closed. 
+	   ie For the control socket to get closed.
 	   btw We don't want to use daemon() function here because
 	   it forks and messes with the file descriptors. */
 	setsid();

libfuse/util/init_script

@@ -1,89 +0,0 @@
-#! /bin/sh
-### BEGIN INIT INFO
-# Provides:          fuse
-# Required-Start:    
-# Should-Start:      udev
-# Required-Stop:     
-# Default-Start:     S
-# Default-Stop:
-# Short-Description: Start and stop fuse.
-# Description:       Load the fuse module and mount the fuse control
-#	filesystem.
-### END INIT INFO
-
-set -e
-
-PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
-MOUNTPOINT=/sys/fs/fuse/connections
-
-# Gracefully exit if the package has been removed.
-which fusermount &>/dev/null || exit 5
-
-case "$1" in
-    start|restart|force-reload)
-	if ! grep -qw fuse /proc/filesystems; then
-		echo -n "Loading fuse module"
-		if ! modprobe fuse >/dev/null 2>&1; then
-			echo " failed!"
-			exit 1
-		else
-			echo "."
-		fi
-	else
-		echo "Fuse filesystem already available."
-	fi
-	if grep -qw fusectl /proc/filesystems && \
-	   ! grep -qw $MOUNTPOINT /proc/mounts; then
-		echo -n "Mounting fuse control filesystem"
-		if ! mount -t fusectl fusectl $MOUNTPOINT >/dev/null 2>&1; then
-			echo " failed!"
-			exit 1
-		else
-			echo "."
-		fi
-	else
-		echo "Fuse control filesystem already available."
-	fi
-	;;
-    stop)
-	if ! grep -qw fuse /proc/filesystems; then
-		echo "Fuse filesystem not loaded."
-		exit 7
-	fi
-	if grep -qw $MOUNTPOINT /proc/mounts; then
-		echo -n "Unmounting fuse control filesystem"
-		if ! umount $MOUNTPOINT >/dev/null 2>&1; then
-			echo " failed!"
-		else
-			echo "."
-		fi
-	else
-		echo "Fuse control filesystem not mounted."
-	fi
-	if grep -qw "^fuse" /proc/modules; then
-		echo -n "Unloading fuse module"
-		if ! rmmod fuse >/dev/null 2>&1; then
-			echo " failed!"
-		else
-			echo "."
-		fi
-	else
-		echo "Fuse module not loaded."
-	fi
-	;;
-    status)
-	echo -n "Checking fuse filesystem"
-	if ! grep -qw fuse /proc/filesystems; then
-		echo " not available."
-		exit 3
-	else
-		echo " ok."
-	fi
-	;;
-  *)
-	echo "Usage: $0 {start|stop|restart|force-reload|status}"
-	exit 1
-	;;
-esac
-
-exit 0

libfuse/util/mount.mergerfs.c

@@ -93,6 +93,7 @@ int main(int argc, char *argv[])
 	else
 		basename = argv[0];
 
+        type = "mergerfs";
 	if (strncmp(basename, "mount.fuse.", 11) == 0)
 		type = basename + 11;
 	if (strncmp(basename, "mount.fuseblk.", 14) == 0)

libfuse/util/udev.rules

@@ -1 +0,0 @@
-KERNEL=="fuse", MODE="0666"

libfuse/util/ulockmgr_server.c

@@ -1,425 +0,0 @@
-/*
-  ulockmgr_server: Userspace Lock Manager Server
-  Copyright (C) 2006  Miklos Szeredi <miklos@szeredi.hu>
-
-  This program can be distributed under the terms of the GNU GPL.
-  See the file COPYING.
-*/
-
-/* #define DEBUG 1 */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <fcntl.h>
-#include <dirent.h>
-#include <pthread.h>
-#include <stdint.h>
-#include <errno.h>
-#include <assert.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/wait.h>
-
-struct message {
-	unsigned intr : 1;
-	unsigned nofd : 1;
-	pthread_t thr;
-	int cmd;
-	int fd;
-	struct flock lock;
-	int error;
-};
-
-struct fd_store {
-	struct fd_store *next;
-	int fd;
-	int origfd;
-	int inuse;
-};
-
-struct owner {
-	struct fd_store *fds;
-	pthread_mutex_t lock;
-};
-
-struct req_data {
-	struct owner *o;
-	int cfd;
-	struct fd_store *f;
-	struct message msg;
-};
-
-#define MAX_SEND_FDS 2
-
-static int receive_message(int sock, void *buf, size_t buflen, int *fdp,
-			   int *numfds)
-{
-	struct msghdr msg;
-	struct iovec iov;
-	size_t ccmsg[CMSG_SPACE(sizeof(int) * MAX_SEND_FDS) / sizeof(size_t)];
-	struct cmsghdr *cmsg;
-	int res;
-	int i;
-
-	assert(*numfds <= MAX_SEND_FDS);
-	iov.iov_base = buf;
-	iov.iov_len = buflen;
-
-	memset(&msg, 0, sizeof(msg));
-	memset(ccmsg, -1, sizeof(ccmsg));
-	msg.msg_iov = &iov;
-	msg.msg_iovlen = 1;
-	msg.msg_control = ccmsg;
-	msg.msg_controllen = sizeof(ccmsg);
-
-	res = recvmsg(sock, &msg, MSG_WAITALL);
-	if (!res) {
-		/* retry on zero return, see do_recv() in ulockmgr.c */
-		res = recvmsg(sock, &msg, MSG_WAITALL);
-		if (!res)
-			return 0;
-	}
-	if (res == -1) {
-		perror("ulockmgr_server: recvmsg");
-		return -1;
-	}
-	if ((size_t) res != buflen) {
-		fprintf(stderr, "ulockmgr_server: short message received\n");
-		return -1;
-	}
-
-	cmsg = CMSG_FIRSTHDR(&msg);
-	if (cmsg) {
-		if (cmsg->cmsg_type != SCM_RIGHTS) {
-			fprintf(stderr,
-				"ulockmgr_server: unknown control message %d\n",
-				cmsg->cmsg_type);
-			return -1;
-		}
-		memcpy(fdp, CMSG_DATA(cmsg), sizeof(int) * *numfds);
-		if (msg.msg_flags & MSG_CTRUNC) {
-			fprintf(stderr,
-				"ulockmgr_server: control message truncated\n");
-			for (i = 0; i < *numfds; i++)
-				close(fdp[i]);
-			*numfds = 0;
-		}
-	} else {
-		if (msg.msg_flags & MSG_CTRUNC) {
-			fprintf(stderr,
-				"ulockmgr_server: control message truncated(*)\n");
-
-			/* There's a bug in the Linux kernel, that if
-			   not all file descriptors were allocated,
-			   then the cmsg header is not filled in */
-			cmsg = (struct cmsghdr *) ccmsg;
-			memcpy(fdp, CMSG_DATA(cmsg), sizeof(int) * *numfds);
-			for (i = 0; i < *numfds; i++)
-				close(fdp[i]);
-		}
-		*numfds = 0;
-	}
-	return res;
-}
-
-static int closefrom(int minfd)
-{
-	DIR *dir = opendir("/proc/self/fd");
-	if (dir) {
-		int dfd = dirfd(dir);
-		struct dirent *ent;
-		while ((ent = readdir(dir))) {
-			char *end;
-			int fd = strtol(ent->d_name, &end, 10);
-			if (ent->d_name[0] && !end[0] && fd >= minfd &&
-			    fd != dfd)
-				close(fd);
-		}
-		closedir(dir);
-	}
-	return 0;
-}
-
-static void send_reply(int cfd, struct message *msg)
-{
-	int res = send(cfd, msg, sizeof(struct message), MSG_NOSIGNAL);
-	if (res == -1)
-		perror("ulockmgr_server: sending reply");
-#ifdef DEBUG
-	fprintf(stderr, "ulockmgr_server: error: %i\n", msg->error);
-#endif
-}
-
-static void *process_request(void *d_)
-{
-	struct req_data *d = d_;
-	int res;
-
-	assert(d->msg.cmd == F_SETLKW);
-	res = fcntl(d->f->fd, F_SETLK, &d->msg.lock);
-	if (res == -1 && errno == EAGAIN) {
-		d->msg.error = EAGAIN;
-		d->msg.thr = pthread_self();
-		send_reply(d->cfd, &d->msg);
-		res = fcntl(d->f->fd, F_SETLKW, &d->msg.lock);
-	}
-	d->msg.error = (res == -1) ? errno : 0;
-	pthread_mutex_lock(&d->o->lock);
-	d->f->inuse--;
-	pthread_mutex_unlock(&d->o->lock);
-	send_reply(d->cfd, &d->msg);
-	close(d->cfd);
-	free(d);
-
-	return NULL;
-}
-
-static void process_message(struct owner *o, struct message *msg, int cfd,
-			    int fd)
-{
-	struct fd_store *f = NULL;
-	struct fd_store *newf = NULL;
-	struct fd_store **fp;
-	struct req_data *d;
-	pthread_t tid;
-	int res;
-
-#ifdef DEBUG
-	fprintf(stderr, "ulockmgr_server: %i %i %i %lli %lli\n",
-		msg->cmd, msg->lock.l_type, msg->lock.l_whence,
-		msg->lock.l_start, msg->lock.l_len);
-#endif
-
-	if (msg->cmd == F_SETLK	 && msg->lock.l_type == F_UNLCK &&
-	    msg->lock.l_start == 0 && msg->lock.l_len == 0) {
-		for (fp = &o->fds; *fp;) {
-			f = *fp;
-			if (f->origfd == msg->fd && !f->inuse) {
-				close(f->fd);
-				*fp = f->next;
-				free(f);
-			} else
-				fp = &f->next;
-		}
-		if (!msg->nofd)
-			close(fd);
-
-		msg->error = 0;
-		send_reply(cfd, msg);
-		close(cfd);
-		return;
-	}
-
-	if (msg->nofd) {
-		for (fp = &o->fds; *fp; fp = &(*fp)->next) {
-			f = *fp;
-			if (f->origfd == msg->fd)
-				break;
-		}
-		if (!*fp) {
-			fprintf(stderr, "ulockmgr_server: fd %i not found\n",
-				msg->fd);
-			msg->error = EIO;
-			send_reply(cfd, msg);
-			close(cfd);
-			return;
-		}
-	} else {
-		newf = f = malloc(sizeof(struct fd_store));
-		if (!f) {
-			msg->error = ENOLCK;
-			send_reply(cfd, msg);
-			close(cfd);
-			return;
-		}
-
-		f->fd = fd;
-		f->origfd = msg->fd;
-		f->inuse = 0;
-	}
-
-	if (msg->cmd == F_GETLK || msg->cmd == F_SETLK ||
-	    msg->lock.l_type == F_UNLCK) {
-		res = fcntl(f->fd, msg->cmd, &msg->lock);
-		msg->error = (res == -1) ? errno : 0;
-		send_reply(cfd, msg);
-		close(cfd);
-		if (newf) {
-			newf->next = o->fds;
-			o->fds = newf;
-		}
-		return;
-	}
-
-	d = malloc(sizeof(struct req_data));
-	if (!d) {
-		msg->error = ENOLCK;
-		send_reply(cfd, msg);
-		close(cfd);
-		free(newf);
-		return;
-	}
-
-	f->inuse++;
-	d->o = o;
-	d->cfd = cfd;
-	d->f = f;
-	d->msg = *msg;
-	res = pthread_create(&tid, NULL, process_request, d);
-	if (res) {
-		msg->error = ENOLCK;
-		send_reply(cfd, msg);
-		close(cfd);
-		free(d);
-		f->inuse--;
-		free(newf);
-		return;
-	}
-
-	if (newf) {
-		newf->next = o->fds;
-		o->fds = newf;
-	}
-	pthread_detach(tid);
-}
-
-static void sigusr1_handler(int sig)
-{
-	(void) sig;
-	/* Nothing to do */
-}
-
-static void process_owner(int cfd)
-{
-	struct owner o;
-	struct sigaction sa;
-
-	memset(&sa, 0, sizeof(struct sigaction));
-	sa.sa_handler = sigusr1_handler;
-	sigemptyset(&sa.sa_mask);
-
-	if (sigaction(SIGUSR1, &sa, NULL) == -1) {
-		perror("ulockmgr_server: cannot set sigusr1 signal handler");
-		exit(1);
-	}
-
-	memset(&o, 0, sizeof(struct owner));
-	pthread_mutex_init(&o.lock, NULL);
-	while (1) {
-		struct message msg;
-		int rfds[2];
-		int res;
-		int numfds = 2;
-
-		res  = receive_message(cfd, &msg, sizeof(msg), rfds, &numfds);
-		if (!res)
-			break;
-		if (res == -1)
-			exit(1);
-
-		if (msg.intr) {
-			if (numfds != 0)
-				fprintf(stderr,
-					"ulockmgr_server: too many fds for intr\n");
-			pthread_kill(msg.thr, SIGUSR1);
-		} else {
-			if (numfds != 2)
-				continue;
-
-			pthread_mutex_lock(&o.lock);
-			process_message(&o, &msg, rfds[0], rfds[1]);
-			pthread_mutex_unlock(&o.lock);
-		}
-	}
-	if (o.fds)
-		fprintf(stderr,
-			"ulockmgr_server: open file descriptors on exit\n");
-}
-
-int main(int argc, char *argv[])
-{
-	int nullfd;
-	char *end;
-	int cfd;
-	sigset_t empty;
-
-	if (argc != 2 || !argv[1][0])
-		goto out_inval;
-
-	cfd = strtol(argv[1], &end, 10);
-	if (*end)
-		goto out_inval;
-
-	/* demonize current process */
-	switch(fork()) {
-	case -1:
-		perror("ulockmgr_server: fork");
-		exit(1);
-	case 0:
-		break;
-	default:
-		_exit(0);
-	}
-
-	if (setsid() == -1) {
-		perror("ulockmgr_server: setsid");
-		exit(1);
-	}
-
-	(void) chdir("/");
-
-	sigemptyset(&empty);
-	sigprocmask(SIG_SETMASK, &empty, NULL);
-
-	if (dup2(cfd, 4) == -1) {
-		perror("ulockmgr_server: dup2");
-		exit(1);
-	}
-	cfd = 4;
-	nullfd = open("/dev/null", O_RDWR);
-	if (nullfd >= 0) {
-		dup2(nullfd, 0);
-		dup2(nullfd, 1);
-	}
-	close(3);
-	closefrom(5);
-	while (1) {
-		char c;
-		int sock;
-		int pid;
-		int numfds = 1;
-		int res = receive_message(cfd, &c, sizeof(c), &sock, &numfds);
-		if (!res)
-			break;
-		if (res == -1)
-			exit(1);
-		assert(numfds == 1);
-
-		pid = fork();
-		if (pid == -1) {
-			perror("ulockmgr_server: fork");
-			close(sock);
-			continue;
-		}
-		if (pid == 0) {
-			close(cfd);
-			pid = fork();
-			if (pid == -1) {
-				perror("ulockmgr_server: fork");
-				_exit(1);
-			}
-			if (pid == 0)
-				process_owner(sock);
-			_exit(0);
-		}
-		waitpid(pid, NULL, 0);
-		close(sock);
-	}
-	return 0;
-
-out_inval:
-	fprintf(stderr, "%s should be started by libulockmgr\n", argv[0]);
-	return 1;
-}

mergerfs.spec

@@ -1,7 +1,7 @@
 Name:		mergerfs
 Version:	__VERSION__
 Release:	1%{?dist}
-Summary:	A FUSE union filesystem
+Summary:	A featureful FUSE based union filesystem
 
 Group:		Applications/System
 License:	ISC
@@ -32,7 +32,9 @@ make %{?_smp_mflags}
 make install PREFIX=%{_prefix} DESTDIR=%{buildroot}
 
 %files
-%{_bindir}/*
+/usr/bin/mergerfs
+/usr/bin/mergerfs-fusermount
+/sbin/mount.mergerfs
 %doc %{_mandir}/*
 
 %changelog

src/branch.cpp

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

src/branch.hpp

@@ -18,12 +18,27 @@
 
 #pragma once
 
+#include "rwlock.hpp"
+#include "tofrom_string.hpp"
+#include "nonstd/optional.hpp"
+
 #include <string>
 #include <vector>
 
-struct Branch
+#include <stdint.h>
+#include <pthread.h>
+
+class Branch : public ToFromString
 {
-  enum Mode
+public:
+  Branch(const uint64_t &default_minfreespace);
+
+public:
+  int from_string(const std::string &str);
+  std::string to_string(void) const;
+
+public:
+  enum class Mode
     {
       INVALID,
       RO,
@@ -31,26 +46,53 @@ struct Branch
       NC
     };
 
+public:
   Mode        mode;
   std::string path;
+  uint64_t    minfreespace() const;
 
+public:
+  void set_minfreespace(const uint64_t minfreespace);
+
+public:
   bool ro(void) const;
   bool nc(void) const;
   bool ro_or_nc(void) const;
+
+private:
+  nonstd::optional<uint64_t>  _minfreespace;
+  const uint64_t             *_default_minfreespace;
 };
 
-class Branches : public std::vector<Branch>
+typedef std::vector<Branch> BranchVec;
+
+class Branches : public ToFromString
 {
 public:
-  std::string to_string(const bool mode_ = false) const;
-
-  void to_paths(std::vector<std::string> &vec_) const;
+  Branches(const uint64_t &default_minfreespace_);
 
 public:
-  void set(const std::string &str_);
-  void add_begin(const std::string &str_);
-  void add_end(const std::string &str_);
-  void erase_begin(void);
-  void erase_end(void);
-  void erase_fnmatch(const std::string &str_);
+  int from_string(const std::string &str);
+  std::string to_string(void) const;
+
+public:
+  void to_paths(std::vector<std::string> &vec) const;
+
+public:
+  mutable pthread_rwlock_t lock;
+  BranchVec vec;
+  const uint64_t &default_minfreespace;
+};
+
+class SrcMounts : public ToFromString
+{
+public:
+  SrcMounts(Branches &b_);
+
+public:
+  int from_string(const std::string &str);
+  std::string to_string(void) const;
+
+private:
+  Branches &_branches;
 };

src/buildmap.hpp

@@ -17,21 +17,22 @@
 #pragma once
 
 #include <algorithm>
+#include <map>
 
 template<typename K,typename V>
 class buildmap
 {
 public:
-  buildmap(const K &key,
-           const V &val)
+  buildmap(const K &key_,
+           const V &val_)
   {
-    _map.insert(std::make_pair(key,val));
+    _map.insert(std::make_pair(key_,val_));
   }
 
-  buildmap<K,V> &operator()(const K &key,
-                            const V &val)
+  buildmap<K,V> &operator()(const K &key_,
+                            const V &val_)
   {
-    _map.insert(std::make_pair(key,val));
+    _map.insert(std::make_pair(key_,val_));
     return *this;
   }
 

src/buildvector.hpp

@@ -23,14 +23,14 @@ template<typename V, bool SORT = false>
 class buildvector
 {
 public:
-  buildvector(const V &val)
+  buildvector(const V &val_)
   {
-    _vector.push_back(val);
+    _vector.push_back(val_);
   }
 
-  buildvector<V,SORT> &operator()(const V &val)
+  buildvector<V,SORT> &operator()(const V &val_)
   {
-    _vector.push_back(val);
+    _vector.push_back(val_);
     return *this;
   }
 

src/category.cpp

@@ -1,59 +0,0 @@
-/*
-  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.
-*/
-
-#include <string>
-#include <vector>
-
-#include "category.hpp"
-#include "buildvector.hpp"
-
-#define CATEGORY(X) Category(Category::Enum::X,#X)
-
-const std::vector<Category> Category::_categories_ =
-  buildvector<Category,true>
-  (CATEGORY(invalid))
-  (CATEGORY(action))
-  (CATEGORY(create))
-  (CATEGORY(search));
-
-const Category * const Category::categories = &_categories_[1];
-
-const Category &Category::invalid = Category::categories[Category::Enum::invalid];
-const Category &Category::action  = Category::categories[Category::Enum::action];
-const Category &Category::create  = Category::categories[Category::Enum::create];
-const Category &Category::search  = Category::categories[Category::Enum::search];
-
-const Category&
-Category::find(const std::string &str)
-{
-  for(int i = Enum::BEGIN; i != Enum::END; ++i)
-    {
-      if(categories[i] == str)
-        return categories[i];
-    }
-
-  return invalid;
-}
-
-const Category&
-Category::find(const Category::Enum::Type i)
-{
-  if(i >= Category::Enum::BEGIN &&
-     i  < Category::Enum::END)
-    return categories[i];
-
-  return invalid;
-}

src/category.hpp

@@ -16,69 +16,9 @@
 
 #pragma once
 
-#include <string>
-#include <vector>
-
-class Category
-{
-public:
-  struct Enum
+enum class Category
   {
-    enum Type
-      {
-        invalid = -1,
-        BEGIN   = 0,
-        action  = BEGIN,
-        create,
-        search,
-        END
-      };
+    ACTION,
+    CREATE,
+    SEARCH
   };
-
-private:
-  Enum::Type  _enum;
-  std::string _str;
-
-public:
-  Category()
-    : _enum(invalid),
-      _str(invalid)
-  {
-  }
-
-  Category(const Enum::Type   enum_,
-           const std::string &str_)
-    : _enum(enum_),
-      _str(str_)
-  {
-  }
-
-public:
-  operator const Enum::Type() const { return _enum; }
-  operator const std::string&() const { return _str; }
-  operator const Category*() const { return this; }
-
-  bool operator==(const std::string &str_) const
-  { return _str == str_; }
-
-  bool operator==(const Enum::Type enum_) const
-  { return _enum == enum_; }
-
-  bool operator!=(const Category &r) const
-  { return _enum != r._enum; }
-
-  bool operator<(const Category &r) const
-  { return _enum < r._enum; }
-
-public:
-  static const Category &find(const std::string&);
-  static const Category &find(const Enum::Type);
-
-public:
-  static const std::vector<Category>  _categories_;
-  static const Category * const       categories;
-  static const Category              &invalid;
-  static const Category              &action;
-  static const Category              &create;
-  static const Category              &search;
-};

src/config.cpp

@@ -15,109 +15,261 @@
 */
 
 #include "config.hpp"
+#include "ef.hpp"
 #include "errno.hpp"
-#include "fs.hpp"
+#include "from_string.hpp"
+#include "num.hpp"
 #include "rwlock.hpp"
+#include "to_string.hpp"
+#include "version.hpp"
 
-#include <unistd.h>
-#include <sys/stat.h>
-
+#include <algorithm>
 #include <string>
-#include <vector>
+#include <iostream>
+
+#include <stdint.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 #define MINFREESPACE_DEFAULT (4294967295ULL)
-#define POLICYINIT(X) X(policies[FuseFunc::Enum::X])
 
 using std::string;
-using std::vector;
+
+#define IFERT(S) if(S == s_) return true
+
+namespace l
+{
+  static
+  bool
+  readonly(const std::string &s_)
+  {
+    IFERT("async_read");
+    IFERT("cache.symlinks");
+    IFERT("cache.writeback");
+    IFERT("fsname");
+    IFERT("fuse_msg_size");
+    IFERT("mount");
+    IFERT("nullrw");
+    IFERT("pid");
+    IFERT("readdirplus");
+    IFERT("threads");
+    IFERT("version");
+
+    return false;
+  }
+}
 
 Config::Config()
-  : destmount(),
-    branches(),
-    branches_lock(),
-    minfreespace(MINFREESPACE_DEFAULT),
-    moveonenospc(false),
-    direct_io(false),
-    dropcacheonclose(false),
-    symlinkify(false),
-    symlinkify_timeout(3600),
-    nullrw(false),
-    ignorepponrename(false),
-    security_capability(true),
-    link_cow(false),
-    xattr(0),
-    statfs(StatFS::BASE),
-    statfs_ignore(StatFSIgnore::NONE),
-    posix_acl(false),
-    POLICYINIT(access),
-    POLICYINIT(chmod),
-    POLICYINIT(chown),
-    POLICYINIT(create),
-    POLICYINIT(getattr),
-    POLICYINIT(getxattr),
-    POLICYINIT(link),
-    POLICYINIT(listxattr),
-    POLICYINIT(mkdir),
-    POLICYINIT(mknod),
-    POLICYINIT(open),
-    POLICYINIT(readlink),
-    POLICYINIT(removexattr),
-    POLICYINIT(rename),
-    POLICYINIT(rmdir),
-    POLICYINIT(setxattr),
-    POLICYINIT(symlink),
-    POLICYINIT(truncate),
-    POLICYINIT(unlink),
-    POLICYINIT(utimens),
-    controlfile("/.mergerfs")
-{
-  pthread_rwlock_init(&branches_lock,NULL);
+  :
+  open_cache(),
 
-  set_category_policy("action","epall");
-  set_category_policy("create","epmfs");
-  set_category_policy("search","ff");
+  controlfile("/.mergerfs"),
+
+  async_read(true),
+  auto_cache(false),
+  branches(minfreespace),
+  cache_attr(1),
+  cache_entry(1),
+  cache_files(CacheFiles::ENUM::LIBFUSE),
+  cache_negative_entry(0),
+  cache_readdir(false),
+  cache_statfs(0),
+  cache_symlinks(false),
+  category(func),
+  direct_io(false),
+  dropcacheonclose(false),
+  fsname(),
+  func(),
+  fuse_msg_size(FUSE_MAX_MAX_PAGES),
+  ignorepponrename(false),
+  inodecalc("hybrid-hash"),
+  link_cow(false),
+  minfreespace(MINFREESPACE_DEFAULT),
+  mount(),
+  moveonenospc(false),
+  nfsopenhack(NFSOpenHack::ENUM::OFF),
+  nullrw(false),
+  pid(::getpid()),
+  posix_acl(false),
+  readdir(ReadDir::ENUM::POSIX),
+  readdirplus(false),
+  security_capability(true),
+  srcmounts(branches),
+  statfs(StatFS::ENUM::BASE),
+  statfs_ignore(StatFSIgnore::ENUM::NONE),
+  symlinkify(false),
+  symlinkify_timeout(3600),
+  threads(0),
+  version(MERGERFS_VERSION),
+  writeback_cache(false),
+  xattr(XAttr::ENUM::PASSTHROUGH)
+{
+  _map["async_read"]           = &async_read;
+  _map["auto_cache"]           = &auto_cache;
+  _map["branches"]             = &branches;
+  _map["cache.attr"]           = &cache_attr;
+  _map["cache.entry"]          = &cache_entry;
+  _map["cache.files"]          = &cache_files;
+  _map["cache.negative_entry"] = &cache_negative_entry;
+  _map["cache.readdir"]        = &cache_readdir;
+  _map["cache.statfs"]         = &cache_statfs;
+  _map["cache.symlinks"]       = &cache_symlinks;
+  _map["cache.writeback"]      = &writeback_cache;
+  _map["category.action"]      = &category.action;
+  _map["category.create"]      = &category.create;
+  _map["category.search"]      = &category.search;
+  _map["direct_io"]            = &direct_io;
+  _map["dropcacheonclose"]     = &dropcacheonclose;
+  _map["fsname"]               = &fsname;
+  _map["func.access"]          = &func.access;
+  _map["func.chmod"]           = &func.chmod;
+  _map["func.chown"]           = &func.chown;
+  _map["func.create"]          = &func.create;
+  _map["func.getattr"]         = &func.getattr;
+  _map["func.getxattr"]        = &func.getxattr;
+  _map["func.link"]            = &func.link;
+  _map["func.listxattr"]       = &func.listxattr;
+  _map["func.mkdir"]           = &func.mkdir;
+  _map["func.mknod"]           = &func.mknod;
+  _map["func.open"]            = &func.open;
+  _map["func.readlink"]        = &func.readlink;
+  _map["func.removexattr"]     = &func.removexattr;
+  _map["func.rename"]          = &func.rename;
+  _map["func.rmdir"]           = &func.rmdir;
+  _map["func.setxattr"]        = &func.setxattr;
+  _map["func.symlink"]         = &func.symlink;
+  _map["func.truncate"]        = &func.truncate;
+  _map["func.unlink"]          = &func.unlink;
+  _map["func.utimens"]         = &func.utimens;
+  _map["fuse_msg_size"]        = &fuse_msg_size;
+  _map["ignorepponrename"]     = &ignorepponrename;
+  _map["inodecalc"]            = &inodecalc;
+  _map["kernel_cache"]         = &kernel_cache;
+  _map["link_cow"]             = &link_cow;
+  _map["minfreespace"]         = &minfreespace;
+  _map["mount"]                = &mount;
+  _map["moveonenospc"]         = &moveonenospc;
+  _map["nfsopenhack"]          = &nfsopenhack;
+  _map["nullrw"]               = &nullrw;
+  _map["pid"]                  = &pid;
+  _map["posix_acl"]            = &posix_acl;
+  //  _map["readdir"]              = &readdir;
+  _map["readdirplus"]          = &readdirplus;
+  _map["security_capability"]  = &security_capability;
+  _map["srcmounts"]            = &srcmounts;
+  _map["statfs"]               = &statfs;
+  _map["statfs_ignore"]        = &statfs_ignore;
+  _map["symlinkify"]           = &symlinkify;
+  _map["symlinkify_timeout"]   = &symlinkify_timeout;
+  _map["threads"]              = &threads;
+  _map["version"]              = &version;
+  _map["xattr"]                = &xattr;
 }
 
-int
-Config::set_func_policy(const string &fusefunc_,
-                        const string &policy_)
+const
+Config&
+Config::ro(void)
 {
-  const Policy   *policy;
-  const FuseFunc *fusefunc;
-
-  fusefunc = FuseFunc::find(fusefunc_);
-  if(fusefunc == FuseFunc::invalid)
-    return (errno=ENODATA,-1);
-
-  policy = Policy::find(policy_);
-  if(policy == Policy::invalid)
-    return (errno=EINVAL,-1);
-
-  policies[(FuseFunc::Enum::Type)*fusefunc] = policy;
-
-  return 0;
+  return *((Config*)fuse_get_context()->private_data);
 }
 
-int
-Config::set_category_policy(const string &category_,
-                            const string &policy_)
+Config&
+Config::rw(void)
 {
-  const Policy   *policy;
-  const Category *category;
+  return *((Config*)fuse_get_context()->private_data);
+}
 
-  category = Category::find(category_);
-  if(category == Category::invalid)
-    return (errno=ENODATA,-1);
+bool
+Config::has_key(const std::string &key_) const
+{
+  return _map.count(key_);
+}
 
-  policy = Policy::find(policy_);
-  if(policy == Policy::invalid)
-    return (errno=EINVAL,-1);
+void
+Config::keys(std::string &s_) const
+{
+  Str2TFStrMap::const_iterator i;
+  Str2TFStrMap::const_iterator ei;
 
-  for(int i = 0; i < FuseFunc::Enum::END; i++)
+  s_.reserve(512);
+
+  i  = _map.begin();
+  ei = _map.end();
+
+  for(; i != ei; ++i)
     {
-      if(FuseFunc::fusefuncs[i] == (Category::Enum::Type)*category)
-        policies[(FuseFunc::Enum::Type)FuseFunc::fusefuncs[i]] = policy;
+      s_ += i->first;
+      s_ += '\0';
     }
 
+  s_.resize(s_.size() - 1);
+}
+
+
+void
+Config::keys_xattr(std::string &s_) const
+{
+  Str2TFStrMap::const_iterator i;
+  Str2TFStrMap::const_iterator ei;
+
+  s_.reserve(1024);
+  for(i = _map.begin(), ei = _map.end(); i != ei; ++i)
+    {
+      s_ += "user.mergerfs.";
+      s_ += i->first;
+      s_ += '\0';
+    }
+}
+
+int
+Config::get(const std::string &key_,
+            std::string       *val_) const
+{
+  Str2TFStrMap::const_iterator i;
+
+  i = _map.find(key_);
+  if(i == _map.end())
+    return -ENOATTR;
+
+  *val_ = i->second->to_string();
+
   return 0;
 }
+
+int
+Config::set_raw(const std::string &key_,
+                const std::string &value_)
+{
+  Str2TFStrMap::iterator i;
+
+  i = _map.find(key_);
+  if(i == _map.end())
+    return -ENOATTR;
+
+  return i->second->from_string(value_);
+}
+
+int
+Config::set(const std::string &key_,
+            const std::string &value_)
+{
+  if(l::readonly(key_))
+    return -EINVAL;
+
+  return set_raw(key_,value_);
+}
+
+std::ostream&
+operator<<(std::ostream &os_,
+           const Config &c_)
+{
+  Str2TFStrMap::const_iterator i;
+  Str2TFStrMap::const_iterator ei;
+
+  for(i = c_._map.begin(), ei = c_._map.end(); i != ei; ++i)
+    {
+      os_ << i->first << '=' << i->second << '\n';
+    }
+
+  return os_;
+}

src/config.hpp

@@ -17,9 +17,21 @@
 #pragma once
 
 #include "branch.hpp"
-#include "fusefunc.hpp"
+#include "config_cachefiles.hpp"
+#include "config_inodecalc.hpp"
+#include "config_moveonenospc.hpp"
+#include "config_nfsopenhack.hpp"
+#include "config_readdir.hpp"
+#include "config_statfs.hpp"
+#include "config_statfsignore.hpp"
+#include "config_xattr.hpp"
+#include "enum.hpp"
+#include "errno.hpp"
+#include "func_category.hpp"
+#include "funcs.hpp"
 #include "policy.hpp"
 #include "policy_cache.hpp"
+#include "tofrom_wrapper.hpp"
 
 #include <fuse.h>
 
@@ -29,80 +41,17 @@
 #include <stdint.h>
 #include <sys/stat.h>
 
+typedef ToFromWrapper<bool>                 ConfigBOOL;
+typedef ToFromWrapper<uint64_t>             ConfigUINT64;
+typedef ToFromWrapper<int>                  ConfigINT;
+typedef ToFromWrapper<std::string>          ConfigSTR;
+typedef std::map<std::string,ToFromString*> Str2TFStrMap;
+
 class Config
 {
-public:
-  struct StatFS
-  {
-    enum Enum
-      {
-        BASE,
-        FULL
-      };
-  };
-
-  struct StatFSIgnore
-  {
-    enum Enum
-      {
-        NONE,
-        RO,
-        NC
-      };
-  };
-
 public:
   Config();
 
-public:
-  int set_func_policy(const std::string &fusefunc_,
-                      const std::string &policy_);
-  int set_category_policy(const std::string &category_,
-                          const std::string &policy_);
-
-public:
-  std::string              fsname;
-  std::string              destmount;
-  Branches                 branches;
-  mutable pthread_rwlock_t branches_lock;
-  uint64_t                 minfreespace;
-  bool                     moveonenospc;
-  bool                     direct_io;
-  bool                     dropcacheonclose;
-  bool                     symlinkify;
-  time_t                   symlinkify_timeout;
-  bool                     nullrw;
-  bool                     ignorepponrename;
-  bool                     security_capability;
-  bool                     link_cow;
-  int                      xattr;
-  StatFS::Enum             statfs;
-  StatFSIgnore::Enum       statfs_ignore;
-  bool                     posix_acl;
-
-public:
-  const Policy  *policies[FuseFunc::Enum::END];
-  const Policy *&access;
-  const Policy *&chmod;
-  const Policy *&chown;
-  const Policy *&create;
-  const Policy *&getattr;
-  const Policy *&getxattr;
-  const Policy *&link;
-  const Policy *&listxattr;
-  const Policy *&mkdir;
-  const Policy *&mknod;
-  const Policy *&open;
-  const Policy *&readlink;
-  const Policy *&removexattr;
-  const Policy *&rename;
-  const Policy *&rmdir;
-  const Policy *&setxattr;
-  const Policy *&symlink;
-  const Policy *&truncate;
-  const Policy *&unlink;
-  const Policy *&utimens;
-
 public:
   mutable PolicyCache open_cache;
 
@@ -110,27 +59,64 @@ public:
   const std::string controlfile;
 
 public:
-  static
-  const
-  Config &
-  get(void)
-  {
-    const fuse_context *fc = fuse_get_context();
+  ConfigBOOL     async_read;
+  ConfigBOOL     auto_cache;
+  Branches       branches;
+  ConfigUINT64   cache_attr;
+  ConfigUINT64   cache_entry;
+  CacheFiles     cache_files;
+  ConfigUINT64   cache_negative_entry;
+  ConfigBOOL     cache_readdir;
+  ConfigUINT64   cache_statfs;
+  ConfigBOOL     cache_symlinks;
+  FuncCategories category;
+  ConfigBOOL     direct_io;
+  ConfigBOOL     dropcacheonclose;
+  ConfigSTR      fsname;
+  Funcs          func;
+  ConfigUINT64   fuse_msg_size;
+  ConfigBOOL     ignorepponrename;
+  InodeCalc      inodecalc;
+  ConfigBOOL     kernel_cache;
+  ConfigBOOL     link_cow;
+  ConfigUINT64   minfreespace;
+  ConfigSTR      mount;
+  MoveOnENOSPC   moveonenospc;
+  NFSOpenHack    nfsopenhack;
+  ConfigBOOL     nullrw;
+  ConfigUINT64   pid;
+  ConfigBOOL     posix_acl;
+  ReadDir        readdir;
+  ConfigBOOL     readdirplus;
+  ConfigBOOL     security_capability;
+  SrcMounts      srcmounts;
+  StatFS         statfs;
+  StatFSIgnore   statfs_ignore;
+  ConfigBOOL     symlinkify;
+  ConfigUINT64   symlinkify_timeout;
+  ConfigINT      threads;
+  ConfigSTR      version;
+  ConfigBOOL     writeback_cache;
+  XAttr          xattr;
 
-    return get(fc);
-  }
+public:
+  friend std::ostream& operator<<(std::ostream &s,
+                                  const Config &c);
 
-  static
-  const Config &
-  get(const fuse_context *fc)
-  {
-    return *((Config*)fc->private_data);
-  }
+public:
+  bool has_key(const std::string &key) const;
+  void keys(std::string &s) const;
+  void keys_xattr(std::string &s) const;
 
-  static
-  Config &
-  get_writable(void)
-  {
-    return (*((Config*)fuse_get_context()->private_data));
-  }
+public:
+  int get(const std::string &key, std::string *val) const;
+  int set_raw(const std::string &key, const std::string &val);
+  int set(const std::string &key, const std::string &val);
+
+public:
+  static const Config &ro(void);
+  static Config       &rw(void);
+
+private:
+  Str2TFStrMap _map;
 };

src/config_cachefiles.cpp

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

src/config_cachefiles.hpp

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

src/config_inodecalc.cpp

@@ -0,0 +1,37 @@
+/*
+  ISC License
+
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "config_inodecalc.hpp"
+#include "fs_inode.hpp"
+
+InodeCalc::InodeCalc(const std::string &s_)
+{
+  fs::inode::set_algo(s_);
+}
+
+std::string
+InodeCalc::to_string(void) const
+{
+  return fs::inode::get_algo();
+}
+
+int
+InodeCalc::from_string(const std::string &s_)
+{
+  return fs::inode::set_algo(s_);
+}

src/config_inodecalc.hpp

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

src/config_moveonenospc.cpp

@@ -0,0 +1,55 @@
+/*
+  ISC License
+
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "config_moveonenospc.hpp"
+#include "ef.hpp"
+#include "errno.hpp"
+#include "from_string.hpp"
+
+int
+MoveOnENOSPC::from_string(const std::string &s_)
+{
+  int rv;
+  std::string s;
+  const Policy *tmp;
+
+  rv = str::from(s_,&enabled);
+  if((rv == 0) && (enabled == true))
+    s = "mfs";
+  ef(rv != 0)
+    s = s_;
+  else
+    return 0;
+
+  tmp = &Policy::find(s);
+  if(tmp == Policy::invalid)
+    return -EINVAL;
+
+  policy  = tmp;
+  enabled = true;
+
+  return 0;
+}
+
+std::string
+MoveOnENOSPC::to_string(void) const
+{
+  if(enabled)
+    return policy->to_string();
+  return "false";
+}

src/config_moveonenospc.hpp

@@ -0,0 +1,44 @@
+/*
+  ISC License
+
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "policy.hpp"
+#include "tofrom_string.hpp"
+
+#include <string>
+
+class MoveOnENOSPC : public ToFromString
+{
+public:
+  MoveOnENOSPC(const bool enabled_)
+    : enabled(enabled_)
+  {
+    policy = (enabled ?
+              &Policy::mfs :
+              &Policy::invalid);
+  }
+
+public:
+  int from_string(const std::string &s);
+  std::string to_string() const;
+
+public:
+  bool enabled;
+  const Policy *policy;
+};

src/config_nfsopenhack.cpp

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

src/config_nfsopenhack.hpp

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

src/config_readdir.cpp

@@ -0,0 +1,50 @@
+/*
+  ISC License
+
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "config_readdir.hpp"
+#include "ef.hpp"
+#include "errno.hpp"
+
+template<>
+int
+ReadDir::from_string(const std::string &s_)
+{
+  if(s_ == "posix")
+    _data = ReadDir::ENUM::POSIX;
+  ef(s_ == "linux")
+    _data = ReadDir::ENUM::LINUX;
+  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_readdir.hpp

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

src/config_statfs.cpp

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

src/config_statfs.hpp

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

src/config_statfsignore.cpp

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

src/config_statfsignore.hpp

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

src/config_xattr.cpp

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

src/config_xattr.hpp

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

src/dirinfo.hpp

@@ -16,16 +16,15 @@
 
 #pragma once
 
+#include "fh.hpp"
+
 #include <string>
 
-class DirInfo
+class DirInfo : public FH
 {
 public:
   DirInfo(const char *fusepath_)
-    : fusepath(fusepath_)
+    : FH(fusepath_)
   {
   }
-
-public:
-  std::string fusepath;
 };

src/ef.hpp

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

src/enum.hpp

@@ -0,0 +1,80 @@
+/*
+  ISC License
+
+  Copyright (c) 2019, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include "tofrom_string.hpp"
+
+#include <string>
+
+template<typename E>
+class Enum : public ToFromString
+{
+public:
+  typedef E ENUM;
+
+public:
+  Enum<ENUM>()
+  {
+  }
+
+  Enum<ENUM>(const ENUM data_)
+    : _data(data_)
+  {
+  }
+
+public:
+  Enum<ENUM>&
+  operator=(const ENUM data_)
+  {
+    _data = data_;
+    return *this;
+  }
+
+  Enum<ENUM>&
+  operator=(const std::string &s_)
+  {
+    from_string(s_);
+    return *this;
+  }
+
+public:
+  operator ENUM() const
+  {
+    return _data;
+  }
+
+public:
+  bool operator==(const ENUM data_) const
+  {
+    return (_data == data_);
+  }
+
+public:
+  std::string to_string() const;
+  int from_string(const std::string &);
+
+public:
+  int to_int() const
+  {
+    return (int)_data;
+  }
+
+private:
+  ENUM _data;
+};

src/fasthash.cpp

@@ -1,84 +0,0 @@
-/* The MIT License
-
-   Copyright (C) 2012 Zilong Tan (eric.zltan@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.
-*/
-
-#include "fasthash.h"
-
-// Compression function for Merkle-Damgard construction.
-// This function is generated using the framework provided.
-#define mix(h) ({                               \
-      (h) ^= (h) >> 23;                         \
-      (h) *= 0x2127599bf4325c37ULL;             \
-      (h) ^= (h) >> 47; })
-
-uint64_t
-fasthash64(const void *buf,
-           size_t      len,
-           uint64_t    seed)
-{
-  const uint64_t    m = 0x880355f21e6d1965ULL;
-  const uint64_t *pos = (const uint64_t *)buf;
-  const uint64_t *end = pos + (len / 8);
-  const unsigned char *pos2;
-  uint64_t h = seed ^ (len * m);
-  uint64_t v;
-
-  while (pos != end) {
-    v  = *pos++;
-    h ^= mix(v);
-    h *= m;
-  }
-
-  pos2 = (const unsigned char*)pos;
-  v = 0;
-
-  switch (len & 7) {
-  case 7: v ^= (uint64_t)pos2[6] << 48;
-  case 6: v ^= (uint64_t)pos2[5] << 40;
-  case 5: v ^= (uint64_t)pos2[4] << 32;
-  case 4: v ^= (uint64_t)pos2[3] << 24;
-  case 3: v ^= (uint64_t)pos2[2] << 16;
-  case 2: v ^= (uint64_t)pos2[1] << 8;
-  case 1: v ^= (uint64_t)pos2[0];
-    h ^= mix(v);
-    h *= m;
-  }
-
-  return mix(h);
-}
-
-uint32_t
-fasthash32(const void *buf,
-           size_t      len,
-           uint32_t    seed)
-{
-  // the following trick converts the 64-bit hashcode to Fermat
-  // residue, which shall retain information from both the higher
-  // and lower parts of hashcode.
-  uint64_t h;
-
-  h = fasthash64(buf, len, seed);
-
-  return (h - (h >> 32));
-}

src/fasthash.h

@@ -1,56 +0,0 @@
-/* The MIT License
-
-   Copyright (C) 2012 Zilong Tan (eric.zltan@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 _FASTHASH_H
-#define _FASTHASH_H
-
-#include <stdint.h>
-#include <stdio.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-  /**
-   * fasthash32 - 32-bit implementation of fasthash
-   * @buf:  data buffer
-   * @len:  data size
-   * @seed: the seed
-   */
-  uint32_t fasthash32(const void *buf, size_t len, uint32_t seed);
-
-  /**
-   * fasthash64 - 64-bit implementation of fasthash
-   * @buf:  data buffer
-   * @len:  data size
-   * @seed: the seed
-   */
-  uint64_t fasthash64(const void *buf, size_t len, uint64_t seed);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

src/fh.hpp

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

src/fileinfo.hpp

@@ -16,19 +16,20 @@
 
 #pragma once
 
+#include "fh.hpp"
+
 #include <string>
 
-class FileInfo
+class FileInfo : public FH
 {
 public:
   FileInfo(const int   fd_,
            const char *fusepath_)
-    : fd(fd_),
-      fusepath(fusepath_)
+    : FH(fusepath_),
+      fd(fd_)
   {
   }
 
 public:
   int fd;
-  std::string fusepath;
 };

src/fixed_mem_pool.hpp

@@ -0,0 +1,87 @@
+/*
+  ISC License
+
+  Copyright (c) 2020, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#pragma once
+
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef struct fixed_mem_pool_t fixed_mem_pool_t;
+struct fixed_mem_pool_t
+{
+  fixed_mem_pool_t *next;
+};
+
+template<uint64_t SIZE>
+class FixedMemPool
+{
+public:
+  FixedMemPool()
+  {
+    list.next = NULL;
+  }
+
+  ~FixedMemPool()
+  {
+    void *mem;
+    while(!empty())
+      {
+        mem = alloc();
+        ::free(mem);
+      }
+  }
+
+  bool
+  empty(void)
+  {
+    return (list.next == NULL);
+  }
+
+  uint64_t
+  size(void)
+  {
+    return SIZE;
+  }
+
+  void*
+  alloc(void)
+  {
+    void *rv;
+
+    if(list.next == NULL)
+      return malloc(SIZE);
+
+    rv = (void*)list.next;
+    list.next = list.next->next;
+
+    return rv;
+  }
+
+  void
+  free(void *mem_)
+  {
+    fixed_mem_pool_t *next;
+
+    next = (fixed_mem_pool_t*)mem_;
+    next->next = list.next;
+    list.next = next;
+  }
+
+private:
+  fixed_mem_pool_t list;
+};

src/from_string.cpp

@@ -0,0 +1,115 @@
+/*
+  ISC License
+
+  Copyright (c) 2019, Antonio SJ Musumeci <trapexit@spawn.link>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "ef.hpp"
+
+#include <string>
+
+#include <errno.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+namespace str
+{
+  int
+  from(const std::string &value_,
+       bool              *bool_)
+  {
+    if((value_ == "true") ||
+       (value_ == "1")    ||
+       (value_ == "on")   ||
+       (value_ == "yes"))
+      *bool_ = true;
+    ef((value_ == "false") ||
+       (value_ == "0")     ||
+       (value_ == "off")   ||
+       (value_ == "no"))
+      *bool_ = false;
+    else
+      return -EINVAL;
+
+    return 0;
+  }
+
+  int
+  from(const std::string &value_,
+       int               *int_)
+  {
+    *int_ = ::strtol(value_.c_str(),NULL,10);
+
+    return 0;
+  }
+
+  int
+  from(const std::string &value_,
+       uint64_t          *uint64_)
+  {
+    char *endptr;
+    uint64_t tmp;
+
+    tmp = ::strtoll(value_.c_str(),&endptr,10);
+    switch(*endptr)
+      {
+      case 'k':
+      case 'K':
+        tmp *= 1024ULL;
+        break;
+
+      case 'm':
+      case 'M':
+        tmp *= (1024ULL * 1024ULL);
+        break;
+
+      case 'g':
+      case 'G':
+        tmp *= (1024ULL * 1024ULL * 1024ULL);
+        break;
+
+      case 't':
+      case 'T':
+        tmp *= (1024ULL * 1024ULL * 1024ULL * 1024ULL);
+        break;
+
+      case '\0':
+        break;
+
+      default:
+        return -EINVAL;
+      }
+
+    *uint64_ = tmp;
+
+    return 0;
+  }
+
+  int
+  from(const std::string &value_,
+       std::string       *str_)
+  {
+    *str_ = value_;
+
+    return 0;
+  }
+
+  int
+  from(const std::string &value_,
+       const std::string *key_)
+  {
+    return -EINVAL;
+  }
+}

src/from_string.hpp

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

src/fs.cpp

@@ -1,156 +0,0 @@
-/*
-  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.
-*/
-
-#include <string>
-#include <vector>
-
-#include <fcntl.h>
-#include <limits.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#include "errno.hpp"
-#include "fs_attr.hpp"
-#include "fs_base_realpath.hpp"
-#include "fs_base_stat.hpp"
-#include "fs_exists.hpp"
-#include "fs_path.hpp"
-#include "fs_statvfs_cache.hpp"
-#include "fs_xattr.hpp"
-#include "str.hpp"
-
-using std::string;
-using std::vector;
-
-namespace fs
-{
-  void
-  findallfiles(const vector<string> &basepaths,
-               const char           *fusepath,
-               vector<string>       &paths)
-  {
-    string fullpath;
-
-    for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
-      {
-        fullpath = fs::path::make(basepaths[i],fusepath);
-
-        if(!fs::exists(fullpath))
-          continue;
-
-        paths.push_back(fullpath);
-      }
-  }
-
-  int
-  findonfs(const vector<string> &basepaths,
-           const string         &fusepath,
-           const int             fd,
-           string               &basepath)
-  {
-    int rv;
-    dev_t dev;
-    string fullpath;
-    struct stat st;
-
-    rv = fs::fstat(fd,&st);
-    if(rv == -1)
-      return -1;
-
-    dev = st.st_dev;
-    for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
-      {
-        fullpath = fs::path::make(basepaths[i],fusepath);
-
-        rv = fs::lstat(fullpath,&st);
-        if(rv == -1)
-          continue;
-
-        if(st.st_dev != dev)
-          continue;
-
-        basepath = basepaths[i];
-
-        return 0;
-      }
-
-    return (errno=ENOENT,-1);
-  }
-
-  void
-  realpathize(vector<string> &strs)
-  {
-    char *rv;
-
-    for(size_t i = 0; i < strs.size(); i++)
-      {
-        rv = fs::realpath(strs[i]);
-        if(rv == NULL)
-          continue;
-
-        strs[i] = rv;
-
-        ::free(rv);
-      }
-  }
-
-  int
-  getfl(const int fd)
-  {
-    return ::fcntl(fd,F_GETFL,0);
-  }
-
-  int
-  setfl(const int    fd,
-        const mode_t mode)
-  {
-    return ::fcntl(fd,F_SETFL,mode);
-  }
-
-  int
-  mfs(const vector<string> &basepaths,
-      const uint64_t        minfreespace,
-      string               &path)
-  {
-    int rv;
-    uint64_t mfs;
-    uint64_t spaceavail;
-    const string *mfsbasepath;
-
-    mfs = 0;
-    mfsbasepath = NULL;
-    for(size_t i = 0, ei = basepaths.size(); i != ei; i++)
-      {
-        rv = fs::statvfs_cache_spaceavail(basepaths[i],&spaceavail);
-        if(rv == -1)
-          continue;
-        if(spaceavail < minfreespace)
-          continue;
-        if(spaceavail <= mfs)
-          continue;
-
-        mfs         = spaceavail;
-        mfsbasepath = &basepaths[i];
-      }
-
-    if(mfsbasepath == NULL)
-      return (errno=ENOENT,-1);
-
-    path = *mfsbasepath;
-
-    return 0;
-  }
-};