diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index d0e6215d..c68b003d 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -18,7 +18,7 @@ jobs:
       - name: Setup fuse
         run: |
           sudo apt-get update
-          sudo apt-get install fuse libfuse-dev
+          sudo apt-get install fuse3 libfuse3-dev
       - name: Maven build
         run: mvn -B verify -Plinux-amd64
       - uses: actions/upload-artifact@v2
diff --git a/.gitmodules b/.gitmodules
index c16f993b..3d1b5e73 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,7 +1,12 @@
-[submodule "libfuse"]
-	path = libfuse
+[submodule "libfuse2"]
+	path = libfuse2
 	url = https://github.com/libfuse/libfuse.git
-	branch = fuse-2_9_bugfix
+	branch = fuse_2_9_bugfix
+
+[submodule "libfuse3"]
+	path = libfuse3
+	url = https://github.com/libfuse/libfuse.git
+	branch = master
 
 [submodule "winfsp"]
 	path = winfsp
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index dbf56047..311f1cf1 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,5 +1,6 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <option name="FORMATTER_TAGS_ENABLED" value="true" />
     <JavaCodeStyleSettings>
       <option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="99" />
       <option name="NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND" value="5" />
diff --git a/.idea/runConfigurations/HelloWorldFileSystem__Windows_.xml b/.idea/runConfigurations/HelloWorldFileSystem__Windows_.xml
new file mode 100644
index 00000000..8489caff
--- /dev/null
+++ b/.idea/runConfigurations/HelloWorldFileSystem__Windows_.xml
@@ -0,0 +1,12 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="HelloWorldFileSystem (Windows)" type="Application" factoryName="Application" singleton="false">
+    <option name="ALTERNATIVE_JRE_PATH" value="17" />
+    <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.HelloWorldFileSystem" />
+    <module name="jfuse-examples" />
+    <option name="PROGRAM_PARAMETERS" value="Z:/" />
+    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=info --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.mac,org.cryptomator.jfuse.win.amd64 --enable-preview" />
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/PosixMirrorFileSystem.xml b/.idea/runConfigurations/PosixMirrorFileSystem.xml
index 4f943e0f..faa4eb5f 100644
--- a/.idea/runConfigurations/PosixMirrorFileSystem.xml
+++ b/.idea/runConfigurations/PosixMirrorFileSystem.xml
@@ -3,7 +3,7 @@
     <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.PosixMirrorFileSystem" />
     <module name="jfuse-examples" />
     <option name="PROGRAM_PARAMETERS" value="$USER_HOME$/Desktop/TMP /Volumes/foo" />
-    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.mac --enable-preview" />
+    <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=debug --enable-native-access=org.cryptomator.jfuse.linux.amd64,org.cryptomator.jfuse.linux.aarch64,org.cryptomator.jfuse.mac --enable-preview" />
     <extension name="coverage">
       <pattern>
         <option name="PATTERN" value="de.skymatic.fusepanama.examples.*" />
diff --git a/.idea/runConfigurations/RandomFileSystem.xml b/.idea/runConfigurations/RandomFileSystem.xml
new file mode 100644
index 00000000..5e0e8100
--- /dev/null
+++ b/.idea/runConfigurations/RandomFileSystem.xml
@@ -0,0 +1,16 @@
+<component name="ProjectRunConfigurationManager">
+  <configuration default="false" name="RandomFileSystem" type="Application" factoryName="Application" nameIsGenerated="true">
+    <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.examples.RandomFileSystem" />
+    <module name="jfuse-examples" />
+    <option name="VM_PARAMETERS" value="-Dorg.slf4j.simpleLogger.defaultLogLevel=debug" />
+    <extension name="coverage">
+      <pattern>
+        <option name="PATTERN" value="org.cryptomator.jfuse.examples.*" />
+        <option name="ENABLED" value="true" />
+      </pattern>
+    </extension>
+    <method v="2">
+      <option name="Make" enabled="true" />
+    </method>
+  </configuration>
+</component>
\ No newline at end of file
diff --git a/.idea/runConfigurations/HelloJnrFileSystem.xml b/.idea/runConfigurations/RandomJnrFileSystem.xml
similarity index 76%
rename from .idea/runConfigurations/HelloJnrFileSystem.xml
rename to .idea/runConfigurations/RandomJnrFileSystem.xml
index 0e5d0cf9..15e82fe9 100644
--- a/.idea/runConfigurations/HelloJnrFileSystem.xml
+++ b/.idea/runConfigurations/RandomJnrFileSystem.xml
@@ -1,6 +1,6 @@
 <component name="ProjectRunConfigurationManager">
-  <configuration default="false" name="HelloJnrFileSystem" type="Application" factoryName="Application" singleton="false" nameIsGenerated="true">
-    <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.tests.HelloJnrFileSystem" />
+  <configuration default="false" name="RandomJnrFileSystem" type="Application" factoryName="Application" singleton="false" nameIsGenerated="true">
+    <option name="MAIN_CLASS_NAME" value="org.cryptomator.jfuse.tests.RandomJnrFileSystem" />
     <module name="jfuse-tests" />
     <option name="VM_PARAMETERS" value="-Djava.library.path=/usr/local/lib -Dorg.slf4j.simpleLogger.defaultLogLevel=info" />
     <extension name="coverage">
diff --git a/README.md b/README.md
index e4b0b5b0..8ac882a3 100644
--- a/README.md
+++ b/README.md
@@ -9,58 +9,62 @@ Zero-Dependency Java bindings for FUSE using [JEP 424](https://openjdk.org/jeps/
 
 This is currently an experimental library requiring JDK 19. As long as the [Foreign Function & Memory API](https://openjdk.org/jeps/424) is incubating, the required JDK will increase.
 
-Currently, it only provides bindings for [libfuse 2.x](https://github.com/libfuse/libfuse/). Once stable, a new branch for libfuse 3.x will be added.
+We attempt to support libfuse 3.x on Linux and Windows while also remaining compatible with libfuse 2.x on macOS, leading to some compromises in the API.
+
+For libfuse 3 to ensure that the `readdir` operation runs in readdirplus mode, you have to add `FuseOperations.Operation.INIT` to the set returend by `FuseOperations::supportedOperations` method to the supported operations. An implementation of `init` is not necessary.
 
 ### Supported `fuse_operations`
 
-Not all `fuse_operations` are supported yet. 
-
-|        | Status |
-|--------|-------|
-| getattr | :white_check_mark: |
-| readlink | :white_check_mark: |
-| ~getdir~ | use readdir |
-| ~mknod~ | use create |
-| mkdir | :white_check_mark: |
-| unlink | :white_check_mark: |
-| rmdir | :white_check_mark: |
-| symlink | :white_check_mark: |
-| rename | :white_check_mark: |
-| link | :x: |
-| chmod | :white_check_mark: |
-| chown | :x: |
-| truncate | :white_check_mark: |
-| ~utime~ | use utimens |
-| open | :white_check_mark: |
-| read | :white_check_mark: |
-| write | :white_check_mark: |
-| statfs | :white_check_mark: |
-| flush | :x: |
-| release | :white_check_mark: |
-| fsync | :x: |
-| setxattr | :x: |
-| getxattr | :x: |
-| listxattr | :x: |
-| removexattr | :x: |
-| opendir | :white_check_mark: |
-| readdir | :white_check_mark: |
-| releasedir | :white_check_mark: |
-| fsyncdir | :x: |
-| init | :white_check_mark: |
-| destroy | :white_check_mark: |
-| access | :white_check_mark: |
-| create | :white_check_mark: |
-| ftruncate | :x: |
-| fgetattr | :x: |
-| lock | :x: |
-| utimens | :white_check_mark: |
-| bmap | :x: |
-| ioctl | :x: |
-| poll | :x: |
-| write_buf | :x: |
-| read_buf | :x: |
-| flock | :x: |
-| fallocate | :x: |
+Not all [`fuse_operations`](https://libfuse.github.io/doxygen/structfuse__operations.html) are supported yet. 
+
+|                 | Status                                  |
+|-----------------|-----------------------------------------|
+| getattr         | :white_check_mark:                      |
+| ~fgetattr~      | use getattr                             |
+| readlink        | :white_check_mark:                      |
+| ~getdir~        | use readdir                             |
+| ~mknod~         | use create                              |
+| mkdir           | :white_check_mark:                      |
+| unlink          | :white_check_mark:                      |
+| rmdir           | :white_check_mark:                      |
+| symlink         | :white_check_mark:                      |
+| rename          | :white_check_mark:                      |
+| link            | :x:                                     |
+| chmod           | :white_check_mark:                      |
+| chown           | :x:                                     |
+| truncate        | :white_check_mark:                      |
+| ~ftruncate~     | use truncate                            |
+| ~utime~         | use utimens                             |
+| open            | :white_check_mark:                      |
+| read            | :white_check_mark:                      |
+| write           | :white_check_mark:                      |
+| statfs          | :white_check_mark:                      |
+| flush           | :x:                                     |
+| release         | :white_check_mark:                      |
+| fsync           | :x:                                     |
+| setxattr        | :x:                                     |
+| getxattr        | :x:                                     |
+| listxattr       | :x:                                     |
+| removexattr     | :x:                                     |
+| opendir         | :white_check_mark:                      |
+| readdir         | :white_check_mark:                      |
+| releasedir      | :white_check_mark:                      |
+| fsyncdir        | :x:                                     |
+| init            | :white_check_mark:                      |
+| destroy         | :white_check_mark:                      |
+| access          | :white_check_mark: (ignored on Windows) |
+| create          | :white_check_mark:                      |
+| lock            | :x:                                     |
+| utimens         | :white_check_mark:                      |
+| bmap            | :x:                                     |
+| ioctl           | :x:                                     |
+| poll            | :x:                                     |
+| write_buf       | :x:                                     |
+| read_buf        | :x:                                     |
+| flock           | :x:                                     |
+| fallocate       | :x:                                     |
+| copy_file_range | :x:                                     |
+| lseek           | :x:                                     |
 
 ## Usage
 
@@ -70,9 +74,9 @@ Usage examples can be found under [`/jfuse-examples/`](jfuse-examples). You basi
 var builder = Fuse.builder();
 var fs = new MyFileSystem(builder.errno());
 try (var fuse = builder.build(fs)) {
-	int result = fuse.mount("my-awesome-fs", mountPoint);
-	// thread will now block until unmounted or failed
-}
+	fuse.mount("my-awesome-fs", mountPoint);
+	// wait as long as the mounted volume is in use
+} // closing will force-unmount (previous graceful unmount recommended)
 ```
 
 During runtime, you will need to add allow native access from platform-specific implementations via `--enable-native-access`, e.g.:
@@ -88,10 +92,10 @@ java -p path/to/mods \
 
 Due to slight differences in memory layout, each platform needs its own implementation. Currently, the following operating systems and architectures are supported:
 
-|        | Linux                                    | Mac (macFUSE) | Windows (WinFSP) |
-|--------|------------------------------------------|-----|---------|
-| x86_64 | [jfuse-linux-amd64](jfuse-linux-amd64)   | [jfuse-mac](jfuse-mac) | [jfuse-win-amd64](jfuse-win-amd64) |
-| arm64  | [jfuse-linux-aarch64](jfuse-linux-aarch64) | [jfuse-mac](jfuse-mac) |         |
+|        | Linux                                      | Mac (macFUSE)            | Windows (WinFSP)                     |
+|--------|--------------------------------------------|--------------------------|--------------------------------------|
+| x86_64 | [jfuse-linux-amd64](jfuse-linux-amd64)     | [jfuse-mac](jfuse-mac)   | [jfuse-win-amd64](jfuse-win-amd64)   |
+| arm64  | [jfuse-linux-aarch64](jfuse-linux-aarch64) | [jfuse-mac](jfuse-mac)   |                                      |
 
 ## Building
 
diff --git a/jfuse-api/pom.xml b/jfuse-api/pom.xml
index b0c142f0..3e9421cd 100644
--- a/jfuse-api/pom.xml
+++ b/jfuse-api/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>jfuse</artifactId>
-		<version>0.1.0</version>
+		<version>0.2.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jfuse-api</artifactId>
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Architecture.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Architecture.java
index 352e759f..ab4cc13a 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Architecture.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Architecture.java
@@ -6,9 +6,16 @@ public enum Architecture {
 	UNKNOWN;
 
 	private static final String OS_ARCH = System.getProperty("os.arch").toLowerCase();
-	public static final Architecture CURRENT = OS_ARCH.contains("x86_64") ? AMD64 //
-			: OS_ARCH.contains("amd64") ? AMD64 //
-			: OS_ARCH.contains("aarch64") ? ARM64 //
-			: UNKNOWN;
+	public static final Architecture CURRENT = getCurrent();
+
+	private static Architecture getCurrent() {
+		if (OS_ARCH.contains("x86_64") || OS_ARCH.contains("amd64")) {
+			return AMD64;
+		} else if (OS_ARCH.contains("aarch64")) {
+			return ARM64;
+		} else {
+			return UNKNOWN;
+		}
+	}
 }
 
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/DirFiller.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/DirFiller.java
index e66d9f8d..30294426 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/DirFiller.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/DirFiller.java
@@ -1,69 +1,58 @@
 package org.cryptomator.jfuse.api;
 
-import org.jetbrains.annotations.Nullable;
-
 import java.io.IOException;
-import java.util.stream.Stream;
+import java.util.function.Consumer;
 
 public interface DirFiller {
 
 	/**
-	 * Inserts a single item into the directory entry buffer.
-	 *
-	 * @param name   The file name
-	 * @param stat   Currently ignored, future use
-	 * @param offset The offset of the readdir-call plus the number of already filled entries
-	 * @return 0 if readdir should continue to fill in further items, non-zero otherwise (including errors)
-	 * @see <a href="https://libfuse.github.io/doxygen/structfuse__operations.html#adc01d3622754fc7de8e643249e73268d">official readdir docs</a>
-	 * @see <a href="https://www.cs.hmc.edu/~geoff/classes/hmc.cs135.201001/homework/fuse/fuse_doc.html#readdir-details">readdir explanation from Geoff Kuenning</a>
+	 * "Plus" mode: all file attributes are valid.
+	 * <p>
+	 * The attributes are used by the kernel to prefill the inode cache during a readdir.
+	 * <p>
+	 * It is okay to set FUSE_FILL_DIR_PLUS if {@link FuseOperations#FUSE_READDIR_PLUS FUSE_READDIR_PLUS} is not set
+	 * and vice versa.
 	 */
-	int fill(String name, @Nullable Stat stat, long offset);
+	int FUSE_FILL_DIR_PLUS = 1 << 1;
 
 	/**
-	 * Convenience wrapper for {@link #fill(String, Stat, long)}, ignoring the offset parameter.
+	 * Function to add an entry in a readdir() operation
+	 * <p>
+	 * The off parameter can be any non-zero value that enables the filesystem to identify the current point in the
+	 * directory stream. It does not need to be the actual physical position. A value of zero is reserved to indicate
+	 * that seeking in directories is not supported.
 	 *
-	 * @param name The file name
-	 * @param stat Currently ignored, future use.
-	 * @throws IOException If {@link #fill(String, Stat, long) fuse_fill_dir_t} returns 1, which indicates an error.
+	 * @param name   the file name of the directory entry
+	 * @param stat   file attributes, can be NULL
+	 * @param offset offset of the next entry or zero when ignoring the offset parameter
+	 * @param flags  fill flags, set to {@link #FUSE_FILL_DIR_PLUS} to cache stats
+	 * @return 1 if buffer is full or an error occured, zero otherwise
+	 * @see <a href="https://libfuse.github.io/doxygen/structfuse__operations.html#adc01d3622754fc7de8e643249e73268d">official readdir docs</a>
+	 * @see <a href="https://www.cs.hmc.edu/~geoff/classes/hmc.cs135.201001/homework/fuse/fuse_doc.html#readdir-details">readdir explanation from Geoff Kuenning</a>
 	 */
-	default void fill(String name, @Nullable Stat stat) throws IOException {
-		if (fill(name, stat, 0) != 0) {
-			throw new IOException("fuse_fill_dir_t unexpectedly returned 1");
-		}
-	}
+	int fill(String name, Consumer<Stat> stat, long offset, int flags);
 
 	/**
-	 * Convenience wrapper for {@link #fill(String, Stat, long)}, using the offset parameter.
-	 * <p>
-	 * <strong>Important:</strong> Note that the complete set of directors entries must contain <code>.</code> and <code>..</code>.
+	 * Convenience wrapper for {@link #fill(String, Consumer, long, int)}, ignoring the offset parameter.
 	 *
-	 * @param children A stream of directory entries offset by the given <code>offset</code>
-	 * @param offset   The offset of the stream (as requested by <code>readdir</code>)
+	 * @param name  The file name
+	 * @param stat  A method to pre-fill the stats of this node
+	 * @throws IOException If {@link #fill(String, Consumer, long, int) fuse_fill_dir_t} returns 1, which indicates an error.
 	 */
-	default void fillChildrenFromOffset(Stream<Child> children, long offset) {
-		var iterator = children.iterator();
-		for (long i = offset; iterator.hasNext(); i++) {
-			var child = iterator.next();
-			if (fill(child.name, child.stat, i + 1) != 0) {
-				return;
-			}
+	default void fill(String name, Consumer<Stat> stat) throws IOException {
+		if (fill(name, stat, 0, 0) != 0) {
+			throw new IOException("fuse_fill_dir_t unexpectedly returned 1");
 		}
 	}
 
 	/**
-	 * Convenience wrapper for {@link #fill(String, Stat, long)}, using the offset parameter.
-	 * <p>
-	 * <strong>Important:</strong> Note that the complete set of directors entries must contain <code>.</code> and <code>..</code>.
+	 * Convenienve wrapper for {@link #fill(String, Consumer, long, int)}, just filling in the name, ignoring stats.
 	 *
-	 * @param childNames A stream of the names of directory entries offset by the given <code>offset</code>
-	 * @param offset     The offset of the stream (as requested by <code>readdir</code>)
+	 * @param name The file name
+	 * @throws IOException If {@link #fill(String, Consumer, long, int) fuse_fill_dir_t} returns 1, which indicates an error.
 	 */
-	default void fillNamesFromOffset(Stream<String> childNames, long offset) {
-		var children = childNames.map(name -> new Child(name, null));
-		fillChildrenFromOffset(children, offset);
-	}
-
-	record Child(String name, @Nullable Stat stat) {
+	default void fill(String name) throws IOException {
+		fill(name, stat -> {});
 	}
 
 }
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FileModes.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FileModes.java
index a240af8f..39632b89 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FileModes.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FileModes.java
@@ -31,14 +31,14 @@ public static Set<PosixFilePermission> toPermissions(int mode) {
 	public static int fromPermissions(Set<PosixFilePermission> permissions) {
 		int mode = 0;
 		// @formatter:off
-		if (permissions.contains(PosixFilePermission.OWNER_READ)) mode |= 0400;
-		if (permissions.contains(PosixFilePermission.OWNER_WRITE)) mode |= 0200;
-		if (permissions.contains(PosixFilePermission.OWNER_EXECUTE)) mode |= 0100;
-		if (permissions.contains(PosixFilePermission.GROUP_READ)) mode |= 0040;
-		if (permissions.contains(PosixFilePermission.GROUP_WRITE)) mode |= 0020;
-		if (permissions.contains(PosixFilePermission.GROUP_EXECUTE)) mode |= 0010;
-		if (permissions.contains(PosixFilePermission.OTHERS_READ)) mode |= 0004;
-		if (permissions.contains(PosixFilePermission.OTHERS_WRITE)) mode |= 0002;
+		if (permissions.contains(PosixFilePermission.OWNER_READ))     mode |= 0400;
+		if (permissions.contains(PosixFilePermission.OWNER_WRITE))    mode |= 0200;
+		if (permissions.contains(PosixFilePermission.OWNER_EXECUTE))  mode |= 0100;
+		if (permissions.contains(PosixFilePermission.GROUP_READ))     mode |= 0040;
+		if (permissions.contains(PosixFilePermission.GROUP_WRITE))    mode |= 0020;
+		if (permissions.contains(PosixFilePermission.GROUP_EXECUTE))  mode |= 0010;
+		if (permissions.contains(PosixFilePermission.OTHERS_READ))    mode |= 0004;
+		if (permissions.contains(PosixFilePermission.OTHERS_WRITE))   mode |= 0002;
 		if (permissions.contains(PosixFilePermission.OTHERS_EXECUTE)) mode |= 0001;
 		// @formatter:on
 		return mode;
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Fuse.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Fuse.java
index 1cc7865f..b930b667 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Fuse.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Fuse.java
@@ -1,22 +1,21 @@
 package org.cryptomator.jfuse.api;
 
+
 import org.jetbrains.annotations.Blocking;
 import org.jetbrains.annotations.BlockingExecutor;
+import org.jetbrains.annotations.MustBeInvokedByOverriders;
 
-import java.lang.foreign.MemorySegment;
 import java.lang.foreign.MemorySession;
-import java.lang.foreign.ValueLayout;
 import java.nio.file.Path;
 import java.util.ArrayList;
 import java.util.List;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CompletionException;
-import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+
 
 /**
  * Represents a FUSE file system. Instances of this class are stateful and can not be reused.
@@ -26,8 +25,10 @@
  */
 public abstract class Fuse implements AutoCloseable {
 
+	private static final FuseMount UNMOUNTED = new UnmountedFuseMount();
+
 	protected final MemorySession fuseScope = MemorySession.openShared();
-	@BlockingExecutor
+	private final AtomicReference<FuseMount> mount = new AtomicReference<>(UNMOUNTED);
 	private final ExecutorService executor;
 
 	protected Fuse() {
@@ -51,65 +52,64 @@ public static FuseBuilder builder() {
 	 * @param progName   The program name used to construct a usage message and to derive a fallback for <code>-ofsname=...</code>
 	 * @param mountPoint mount point
 	 * @param flags      Additional flags. Use flag <code>-help</code> to get a list of available flags
-	 * @return 0 if mounted successfully, or the result of <code>fuse_main_real()</code> in case of errors
-	 * @throws CompletionException wrapping exceptions thrown during <code>init()</code> or <code>fuse_main_real()</code>
+	 * @throws MountFailedException If mounting failed
+	 * @throws IllegalArgumentException If providing unsupported mount flags
 	 */
-	public int mount(String progName, Path mountPoint, String... flags) throws CompletionException, TimeoutException {
+	@Blocking
+	@MustBeInvokedByOverriders
+	public void mount(String progName, Path mountPoint, String... flags) throws MountFailedException, IllegalArgumentException {
+		FuseMount lock = new UnmountedFuseMount();
+		if (!mount.compareAndSet(UNMOUNTED, lock)) {
+			throw new IllegalStateException("Already mounted");
+		}
+
 		List<String> args = new ArrayList<>();
 		args.add(progName);
-		args.add("-f"); // foreground mode required, so fuse_main_real() blocks
-		args.add(mountPoint.toString());
 		args.addAll(List.of(flags));
-		return mount(args);
-	}
+		args.add("-f"); // always stay in foreground. don't fork & kill this process via `fuse_daemonize`
+		args.add(mountPoint.toString());
 
-	protected int mount(List<String> args) throws TimeoutException {
-		// keep reference in field and cancel during close()?
-		var mountResult = CompletableFuture.supplyAsync(() -> fuseMain(args), executor);
 		try {
-			// fuseMain() will block (unless failing with return code != 0), therefore we need to wait for init()
-			// if any of these two completes, we know that mounting succeeded of failed.
-			var result = CompletableFuture.anyOf(mountResult, initialized()).get(10, TimeUnit.SECONDS);
-			if (result instanceof Integer i) {
-				return i;
-			} else {
-				throw new IllegalStateException("Expected Future<Integer>");
-			}
-		} catch (CancellationException | ExecutionException e) {
-			return 1;
-		} catch (InterruptedException e) {
-			Thread.currentThread().interrupt();
-			return 1;
+			var fuseMount = this.mount(args);
+			var isOnlySession = mount.compareAndSet(lock, fuseMount);
+			assert isOnlySession : "unreachable code, as no other method can set this.mount to lock";
+			executor.submit(this::fuseLoop); // TODO keep reference of future and report result
+		} finally {
+			mount.compareAndSet(lock, UNMOUNTED); // if value is still `lock`, mount has failed.
 		}
 	}
 
 	@Blocking
-	protected int fuseMain(List<String> flags) {
-		try (var scope = MemorySession.openConfined()) {
-			//var allocator =  SegmentAllocator.nativeAllocator(scope);
-			var argc = flags.size();
-			var argv = scope.allocateArray(ValueLayout.ADDRESS, argc);
-			for (int i = 0; i < argc; i++) {
-				var cString = scope.allocateUtf8String(flags.get(i));
-				argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
-			}
-			return fuseMain(argc, argv);
-		}
+	private int fuseLoop() {
+		AtomicInteger result = new AtomicInteger();
+		fuseScope.whileAlive(() -> {
+			var mount = this.mount.get();
+			result.set(mount.loop());
+		});
+		return result.get();
 	}
 
 	@Blocking
-	protected abstract int fuseMain(int argc, MemorySegment argv);
-
-	protected abstract CompletableFuture<Integer> initialized();
+	protected abstract FuseMount mount(List<String> args) throws MountFailedException, IllegalArgumentException;
 
+	/**
+	 * Unmounts (if needed) this fuse file system and frees up system resources.
+	 * <p>
+	 * <strong>Important:</strong> Before closing, a graceful unmount via system tools (e.g. {@code fusermount -u}) should be attempted.
+	 */
 	@Override
+	@Blocking
+	@MustBeInvokedByOverriders
 	public void close() throws TimeoutException {
 		try {
+			var fuseMount = this.mount.getAndSet(UNMOUNTED);
+			fuseMount.unmount();
 			executor.shutdown();
 			boolean exited = executor.awaitTermination(10, TimeUnit.SECONDS);
 			if (!exited) {
 				throw new TimeoutException("fuse main loop continued runn");
 			}
+			fuseMount.destroy();
 		} catch (InterruptedException e) {
 			Thread.currentThread().interrupt();
 		} finally {
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseConnInfo.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseConnInfo.java
index af9f1ec3..6253c565 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseConnInfo.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseConnInfo.java
@@ -1,8 +1,147 @@
 package org.cryptomator.jfuse.api;
 
+/**
+ * Fuse connection info struct used in {@link FuseOperations#init(FuseConnInfo)} method.
+ * <p>
+ * This struct is a union of the libfuse2 and libfuse3 definition. If an accessor method or macro is not supported by used libfuse version, it is documented in the javadoc.
+ * See also @code{fuse_common.h} of libfuse2 or 3.
+ */
 public interface FuseConnInfo {
 
+	@SuppressWarnings("PointlessBitwiseExpression")
+	int FUSE_CAP_ASYNC_READ = (1 << 0);
+	int FUSE_CAP_POSIX_LOCKS = (1 << 1);
+	int FUSE_CAP_ATOMIC_O_TRUNC = (1 << 3);
+	int FUSE_CAP_EXPORT_SUPPORT = (1 << 4);
+	/**
+	 * Libfuse2 only
+	 */
+	int FUSE_CAP_BIG_WRITES = (1 << 5);
+	int FUSE_CAP_DONT_MASK = (1 << 6);
+	int FUSE_CAP_SPLICE_WRITE = (1 << 7);
+	int FUSE_CAP_SPLICE_MOVE = (1 << 8);
+	int FUSE_CAP_SPLICE_READ = (1 << 9);
+	int FUSE_CAP_IOCTL_DIR = (1 << 11);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_AUTO_INVAL_DATA = (1 << 12);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_READDIRPLUS = (1 << 13);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_READDIRPLUS_AUTO = (1 << 14);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_ASYNC_DIO = (1 << 15);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_WRITEBACK_CACHE = (1 << 16);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_NO_OPEN_SUPPORT = (1 << 17);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_PARALLEL_DIROPS = (1 << 18);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_POSIX_ACL = (1 << 19);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_HANDLE_KILLPRIV = (1 << 20);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_CACHE_SYMLINKS = (1 << 23);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_NO_OPENDIR_SUPPORT = (1 << 24);
+	/**
+	 * Libfuse3 only
+	 */
+	int FUSE_CAP_EXPLICIT_INVAL_DATA = (1 << 25);
+
 	int protoMajor();
 
 	int protoMinor();
+
+	int capable();
+
+	int want();
+
+	void setWant(int wanted);
+
+	int maxWrite();
+
+	void setMaxWrite(int maxWrite);
+
+	/**
+	 * Libfuse3 only
+	 *
+	 * @return maxRead value of fuse_conn_info or 0 if not supported
+	 */
+	default int maxRead() {
+		return 0;
+	}
+
+	/**
+	 * Libfuse3 only
+	 */
+	default void setMaxRead(int maxRead) {
+		//no-op
+	}
+
+	int maxReadahead();
+
+	void setMaxReadahead(int maxReadahead);
+
+	int maxBackground();
+
+	void setMaxBackground(int maxBackground);
+
+	int congestionThreshold();
+
+	void setCongestionThreshold(int congestionThreshold);
+
+	/**
+	 * Libfuse3 only
+	 *
+	 * @return time_gran value of fuse_conn_info or 0 if not supported
+	 */
+	default int timeGran() {
+		return 0;
+	}
+
+	/**
+	 * Libfuse3 only
+	 */
+	default void setTimeGran(int timeGran) {
+		//no-op
+	}
+
+	/**
+	 * Libfuse2 only
+	 *
+	 * @return async_read value of fuse_conn_info or 0 if not supported
+	 */
+	default int asyncRead() {
+		return 0;
+	}
+
+	/**
+	 * Libfuse2 only
+	 */
+	default void setAsyncRead(int asyncRead) {
+		//no-op
+	}
 }
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseMount.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseMount.java
new file mode 100644
index 00000000..b3213ce8
--- /dev/null
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseMount.java
@@ -0,0 +1,29 @@
+package org.cryptomator.jfuse.api;
+
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.Blocking;
+
+@ApiStatus.Internal
+public interface FuseMount {
+
+	/**
+	 * Runs <code>fuse_loop</code> or <code>fuse_loop_mt</code>,
+	 * depending on the implementation and requested options.
+	 *
+	 * @return exit code returned by the <code>fuse_loop(_mt)</code>
+	 */
+	@Blocking
+	int loop();
+
+	/**
+	 * Perform actions required to stop the {@link #loop() run loop}, e.g. <code>fuse_exit</code>
+	 * and to unmount the volume, e.g. <code>fuse_unmount</code>.
+	 */
+	void unmount() ;
+
+	/**
+	 * Cleans up resources <em>after</em> the {@link #loop() run loop} exited.
+	 */
+	void destroy();
+
+}
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseOperations.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseOperations.java
index 463d388f..c4dcb4dd 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseOperations.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/FuseOperations.java
@@ -1,5 +1,7 @@
 package org.cryptomator.jfuse.api;
 
+import org.jetbrains.annotations.Nullable;
+
 import java.nio.ByteBuffer;
 import java.util.Set;
 
@@ -36,6 +38,16 @@ enum Operation {
 		WRITE
 	}
 
+	/**
+	 * "Plus" mode.
+	 * <p>
+	 * The kernel wants to prefill the inode cache during readdir. The filesystem may honour this by filling in the
+	 * attributes and setting {@link DirFiller#FUSE_FILL_DIR_PLUS FUSE_FILL_DIR_PLUS} for the filler function.
+	 * The filesystem may also just ignore this flag completely.
+	 */
+	@SuppressWarnings("PointlessBitwiseExpression")
+	int FUSE_READDIR_PLUS = 1 << 0;
+
 	/**
 	 * @return The error codes from <code>errno.h</code> for the current platform.
 	 * @see FuseBuilder#errno()
@@ -51,51 +63,62 @@ enum Operation {
 	 * Get file attributes.
 	 * <p>
 	 * Similar to stat().  The 'st_dev' and 'st_blksize' fields are
-	 * ignored.	 The 'st_ino' field is ignored except if the 'use_ino'
-	 * mount option is given.
+	 * ignored. The 'st_ino' field is ignored except if the 'use_ino'
+	 * mount option is given. In that case it is passed to userspace,
+	 * but libfuse and the kernel will still assign a different
+	 * inode for internal use (called the "nodeid").
+	 * <p>
+	 * This method doubles as <code>fgetattr</code> in libfuse2
+	 *
+	 * @param path file path
+	 * @param stat file information
+	 * @param fi   will always be <code>null</code> if the file is not currently open,
+	 *             but may also be <code>null</code> if the file is open.
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int getattr(String path, Stat stat) {
+	default int getattr(String path, Stat stat, @Nullable FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Read the target of a symbolic link
-	 * <p>
-	 * The buffer should be filled with a null terminated string.  The
-	 * buffer size argument includes the space for the terminating
-	 * null character.	If the linkname is too long to fit in the
-	 * buffer, it should be truncated.	The return value should be 0
-	 * for success.
+	 * Read the target of a symbolic link.
+	 *
+	 * @param path file path
+	 * @param buf  The buffer should be filled with a null terminated string.
+	 * @param len  The buffer size (including the terminating null character). If the linkname is too long to fit in the
+	 *             buffer, it should be truncated.
+	 * @return The return value should be 0
 	 */
 	default int readlink(String path, ByteBuffer buf, long len) {
 		return -errno().enosys();
 	}
 
-//	/**
-//	 * @deprecated use {@link #readdir(String, Pointer, Callback, long, Pointer)} instead
-//	 */
-//	@Deprecated
-//	default int getdir(String path, Pointer<fuse_h.fuse_dirhandle> fuse_dirhandlePointer, Callback<fuse_h.FI2> fi2Callback) {
-//		return -errno().enosys();
-//	}
-
 	/**
-	 * Create a file node
+	 * Create a file node.
 	 * <p>
 	 * This is called for creation of all non-directory, non-symlink
 	 * nodes.  If the filesystem defines a create() method, then for
 	 * regular files that will be called instead.
+	 *
+	 * @param path file path
+	 * @param mode file mode and type of node to create (using bitwise OR)
+	 * @param rdev ignored if mode does not contain <code>S_IFCHR</code> or <code>S_IFBLK</code>
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int mknod(String path, short mode, int rdev) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Create a directory
+	 * Create a directory.
 	 * <p>
 	 * Note that the mode argument may not have the type specification
 	 * bits set, i.e. S_ISDIR(mode) can be false.  To obtain the
 	 * correct directory type bits use  mode|S_IFDIR
+	 *
+	 * @param path file path
+	 * @param mode file mode (using bitwise OR)
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int mkdir(String path, int mode) {
 		return -errno().enosys();
@@ -103,6 +126,9 @@ default int mkdir(String path, int mode) {
 
 	/**
 	 * Remove a file
+	 *
+	 * @param path file path
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int unlink(String path) {
 		return -errno().enosys();
@@ -110,6 +136,9 @@ default int unlink(String path) {
 
 	/**
 	 * Remove a directory
+	 *
+	 * @param path file path
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int rmdir(String path) {
 		return -errno().enosys();
@@ -117,6 +146,10 @@ default int rmdir(String path) {
 
 	/**
 	 * Create a symbolic link
+	 *
+	 * @param linkname file path
+	 * @param target   content of the link
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int symlink(String linkname, String target) {
 		return -errno().enosys();
@@ -124,13 +157,28 @@ default int symlink(String linkname, String target) {
 
 	/**
 	 * Rename a file
+	 *
+	 * @param oldpath old file path
+	 * @param newpath new file path
+	 * @param flags   may be `RENAME_EXCHANGE` or `RENAME_NOREPLACE`. If
+	 *                RENAME_NOREPLACE is specified, the filesystem must not
+	 *                overwrite *newname* if it exists and return an error
+	 *                instead. If `RENAME_EXCHANGE` is specified, the filesystem
+	 *                must atomically exchange the two files, i.e. both must
+	 *                exist and neither may be deleted.
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int rename(String oldpath, String newpath) {
+	// TODO create enum for flags
+	default int rename(String oldpath, String newpath, int flags) {
 		return -errno().enosys();
 	}
 
 	/**
 	 * Create a hard link to a file
+	 *
+	 * @param linkname file path
+	 * @param target   content of the link
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int link(String linkname, String target) {
 		return -errno().enosys();
@@ -138,59 +186,89 @@ default int link(String linkname, String target) {
 
 	/**
 	 * Change the permission bits of a file
+	 *
+	 * @param path file path
+	 * @param mode file mode (using bitwise OR)
+	 * @param fi   will always be <code>null</code> if the file is not currently open,
+	 *             but may also be <code>null</code> if the file is open.
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int chmod(String path, int mode) {
+	default int chmod(String path, int mode, @Nullable FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
 	 * Change the owner and group of a file
+	 *
+	 * @param path file path
+	 * @param uid  user id
+	 * @param gid  group id
+	 * @param fi   will always be <code>null</code> if the file is not currently open,
+	 *             but may also be <code>null</code> if the file is open.
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int chown(String path, int uid, int gid) {
+	default int chown(String path, int uid, int gid, @Nullable FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Change the size of a file
+	 * Change the size of a file.
+	 * <p>
+	 * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+	 * expected to reset the setuid and setgid bits.
+	 * <p>
+	 * This method doubles as <code>ftruncate</code> in libfuse2
+	 *
+	 * @param path file path
+	 * @param size new size of the file
+	 * @param fi   will always be <code>null</code> if the file is not currently open,
+	 *             but may also be <code>null</code> if the file is open.
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int truncate(String path, long size) {
+	default int truncate(String path, long size, @Nullable FileInfo fi) {
 		return -errno().enosys();
 	}
 
-//	/**
-//	 * Change the access and/or modification times of a file
-//	 *
-//	 * @deprecated use {@link #utimens(String, TimeSpec) utimens()} instead.
-//	 */
-//	@Deprecated
-//	default int utime(String path, Pointer<utime_h.utimbuf> utimbufPointer) {
-//		return -errno().enosys();
-//	}
-
 	/**
-	 * File open operation
+	 * Open a file.
 	 * <p>
-	 * No creation (O_CREAT, O_EXCL) and by default also no
-	 * truncation (O_TRUNC) flags will be passed to open(). If an
-	 * application specifies O_TRUNC, fuse first calls truncate()
-	 * and then open(). Only if 'atomic_o_trunc' has been
-	 * specified and kernel version is 2.6.24 or later, O_TRUNC is
-	 * passed on to open.
+	 * Open flags are available in fi->flags. The following rules apply.
+	 * <ul>
+	 *     <li>Creation (O_CREAT, O_EXCL, O_NOCTTY) flags will be filtered out / handled by the kernel.</li>
+	 *     <li>Access modes (O_RDONLY, O_WRONLY, O_RDWR, O_EXEC, O_SEARCH) should be used by the filesystem to check if
+	 *     the operation is permitted.  If the ``-o default_permissions`` mount option is given, this check is already
+	 *     done by the kernel before calling open() and may thus be omitted by the filesystem.</li>
+	 * 	  <li>When writeback caching is enabled, the kernel may send read requests even for files opened with O_WRONLY.
+	 * 	  Thefilesystem should be prepared to handle this.</li>
+	 * 	  <li>When writeback caching is disabled, the filesystem is expected to properly handle the O_APPEND flag and
+	 * 	  ensurethat each write is appending to the end of the file.</li>
+	 * 	  <li>When writeback caching is enabled, the kernel will handle O_APPEND. However, unless all changes to the
+	 * 	  file come through the kernel this will not work reliably. The filesystem should thus either ignore the
+	 * 	  O_APPEND flag (and let the kernel handle it), or return an error (indicating that reliably O_APPEND is
+	 * 	  not available).</li>
+	 * </ul>
+	 * Filesystem may store an arbitrary file handle (pointer, index, etc) in {@link FileInfo#setFh(long) fi->fh},
+	 * and use this in other all other file operations (read, write, flush, release, fsync).
 	 * <p>
-	 * Unless the 'default_permissions' mount option is given,
-	 * open should check if the operation is permitted for the
-	 * given flags. Optionally open may also return an arbitrary
-	 * filehandle in the fuse_file_info structure, which will be
-	 * passed to all file operations.
+	 * Filesystem may also implement stateless file I/O and not store anything in {@link FileInfo#setFh(long) fi->fh}.
 	 * <p>
-	 * Changed in version 2.2
+	 * There are also some flags (direct_io, keep_cache) which the filesystem may set in fi, to change the way the file
+	 * is opened. See fuse_file_info structure in fuse_common.h for more details.
+	 * <p>
+	 * If this request is answered with an error code of ENOSYS and FUSE_CAP_NO_OPEN_SUPPORT is set in
+	 * `fuse_conn_info.capable`, this is treated as success and future calls to open will also succeed without being
+	 * send to the filesystem process.
+	 *
+	 * @param path file path
+	 * @param fi   file info, which may be used to store a file handle
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int open(String path, FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Read data from an open file
+	 * Read data from an open file.
 	 * <p>
 	 * Read should return exactly the number of bytes requested except
 	 * on EOF or error, otherwise the rest of the data will be
@@ -198,80 +276,103 @@ default int open(String path, FileInfo fi) {
 	 * 'direct_io' mount option is specified, in which case the return
 	 * value of the read system call will reflect the return value of
 	 * this operation.
-	 * <p>
-	 * Changed in version 2.2
+	 *
+	 * @param path   file path
+	 * @param buf    the buffer to read into
+	 * @param count  number of bytes to read
+	 * @param offset position in the file to start reading
+	 * @param fi     file info
+	 * @return number of bytes read or negated error code (-errno)
 	 */
-	default int read(String path, ByteBuffer buf, long size, long offset, FileInfo fi) {
+	default int read(String path, ByteBuffer buf, long count, long offset, FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Write data to an open file
+	 * Write data to an open file.
 	 * <p>
 	 * Write should return exactly the number of bytes requested
 	 * except on error.	 An exception to this is when the 'direct_io'
 	 * mount option is specified (see read operation).
 	 * <p>
-	 * Changed in version 2.2
+	 * Unless FUSE_CAP_HANDLE_KILLPRIV is disabled, this method is
+	 * expected to reset the setuid and setgid bits.
+	 *
+	 * @param path   file path
+	 * @param buf    the buffer containing the data to be written
+	 * @param count  number of bytes to write
+	 * @param offset position in the file to write to
+	 * @param fi     file info
+	 * @return number of bytes written or negated error code (-errno)
 	 */
-	default int write(String path, ByteBuffer buf, long size, long offset, FileInfo fi) {
+	default int write(String path, ByteBuffer buf, long count, long offset, FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Get file system statistics
+	 * Get file system statistics.
 	 * <p>
-	 * The 'f_frsize', 'f_favail', 'f_fsid' and 'f_flag' fields are ignored
-	 * <p>
-	 * Replaced 'struct statfs' parameter with 'struct statvfs' in
-	 * version 2.5
+	 * The 'f_favail', 'f_fsid' and 'f_flag' fields are ignored
+	 *
+	 * @param path    file path of any file within the file system
+	 * @param statvfs The statistics object to be filled with data
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int statfs(String path, Statvfs statvfs) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Possibly flush cached data
+	 * Possibly flush cached data.
 	 * <p>
 	 * BIG NOTE: This is not equivalent to fsync().  It's not a
 	 * request to sync dirty data.
 	 * <p>
-	 * Flush is called on each close() of a file descriptor.  So if a
-	 * filesystem wants to return write errors in close() and the file
-	 * has cached dirty data, this is a good place to write back data
-	 * and return any errors.  Since many applications ignore close()
-	 * errors this is not always useful.
+	 * Flush is called on each close() of a file descriptor, as opposed to
+	 * release which is called on the close of the last file descriptor for
+	 * a file.  Under Linux, errors returned by flush() will be passed to
+	 * userspace as errors from close(), so flush() is a good place to write
+	 * back any cached dirty data. However, many applications ignore errors
+	 * on close(), and on non-Linux systems, close() may succeed even if flush()
+	 * returns an error. For these reasons, filesystems should not assume
+	 * that errors returned by flush will ever be noticed or even
+	 * delivered.
 	 * <p>
 	 * NOTE: The flush() method may be called more than once for each
-	 * open().	This happens if more than one file descriptor refers
-	 * to an opened file due to dup(), dup2() or fork() calls.	It is
-	 * not possible to determine if a flush is final, so each flush
-	 * should be treated equally.  Multiple write-flush sequences are
-	 * relatively rare, so this shouldn't be a problem.
-	 * <p>
-	 * Filesystems shouldn't assume that flush will always be called
-	 * after some writes, or that if will be called at all.
-	 * <p>
-	 * Changed in version 2.2
+	 * open().  This happens if more than one file descriptor refers to an
+	 * open file handle, e.g. due to dup(), dup2() or fork() calls.  It is
+	 * not possible to determine if a flush is final, so each flush should
+	 * be treated equally.  Multiple write-flush sequences are relatively
+	 * rare, so this shouldn't be a problem.
+	 * <p>
+	 * Filesystems shouldn't assume that flush will be called at any
+	 * particular point.  It may be called more times than expected, or not
+	 * at all.
+	 *
+	 * @param path file path
+	 * @param fi   file info
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int flush(String path, FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Release an open file
+	 * Release an open file.
 	 * <p>
 	 * Release is called when there are no more references to an open
 	 * file: all file descriptors are closed and all memory mappings
 	 * are unmapped.
 	 * <p>
 	 * For every open() call there will be exactly one release() call
-	 * with the same flags and file descriptor.	 It is possible to
+	 * with the same flags and file handle.  It is possible to
 	 * have a file opened more than once, in which case only the last
 	 * release will mean, that no more reads/writes will happen on the
 	 * file.  The return value of release is ignored.
-	 * <p>
-	 * Changed in version 2.2
+	 *
+	 * @param path file path
+	 * @param fi   file info
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int release(String path, FileInfo fi) {
 		return 0;
@@ -279,11 +380,11 @@ default int release(String path, FileInfo fi) {
 
 	/**
 	 * Synchronize file contents
-	 * <p>
-	 * If the datasync parameter is non-zero, then only the user data
-	 * should be flushed, not the meta data.
-	 * <p>
-	 * Changed in version 2.2
+	 *
+	 * @param path     file path
+	 * @param datasync if non-zero, then only the user data should be flushed, not the meta data.
+	 * @param fi       file info
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int fsync(String path, int datasync, FileInfo fi) {
 		return -errno().enosys();
@@ -291,6 +392,14 @@ default int fsync(String path, int datasync, FileInfo fi) {
 
 	/**
 	 * Set extended attributes
+	 *
+	 * @param path  file path
+	 * @param name  attribute name
+	 * @param value attribute value
+	 * @param size  number of bytes of the value TODO: can this be combined with the value buffer?
+	 * @param flags defaults to zero, which creates <em>or</em> replaces the attribute. For fine-grained atomic control,
+	 *              <code>XATTR_CREATE</code> or <code>XATTR_REPLACE</code> may be used.
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int setxattr(String path, String name, ByteBuffer value, long size, int flags) {
 		return -errno().enosys();
@@ -298,6 +407,12 @@ default int setxattr(String path, String name, ByteBuffer value, long size, int
 
 	/**
 	 * Get extended attributes
+	 *
+	 * @param path  file path
+	 * @param name  attribute name
+	 * @param value attribute value
+	 * @param size  size of the value buffer TODO: can this be combined with the value buffer?
+	 * @return the non-negative value size or negated error code (-errno)
 	 */
 	default int getxattr(String path, String name, ByteBuffer value, long size) {
 		return -errno().enosys();
@@ -305,6 +420,11 @@ default int getxattr(String path, String name, ByteBuffer value, long size) {
 
 	/**
 	 * List extended attributes
+	 *
+	 * @param path file path
+	 * @param list consecutive list of null-terminated attribute names (as many as fit into the buffer)
+	 * @param size size of the list buffer TODO: can this be combined with the value buffer?
+	 * @return the non-negative list size or negated error code (-errno)
 	 */
 	default int listxattr(String path, ByteBuffer list, long size) {
 		return -errno().enosys();
@@ -312,84 +432,95 @@ default int listxattr(String path, ByteBuffer list, long size) {
 
 	/**
 	 * Remove extended attributes
+	 *
+	 * @param path file path
+	 * @param name attribute name
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int removexattr(String path, String name) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Open directory
+	 * Open directory.
 	 * <p>
 	 * Unless the 'default_permissions' mount option is given,
 	 * this method should check if opendir is permitted for this
 	 * directory. Optionally opendir may also return an arbitrary
-	 * filehandle in the fuse_file_info structure, which will be
-	 * passed to readdir, closedir and fsyncdir.
-	 * <p>
-	 * Introduced in version 2.3
+	 * {@link FileInfo#setFh(long) filehandle in the fuse_file_info structure},
+	 * which will be passed to readdir, releasedir and fsyncdir.
+	 *
+	 * @param path directory path
+	 * @param fi   file info, which may be used to store a file handle
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int opendir(String path, FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Read directory
-	 * <p>
-	 * This supersedes the old getdir interface.
-	 * New applications should use this.
+	 * Read directory.
 	 * <p>
 	 * The filesystem may choose between two modes of operation:
-	 * <p>
-	 * 1) The readdir implementation ignores the offset parameter, and
-	 * passes zero to the filler function's offset.  The filler
-	 * function will not return '1' (unless an error happens), so the
-	 * whole directory is read in a single readdir operation.  This
-	 * works just like the old getdir() method.
-	 * <p>
-	 * 2) The readdir implementation keeps track of the offsets of the
-	 * directory entries.  It uses the offset parameter and always
-	 * passes non-zero offset to the filler function.  When the buffer
-	 * is full (or an error happens) the filler function will return
-	 * '1'.
-	 * <p>
-	 * Introduced in version 2.3
-	 */
-	default int readdir(String path, DirFiller filler, long offset, FileInfo fi) {
+	 * <ol>
+	 *     <li>The readdir implementation ignores the offset parameter, and
+	 * 	  passes zero to the filler function's offset.  The filler
+	 * 	  function will not return '1' (unless an error happens), so the
+	 * 	  whole directory is read in a single readdir operation.</li>
+	 *     <li>The readdir implementation keeps track of the offsets of the
+	 * 	  directory entries.  It uses the offset parameter and always
+	 * 	  passes non-zero offset to the filler function.  When the buffer
+	 * 	  is full (or an error happens) the filler function will return
+	 * 	  '1'.</li>
+	 * </ol>
+	 *
+	 * @param path   directory path
+	 * @param filler the fill function
+	 * @param offset the offset
+	 * @param fi     file info
+	 * @param flags  When {@link #FUSE_READDIR_PLUS} is not set, only some parameters of the
+	 *               fill function (the {@code filler} parameter) are actually used:
+	 *               The file type (which is part of {@link Stat#getMode()}) is used. And if
+	 *               fuse_config::use_ino is set, the inode (stat::st_ino) is also
+	 *               used. The other fields are ignored when {@code READ_DIR_PLUS} is not
+	 *               set.
+	 * @return 0 on success or negated error code (-errno)
+	 */
+	default int readdir(String path, DirFiller filler, long offset, FileInfo fi, int flags) {
 		return -errno().enosys();
 	}
 
 	/**
 	 * Release directory
-	 * <p>
-	 * Introduced in version 2.3
+	 *
+	 * @param path directory path. If the directory has been removed after the call to opendir, the
+	 *             path parameter will be <code>null</code>
+	 * @param fi   file info
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int releasedir(String path, FileInfo fi) {
+	default int releasedir(@Nullable String path, FileInfo fi) {
 		return 0;
 	}
 
 	/**
 	 * Synchronize directory contents
-	 * <p>
-	 * If the datasync parameter is non-zero, then only the user data
-	 * should be flushed, not the meta data
-	 * <p>
-	 * Introduced in version 2.3
+	 *
+	 * @param path     directory path. If the directory has been removed after the call to opendir, the
+	 *                 path parameter will be <code>null</code>
+	 * @param datasync if non-zero, then only the user data should be flushed, not the meta data
+	 * @param fi       file info
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int fsyncdir(String path, int datasync, FileInfo fi) {
+	default int fsyncdir(@Nullable String path, int datasync, FileInfo fi) {
 		return -errno().enosys();
 	}
 
 	/**
 	 * Initialize filesystem
-	 * <p>
-	 * The return value will passed in the private_data field of
-	 * fuse_context to all file operations and as a parameter to the
-	 * destroy() method.
-	 * <p>
-	 * Introduced in version 2.3
-	 * Changed in version 2.6
+	 *
+	 * @param conn FUSE information
 	 */
-	default void init(FuseConnInfo conn) {
+	default void init(FuseConnInfo conn) { // TODO: add @Nullable FuseConfig for libfuse3
 		// no-op
 	}
 
@@ -397,30 +528,30 @@ default void init(FuseConnInfo conn) {
 	 * Clean up filesystem
 	 * <p>
 	 * Called on filesystem exit.
-	 * <p>
-	 * Introduced in version 2.3
 	 */
 	default void destroy() {
 		// no-op
 	}
 
 	/**
-	 * Check file access permissions
+	 * Check file access permissions.
 	 * <p>
 	 * This will be called for the access() system call.  If the
 	 * 'default_permissions' mount option is given, this method is not
 	 * called.
 	 * <p>
 	 * This method is not called under Linux kernel versions 2.4.x
-	 * <p>
-	 * Introduced in version 2.5
+	 *
+	 * @param path file path
+	 * @param mask bitwise OR of file access checks
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int access(String path, int mask) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Create and open a file
+	 * Create and open a file.
 	 * <p>
 	 * If the file does not exist, first create it with the specified
 	 * mode, and then open it.
@@ -428,45 +559,16 @@ default int access(String path, int mask) {
 	 * If this method is not implemented or under Linux kernel
 	 * versions earlier than 2.6.15, the mknod() and open() methods
 	 * will be called instead.
-	 * <p>
-	 * Introduced in version 2.5
+	 *
+	 * @param path file path
+	 * @param mode mode used to create the file if it does not exist yet
+	 * @param fi   file info, which may be used to store a file handle
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int create(String path, int mode, FileInfo fi) {
 		return -errno().enosys();
 	}
 
-	/**
-	 * Change the size of an open file
-	 * <p>
-	 * This method is called instead of the truncate() method if the
-	 * truncation was invoked from an ftruncate() system call.
-	 * <p>
-	 * If this method is not implemented or under Linux kernel
-	 * versions earlier than 2.6.15, the truncate() method will be
-	 * called instead.
-	 * <p>
-	 * Introduced in version 2.5
-	 */
-	default int ftruncate(String path, long size, FileInfo fi) {
-		return -errno().enosys();
-	}
-
-	/**
-	 * Get attributes from an open file
-	 * <p>
-	 * This method is called instead of the getattr() method if the
-	 * file information is available.
-	 * <p>
-	 * Currently this is only called after the create() method if that
-	 * is implemented (see above).  Later it may be called for
-	 * invocations of fstat() too.
-	 * <p>
-	 * Introduced in version 2.5
-	 */
-	default int fgetattr(String path, Stat stat, FileInfo fi) {
-		return -errno().enosys();
-	}
-
 //	/**
 //	 * Perform POSIX file locking operation
 //	 * <p>
@@ -505,16 +607,21 @@ default int fgetattr(String path, Stat stat, FileInfo fi) {
 
 	/**
 	 * Change the access and modification times of a file with
-	 * nanosecond resolution
+	 * nanosecond resolution.
 	 * <p>
 	 * This supersedes the old utime() interface.  New applications
 	 * should use this.
 	 * <p>
 	 * See the utimensat(2) man page for details.
-	 * <p>
-	 * Introduced in version 2.6
+	 *
+	 * @param path  file path
+	 * @param atime last access time
+	 * @param mtime last modified time
+	 * @param fi    will always be <code>null</code> if the file is not currently open,
+	 *              but may also be <code>null</code> if the file is open.
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int utimens(String path, TimeSpec atime, TimeSpec mtime) {
+	default int utimens(String path, TimeSpec atime, TimeSpec mtime, @Nullable FileInfo fi) {
 		return -errno().enosys();
 	}
 
@@ -540,12 +647,18 @@ default int utimens(String path, TimeSpec atime, TimeSpec mtime) {
 	 * _IOC_READ in area and if both are set in/out area.  In all
 	 * non-NULL cases, the area is of _IOC_SIZE(cmd) bytes.
 	 * <p>
-	 * If flags has FUSE_IOCTL_DIR then the fuse_file_info refers to a
-	 * directory file handle.
-	 * <p>
-	 * Introduced in version 2.8
+	 * Note: the unsigned long request submitted by the application
+	 * is truncated to 32 bits.
+	 *
+	 * @param path  file path
+	 * @param cmd   the request
+	 * @param arg   any arguments
+	 * @param fi    file info
+	 * @param flags if containing FUSE_IOCTL_DIR then the <code>fi</code> refers to a directory file handle.
+	 * @param data  data (depends on <code>cmd</code> and may be <code>null</code>)
+	 * @return 0 on success or negated error code (-errno)
 	 */
-	default int ioctl(String path, int cmd, ByteBuffer arg, FileInfo fi, int flags, ByteBuffer data) {
+	default int ioctl(String path, int cmd, ByteBuffer arg, FileInfo fi, int flags, @Nullable ByteBuffer data) {
 		return -errno().enosys();
 	}
 
@@ -605,7 +718,7 @@ default int ioctl(String path, int cmd, ByteBuffer arg, FileInfo fi, int flags,
 //	}
 
 	/**
-	 * Perform BSD file locking operation
+	 * Perform BSD file locking operation.
 	 * <p>
 	 * The op argument will be either LOCK_SH, LOCK_EX or LOCK_UN
 	 * <p>
@@ -621,22 +734,30 @@ default int ioctl(String path, int cmd, ByteBuffer arg, FileInfo fi, int flags,
 	 * Note: if this method is not implemented, the kernel will still
 	 * allow file locking to work locally.  Hence it is only
 	 * interesting for network filesystems and similar.
-	 * <p>
-	 * Introduced in version 2.9
+	 *
+	 * @param path file path
+	 * @param fi   file info
+	 * @param op   one of <code>LOCK_SH</code>, <code>LOCK_EX</code> or <code>LOCK_UN</code>
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int flock(String path, FileInfo fi, int op) {
 		return -errno().enosys();
 	}
 
 	/**
-	 * Allocates space for an open file
+	 * Allocates space for an open file.
 	 * <p>
 	 * This function ensures that required space is allocated for specified
 	 * file.  If this function returns success then any subsequent write
 	 * request to specified range is guaranteed not to fail because of lack
 	 * of space on the file system media.
-	 * <p>
-	 * Introduced in version 2.9.1
+	 *
+	 * @param path   file path
+	 * @param mode   the operation to be performed
+	 * @param offset start of the allocated region
+	 * @param length number of bytes to allocate in this file
+	 * @param fi     file info
+	 * @return 0 on success or negated error code (-errno)
 	 */
 	default int fallocate(String path, int mode, long offset, long length, FileInfo fi) {
 		return -errno().enosys();
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/MountFailedException.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/MountFailedException.java
new file mode 100644
index 00000000..e1378ffc
--- /dev/null
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/MountFailedException.java
@@ -0,0 +1,9 @@
+package org.cryptomator.jfuse.api;
+
+public class MountFailedException extends Exception {
+
+	public MountFailedException(String message) {
+		super(message);
+	}
+
+}
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/OperatingSystem.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/OperatingSystem.java
index 4023b108..6812e26f 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/OperatingSystem.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/OperatingSystem.java
@@ -7,9 +7,18 @@ public enum OperatingSystem {
 	UNKNOWN;
 
 	private static final String OS_NAME = System.getProperty("os.name").toLowerCase();
-	public static final OperatingSystem CURRENT = OS_NAME.contains("linux") ? LINUX
-			: OS_NAME.contains("mac") ? MAC
-			: OS_NAME.contains("windows") ? WINDOWS
-			: UNKNOWN;
+	public static final OperatingSystem CURRENT = getCurrent();
+
+	private static OperatingSystem getCurrent() {
+		if (OS_NAME.contains("linux")) {
+			return LINUX;
+		} else if (OS_NAME.contains("mac")) {
+			return MAC;
+		} else if (OS_NAME.contains("windows")) {
+			return WINDOWS;
+		} else {
+			return UNKNOWN;
+		}
+	}
 }
 
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Stat.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Stat.java
index 10ab81d0..95b1891f 100644
--- a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Stat.java
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/Stat.java
@@ -3,8 +3,45 @@
 import java.nio.file.attribute.PosixFilePermission;
 import java.util.Set;
 
+@SuppressWarnings("OctalInteger")
 public interface Stat {
 
+	/**
+	 * Mask value for file type socket
+	 * See man page of inode(7).
+	 */
+	int S_IFSOCK = 0140000;
+	/**
+	 * Mask value for file type symbolic link
+	 * See man page of inode(7).
+	 */
+	int S_IFLNK = 0120000;
+	/**
+	 * Mask value for file type regular file
+	 * See man page of inode(7).
+	 */
+	int S_IFREG = 0100000;
+	/**
+	 * Mask value for file type block device
+	 * See man page of inode(7).
+	 */
+	int S_IFBLK = 0060000;
+	/**
+	 * Mask value for file type directory
+	 * See man page of inode(7).
+	 */
+	int S_IFDIR = 0040000;
+	/**
+	 * Mask value for file type character device
+	 * See man page of inode(7).
+	 */
+	int S_IFCHR = 0020000;
+	/**
+	 * Mask value for file type named pipe (FIFO)
+	 * See man page of inode(7).
+	 */
+	int S_IFIFO = 0010000;
+
 	TimeSpec aTime();
 
 	TimeSpec cTime();
@@ -46,37 +83,61 @@ default void setPermissions(Set<PosixFilePermission> permissions) {
 	/**
 	 * @return <code>true</code> if <code>S_IFDIR</code> bit is set in {@link #getMode()}
 	 */
-	boolean isDir();
+	default boolean isDir() {
+		return hasMode(S_IFDIR);
+	}
 
 	/**
 	 * Sets the <code>S_IFDIR</code> bit in {@link #setMode(int)}
 	 *
 	 * @param isDir Whether to set the <code>S_IFDIR</code> bit to one.
 	 */
-	void toggleDir(boolean isDir);
+	default void toggleDir(boolean isDir) {
+		toggleMode(S_IFDIR, isDir);
+	}
 
 	/**
 	 * @return <code>true</code> if <code>S_IFREG</code> bit is set in {@link #getMode()}
 	 */
-	boolean isReg();
+	default boolean isReg() {
+		return hasMode(S_IFREG);
+	}
 
 	/**
 	 * Sets the <code>S_IFREG</code> bit in {@link #setMode(int)}
 	 *
 	 * @param isReg Whether to set the <code>S_IFREG</code> bit to one.
 	 */
-	void toggleReg(boolean isReg);
+	default void toggleReg(boolean isReg) {
+		toggleMode(S_IFREG, isReg);
+	}
 
 	/**
 	 * @return <code>true</code> if <code>S_IFLNK</code> bit is set in {@link #getMode()}
 	 */
-	boolean isLnk();
+	default boolean isLnk() {
+		return hasMode(S_IFLNK);
+	}
 
 	/**
 	 * Sets the <code>S_IFLNK</code> bit in {@link #setMode(int)}
 	 *
 	 * @param isLnk Whether to set the <code>S_IFLNK</code> bit to one.
 	 */
-	void toggleLnk(boolean isLnk);
+	default void toggleLnk(boolean isLnk) {
+		toggleMode(S_IFLNK, isLnk);
+	}
+
+	default boolean hasMode(int mask) {
+		return (getMode() & mask) == mask;
+	}
+
+	default void toggleMode(int mask, boolean set) {
+		if (set) {
+			setMode(getMode() | mask);
+		} else {
+			setMode(getMode() & ~mask);
+		}
+	}
 
 }
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/UnmountedFuseMount.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/UnmountedFuseMount.java
new file mode 100644
index 00000000..1c3a4be2
--- /dev/null
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/UnmountedFuseMount.java
@@ -0,0 +1,21 @@
+package org.cryptomator.jfuse.api;
+
+/**
+ * A dummy implementation that can safely be used for repeated invocations during {@link Fuse#close()}, making it idempotent.
+ */
+class UnmountedFuseMount implements FuseMount {
+	@Override
+	public int loop() {
+		return 0;
+	}
+
+	@Override
+	public void unmount() {
+		// no-op
+	}
+
+	@Override
+	public void destroy() {
+		// no-op
+	}
+}
diff --git a/jfuse-api/src/main/java/org/cryptomator/jfuse/api/package-info.java b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/package-info.java
new file mode 100644
index 00000000..a3525a6c
--- /dev/null
+++ b/jfuse-api/src/main/java/org/cryptomator/jfuse/api/package-info.java
@@ -0,0 +1,4 @@
+@ApiStatus.Experimental
+package org.cryptomator.jfuse.api;
+
+import org.jetbrains.annotations.ApiStatus;
\ No newline at end of file
diff --git a/jfuse-api/src/test/java/org/cryptomator/jfuse/api/DirFillerTest.java b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/DirFillerTest.java
new file mode 100644
index 00000000..4e529e93
--- /dev/null
+++ b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/DirFillerTest.java
@@ -0,0 +1,50 @@
+package org.cryptomator.jfuse.api;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+
+public class DirFillerTest {
+
+	@Test
+	@DisplayName("fill(path, statFiller)")
+	public void testTwoArgFill() throws IOException {
+		var filler = Mockito.mock(DirFiller.class);
+		Mockito.doCallRealMethod().when(filler).fill(Mockito.any(), Mockito.any());
+		Mockito.doReturn(0).when(filler).fill(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.anyInt());
+
+		filler.fill("name", stat -> {
+		});
+
+		Mockito.verify(filler).fill(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.anyInt());
+	}
+
+	@Test
+	@DisplayName("fill(path, statFiller) throws IOException")
+	public void testExceptionalTwoArgFill() throws IOException {
+		var filler = Mockito.mock(DirFiller.class);
+		Mockito.doCallRealMethod().when(filler).fill(Mockito.any(), Mockito.any());
+		Mockito.doReturn(1).when(filler).fill(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.anyInt());
+
+		Assertions.assertThrows(IOException.class, () -> {
+			filler.fill("name", stat -> {
+			});
+		});
+	}
+
+	@Test
+	@DisplayName("fill(path) ")
+	public void testOneArgFill() throws IOException {
+		var filler = Mockito.mock(DirFiller.class);
+		Mockito.doCallRealMethod().when(filler).fill(Mockito.any());
+		Mockito.doNothing().when(filler).fill(Mockito.any(), Mockito.any());
+
+		filler.fill("name");
+
+		Mockito.verify(filler).fill(Mockito.any(), Mockito.any());
+	}
+
+}
\ No newline at end of file
diff --git a/jfuse-api/src/test/java/org/cryptomator/jfuse/api/StatTest.java b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/StatTest.java
new file mode 100644
index 00000000..8d1b8617
--- /dev/null
+++ b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/StatTest.java
@@ -0,0 +1,151 @@
+package org.cryptomator.jfuse.api;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.ArgumentMatcher;
+import org.mockito.Mockito;
+
+import java.util.stream.Stream;
+
+import static org.cryptomator.jfuse.api.Stat.S_IFDIR;
+import static org.cryptomator.jfuse.api.Stat.S_IFLNK;
+import static org.cryptomator.jfuse.api.Stat.S_IFREG;
+
+public class StatTest {
+
+	private static final int MAGIC = 123456;//some rando number
+
+	public Stat stat = Mockito.spy(new StubStatImpl());
+
+	@ParameterizedTest
+	@MethodSource("provideDataForToggle")
+	public void testToggleMode(int mode, int mask, boolean toSet) {
+		Mockito.when(stat.getMode()).thenReturn(mode);
+		stat.toggleMode(mask, toSet);
+		Mockito.verify(stat).setMode(Mockito.intThat(toSet ? hasBitsSet(mask) : hasBitsNotSet(mask)));
+	}
+
+	public static Stream<Arguments> provideDataForToggle() {
+		return Stream.of(
+				Arguments.arguments(S_IFDIR, S_IFDIR, true), //
+				Arguments.arguments(S_IFDIR, S_IFDIR, false), //
+				Arguments.arguments(0, S_IFDIR, true), //
+				Arguments.arguments(0, S_IFDIR, false)
+		);
+	}
+
+	@ParameterizedTest
+	@ValueSource(booleans = {true, false})
+	public void testHasMode(boolean isPresent) {
+		Mockito.when(stat.getMode()).thenReturn(isPresent ? MAGIC : ~MAGIC);
+		boolean result = stat.hasMode(MAGIC);
+		Assertions.assertEquals(isPresent, result);
+	}
+
+
+	@Test
+	public void testIsDir() {
+		stat.isDir();
+		Mockito.verify(stat).hasMode(S_IFDIR);
+	}
+
+	@ParameterizedTest
+	@ValueSource(booleans = {true, false})
+	public void testToggleDir(boolean isDir) {
+		stat.toggleDir(isDir);
+		Mockito.verify(stat).toggleMode(S_IFDIR, isDir);
+	}
+
+	@Test
+	public void testIsReg() {
+		stat.isReg();
+		Mockito.verify(stat).hasMode(S_IFREG);
+	}
+
+	@ParameterizedTest
+	@ValueSource(booleans = {true, false})
+	public void testToggleReg(boolean isReg) {
+		stat.toggleReg(isReg);
+		Mockito.verify(stat).toggleMode(S_IFREG, isReg);
+	}
+
+	@Test
+	public void testIsLnk() {
+		stat.isLnk();
+		Mockito.verify(stat).hasMode(S_IFLNK);
+	}
+
+	@ParameterizedTest
+	@ValueSource(booleans = {true, false})
+	public void testToggleLnk(boolean isLnk) {
+		stat.toggleLnk(isLnk);
+		Mockito.verify(stat).toggleMode(S_IFLNK, isLnk);
+	}
+
+	private static ArgumentMatcher<Integer> hasBitsSet(int mask) {
+		return toMatch -> (toMatch & mask) == mask;
+	}
+
+	private static ArgumentMatcher<Integer> hasBitsNotSet(int mask) {
+		return toMatch -> (toMatch & mask) == 0;
+	}
+
+
+	private class StubStatImpl implements Stat {
+
+		@Override
+		public TimeSpec aTime() {
+			return null;
+		}
+
+		@Override
+		public TimeSpec cTime() {
+			return null;
+		}
+
+		@Override
+		public TimeSpec mTime() {
+			return null;
+		}
+
+		@Override
+		public TimeSpec birthTime() {
+			return null;
+		}
+
+		@Override
+		public void setMode(int mode) {
+
+		}
+
+		@Override
+		public int getMode() {
+			return 0;
+		}
+
+		@Override
+		public void setNLink(short count) {
+
+		}
+
+		@Override
+		public long getNLink() {
+			return 0;
+		}
+
+		@Override
+		public void setSize(long size) {
+
+		}
+
+		@Override
+		public long getSize() {
+			return 0;
+		}
+	}
+
+}
diff --git a/jfuse-api/src/test/java/org/cryptomator/jfuse/api/UnmountedFuseMountTest.java b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/UnmountedFuseMountTest.java
new file mode 100644
index 00000000..805c788a
--- /dev/null
+++ b/jfuse-api/src/test/java/org/cryptomator/jfuse/api/UnmountedFuseMountTest.java
@@ -0,0 +1,25 @@
+package org.cryptomator.jfuse.api;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class UnmountedFuseMountTest {
+
+	private final UnmountedFuseMount unmountedMount = new UnmountedFuseMount();
+
+	@Test
+	public void testLoop() {
+		Assertions.assertEquals(0, unmountedMount.loop());
+	}
+
+	@Test
+	public void testUnmount() {
+		Assertions.assertDoesNotThrow(unmountedMount::unmount);
+	}
+
+	@Test
+	public void testDestroy() {
+		Assertions.assertDoesNotThrow(unmountedMount::destroy);
+	}
+
+}
\ No newline at end of file
diff --git a/jfuse-examples/pom.xml b/jfuse-examples/pom.xml
index 076b21f1..95a756c7 100644
--- a/jfuse-examples/pom.xml
+++ b/jfuse-examples/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>jfuse</artifactId>
-		<version>0.1.0</version>
+		<version>0.2.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jfuse-examples</artifactId>
diff --git a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/AbstractMirrorFileSystem.java b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/AbstractMirrorFileSystem.java
index 8328ff85..1d021020 100644
--- a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/AbstractMirrorFileSystem.java
+++ b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/AbstractMirrorFileSystem.java
@@ -41,7 +41,6 @@
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ConcurrentMap;
 import java.util.concurrent.atomic.AtomicLong;
-import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
 
 public abstract sealed class AbstractMirrorFileSystem implements FuseOperations permits PosixMirrorFileSystem, WindowsMirrorFileSystem {
@@ -169,33 +168,12 @@ public int readlink(String path, ByteBuffer buf, long len) {
 
 	@SuppressWarnings("OctalInteger")
 	@Override
-	public int getattr(String path, Stat stat) {
+	public int getattr(String path, Stat stat, FileInfo fi) {
 		LOG.trace("getattr {}", path);
 		Path node = resolvePath(path);
 		try {
 			var attrs = readAttributes(node);
-			if (attrs instanceof PosixFileAttributes posixAttrs) {
-				stat.setPermissions(posixAttrs.permissions());
-			} else if (attrs instanceof DosFileAttributes dosAttrs) {
-				int mode = 0444;
-				mode |= dosAttrs.isReadOnly() ? 0000 : 0200; // add write access for owner
-				mode |= attrs.isDirectory() ? 0111 : 0000; // add execute access for directories
-				stat.setMode(mode);
-			}
-			stat.setSize(attrs.size());
-			stat.setNLink((short) 1);
-			if (attrs.isDirectory()) {
-				stat.toggleDir(true);
-				stat.setNLink((short) (2 + countSubDirs(node)));
-			} else if (attrs.isSymbolicLink()) {
-				stat.toggleLnk(true);
-			} else if (attrs.isRegularFile()){
-				stat.toggleReg(true);
-			}
-			stat.aTime().set(attrs.lastAccessTime().toInstant());
-			stat.mTime().set(attrs.lastModifiedTime().toInstant());
-			stat.cTime().set(attrs.lastAccessTime().toInstant());
-			stat.birthTime().set(attrs.creationTime().toInstant());
+			copyAttrsToStat(attrs, stat);
 			return 0;
 		} catch (NoSuchFileException e) {
 			return -errno.enoent();
@@ -204,6 +182,32 @@ public int getattr(String path, Stat stat) {
 		}
 	}
 
+	@SuppressWarnings("OctalInteger")
+	protected void copyAttrsToStat(BasicFileAttributes attrs, Stat stat) {
+		if (attrs instanceof PosixFileAttributes posixAttrs) {
+			stat.setPermissions(posixAttrs.permissions());
+		} else if (attrs instanceof DosFileAttributes dosAttrs) {
+			int mode = 0444;
+			mode |= dosAttrs.isReadOnly() ? 0000 : 0200; // add write access for owner
+			mode |= attrs.isDirectory() ? 0111 : 0000; // add execute access for directories
+			stat.setMode(mode);
+		}
+		stat.setSize(attrs.size());
+		stat.setNLink((short) 1);
+		if (attrs.isDirectory()) {
+			stat.toggleDir(true);
+			stat.setNLink((short) 2); // quick and dirty implementation. should really be 2 + subdir count
+		} else if (attrs.isSymbolicLink()) {
+			stat.toggleLnk(true);
+		} else if (attrs.isRegularFile()){
+			stat.toggleReg(true);
+		}
+		stat.aTime().set(attrs.lastAccessTime().toInstant());
+		stat.mTime().set(attrs.lastModifiedTime().toInstant());
+		stat.cTime().set(attrs.lastAccessTime().toInstant());
+		stat.birthTime().set(attrs.creationTime().toInstant());
+	}
+
 	protected abstract BasicFileAttributes readAttributes(Path node) throws IOException;
 
 	private long countSubDirs(Path dir) throws IOException {
@@ -213,7 +217,7 @@ private long countSubDirs(Path dir) throws IOException {
 	}
 
 	@Override
-	public int chmod(String path, int mode) {
+	public int chmod(String path, int mode, FileInfo fi) {
 		LOG.trace("chmod {}", path);
 		Path node = resolvePath(path);
 		try {
@@ -225,7 +229,7 @@ public int chmod(String path, int mode) {
 	}
 
 	@Override
-	public int utimens(String path, TimeSpec atime, TimeSpec mtime) {
+	public int utimens(String path, TimeSpec atime, TimeSpec mtime, FileInfo fi) {
 		LOG.trace("utimens {}", path);
 		Path node = resolvePath(path);
 		var view = Files.getFileAttributeView(node, BasicFileAttributeView.class, LinkOption.NOFOLLOW_LINKS);
@@ -270,13 +274,16 @@ public int opendir(String path, FileInfo fi) {
 	}
 
 	@Override
-	public int readdir(String path, DirFiller filler, long offset, FileInfo fi) {
+	public int readdir(String path, DirFiller filler, long offset, FileInfo fi, int flags) {
 		LOG.trace("readdir {}", path);
 		Path node = resolvePath(path);
+
 		try (var ds = Files.newDirectoryStream(node)) {
-			var childNames = StreamSupport.stream(ds.spliterator(), false).map(Path::getFileName).map(Path::toString);
-			var allNames = Stream.concat(Stream.of(".", ".."), childNames);
-			filler.fillNamesFromOffset(allNames.skip(offset), offset);
+			filler.fill(".");
+			filler.fill("..");
+			for (var child : ds) {
+				filler.fill(child.getFileName().toString());
+			}
 			return 0;
 		} catch (NotDirectoryException e) {
 			return -errno.enotdir();
@@ -344,8 +351,9 @@ public int read(String path, ByteBuffer buf, long size, long offset, FileInfo fi
 			return -errno.ebadf();
 		}
 		try {
-			// TODO restrict to `size` bytes!
-			int read = fc.read(buf, offset);
+			var dst = buf.duplicate();
+			dst.limit((int) Math.min(dst.position() + size, dst.limit())); // restrict to `size` bytes!
+			int read = fc.read(dst, offset);
 			return read == -1 ? 0 : read; // there is no "-1" in fuse
 		} catch (IOException e) {
 			return -errno.eio();
@@ -367,7 +375,7 @@ public int write(String path, ByteBuffer buf, long size, long offset, FileInfo f
 	}
 
 	@Override
-	public int truncate(String path, long size) {
+	public int truncate(String path, long size, FileInfo fi) {
 		LOG.trace("truncate {} to size {}", path, size);
 		Path node = resolvePath(path);
 		try (FileChannel fc = FileChannel.open(node, StandardOpenOption.WRITE)) {
@@ -413,7 +421,7 @@ public int unlink(String path) {
 	}
 
 	@Override
-	public int rename(String oldpath, String newpath) {
+	public int rename(String oldpath, String newpath, int flags) {
 		LOG.trace("rename {} -> {}", oldpath, newpath);
 		Path nodeOld = resolvePath(oldpath);
 		Path nodeNew = resolvePath(newpath);
diff --git a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/HelloWorldFileSystem.java b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/HelloWorldFileSystem.java
index b40bef81..ad07fcb5 100644
--- a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/HelloWorldFileSystem.java
+++ b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/HelloWorldFileSystem.java
@@ -6,24 +6,24 @@
 import org.cryptomator.jfuse.api.Fuse;
 import org.cryptomator.jfuse.api.FuseConnInfo;
 import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
 import org.cryptomator.jfuse.api.Stat;
 import org.cryptomator.jfuse.api.Statvfs;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Path;
 import java.util.EnumSet;
 import java.util.Set;
-import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeoutException;
-import java.util.stream.Stream;
 
-public class HelloWorldFileSystem implements FuseOperations {
+import static org.cryptomator.jfuse.api.Stat.S_IFDIR;
+import static org.cryptomator.jfuse.api.Stat.S_IFREG;
 
-	private static final int S_IFDIR = 0040000;
-	private static final int S_IFREG = 0100000;
+public class HelloWorldFileSystem implements FuseOperations {
 
 	private static final Logger LOG = LoggerFactory.getLogger(HelloWorldFileSystem.class);
 
@@ -40,15 +40,16 @@ public static void main(String[] args) {
 		var fuseOps = new HelloWorldFileSystem(builder.errno());
 		try (var fuse = builder.build(fuseOps)) {
 			LOG.info("Mounting at {}...", mountPoint);
-			int result = fuse.mount("jfuse", mountPoint, "-s");
-			if (result == 0) {
-				LOG.info("Mounted to {}. Unmount to terminate this process", mountPoint);
-			} else {
-				LOG.error("Failed to mount to {}. Exit code: {}", mountPoint, result);
-			}
-		} catch (TimeoutException | CompletionException e) {
+			fuse.mount("jfuse", mountPoint, "-s");
+			LOG.info("Mounted to {}.", mountPoint);
+			LOG.info("Enter a anything to unmount...");
+			System.in.read();
+		} catch (MountFailedException | TimeoutException e) {
 			LOG.error("Un/Mounting failed. ", e);
 			System.exit(1);
+		} catch (IOException e) {
+			LOG.error("Failed to create mirror", e);
+			System.exit(1);
 		}
 	}
 
@@ -72,8 +73,9 @@ public int access(String path, int mask) {
 		return 0;
 	}
 
+	@SuppressWarnings("OctalInteger")
 	@Override
-	public int getattr(String path, Stat stat) {
+	public int getattr(String path, Stat stat, FileInfo fi) {
 		LOG.debug("getattr() {}", path);
 		if ("/".equals(path)) {
 			stat.setMode(S_IFDIR | 0755);
@@ -141,21 +143,23 @@ public int opendir(String path, FileInfo fi) {
 	}
 
 	@Override
-	public int readdir(String path, DirFiller filler, long offset, FileInfo fi) {
+	public int readdir(String path, DirFiller filler, long offset, FileInfo fi, int flags) {
 		LOG.debug("readdir() {} {}", path, offset);
-		var entries = Stream.of( //
-				".", //
-				"..", //
-				HELLO_PATH.substring(1), //
-				"aaa", //
-				"bbb", //
-				"ccc", //
-				"ddd", //
-				"xxx", //
-				"yyy", //
-				"zzz").skip(offset);
-		filler.fillNamesFromOffset(entries, offset);
-		return 0;
+		try {
+			filler.fill(".");
+			filler.fill("..");
+			filler.fill(HELLO_PATH.substring(1));
+			filler.fill("aaa");
+			filler.fill("bbb");
+			filler.fill("ccc");
+			filler.fill("ddd");
+			filler.fill("xxx");
+			filler.fill("yyy");
+			filler.fill("zzz");
+			return 0;
+		} catch (IOException e) {
+			return -errno.eio();
+		}
 	}
 
 	@Override
diff --git a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/PosixMirrorFileSystem.java b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/PosixMirrorFileSystem.java
index 4f503cbd..05da530b 100644
--- a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/PosixMirrorFileSystem.java
+++ b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/PosixMirrorFileSystem.java
@@ -1,8 +1,10 @@
 package org.cryptomator.jfuse.examples;
 
 import org.cryptomator.jfuse.api.Errno;
+import org.cryptomator.jfuse.api.FileInfo;
 import org.cryptomator.jfuse.api.FileModes;
 import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.MountFailedException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -16,7 +18,6 @@
 import java.nio.file.attribute.PosixFileAttributes;
 import java.nio.file.attribute.PosixFilePermission;
 import java.util.Set;
-import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeoutException;
 
 public final class PosixMirrorFileSystem extends AbstractMirrorFileSystem {
@@ -32,15 +33,11 @@ public static void main(String[] args) {
 		var builder = Fuse.builder();
 		try (var fuse = builder.build(new PosixMirrorFileSystem(mirrored, builder.errno()))) {
 			LOG.info("Mounting at {}...", mountPoint);
-			int result = fuse.mount("jfuse", mountPoint, "-s", "-ovolname=mirror");
-			if (result == 0) {
-				LOG.info("Mounted to {}. Unmount to terminate this process", mountPoint);
-			} else {
-				LOG.error("Failed to mount to {}. Exit code: {}", mountPoint, result);
-			}
+			fuse.mount("jfuse", mountPoint, "-s");
+			LOG.info("Mounted to {}.", mountPoint);
 			LOG.info("Enter a anything to unmount...");
 			System.in.read();
-		} catch (TimeoutException | CompletionException e) {
+		} catch (MountFailedException | TimeoutException e) {
 			LOG.error("Un/Mounting failed. ", e);
 			System.exit(1);
 		} catch (IOException e) {
@@ -66,7 +63,7 @@ protected PosixFileAttributes readAttributes(Path node) throws IOException {
 	}
 
 	@Override
-	public int chmod(String path, int mode) {
+	public int chmod(String path, int mode, FileInfo fi) {
 		LOG.trace("chmod {}", path);
 		Path node = resolvePath(path);
 		try {
diff --git a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/RandomFileStructure.java b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/RandomFileStructure.java
new file mode 100644
index 00000000..d65898b6
--- /dev/null
+++ b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/RandomFileStructure.java
@@ -0,0 +1,79 @@
+package org.cryptomator.jfuse.examples;
+
+import java.time.Instant;
+import java.util.Base64;
+import java.util.Collections;
+import java.util.SortedMap;
+import java.util.TreeMap;
+import java.util.random.RandomGenerator;
+import java.util.random.RandomGeneratorFactory;
+
+/**
+ * A pseudo-randomized readonly file tree.
+ */
+public class RandomFileStructure {
+
+	private static final SortedMap<String, Node> NO_CHILDREN = Collections.unmodifiableSortedMap(new TreeMap<>());
+
+	private final Node root;
+
+	private RandomFileStructure(Node root) {
+		this.root = root;
+	}
+
+	public static RandomFileStructure init(long seed, int maxChildren) {
+		RandomGenerator rng = RandomGeneratorFactory.getDefault().create(seed);
+		var children = new TreeMap<String, Node>();
+		for (int i = 0; i < maxChildren; i++) {
+			var child = genNode(rng, maxChildren / 2);
+			children.put(child.name, child);
+		}
+		var root = new Node("",true, Instant.EPOCH, 0, children);
+		return new RandomFileStructure(root);
+	}
+
+	private static Node genNode(RandomGenerator rng, int nChildren) {
+		var bytes = new byte[15];
+		rng.nextBytes(bytes);
+		var name = Base64.getUrlEncoder().encodeToString(bytes);
+		var isDir = rng.nextInt(10) < 1; // 10% directories
+		var lastModified = Instant.ofEpochSecond(rng.nextLong(0, 32503676399L));
+		if (isDir) {
+			var children = new TreeMap<String, Node>();
+			for (int i = 0; i < nChildren; i++) {
+				var child = genNode(rng, nChildren / 4);
+				children.put(child.name, child);
+			}
+			return new Node(name, true, lastModified, 0, children);
+		} else {
+			var size = rng.nextInt(0, 500_000_000);
+			return new Node(name, false, lastModified, size, NO_CHILDREN);
+		}
+	}
+
+	public Node getNode(String absPath) {
+		assert absPath.indexOf('/') == 0;
+		var subPath = absPath.substring(1);
+		return getNode(root, subPath);
+	}
+
+	private Node getNode(Node base, String relPath) {
+		int idx = relPath.indexOf('/');
+		var current = idx == -1 ? relPath : relPath.substring(0, idx);
+		var remaining = idx == -1 ? "" : relPath.substring(idx + 1);
+		if (current.isEmpty()) {
+			return base;
+		} else {
+			var child = base.children.get(current);
+			if (child == null) {
+				return null;
+			} else {
+				return getNode(child, remaining);
+			}
+		}
+	}
+
+	public record Node (String name, boolean isDir, Instant lastModified, long size, SortedMap<String, Node> children) {
+	}
+
+}
diff --git a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/RandomFileSystem.java b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/RandomFileSystem.java
new file mode 100644
index 00000000..6336c43d
--- /dev/null
+++ b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/RandomFileSystem.java
@@ -0,0 +1,157 @@
+package org.cryptomator.jfuse.examples;
+
+import org.cryptomator.jfuse.api.DirFiller;
+import org.cryptomator.jfuse.api.Errno;
+import org.cryptomator.jfuse.api.FileInfo;
+import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.api.Stat;
+import org.cryptomator.jfuse.api.Statvfs;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.file.Path;
+import java.util.EnumSet;
+import java.util.Set;
+import java.util.concurrent.TimeoutException;
+
+import static org.cryptomator.jfuse.api.Stat.S_IFDIR;
+import static org.cryptomator.jfuse.api.Stat.S_IFREG;
+
+public class RandomFileSystem implements FuseOperations {
+
+	private static final Logger LOG = LoggerFactory.getLogger(RandomFileSystem.class);
+
+	private final Errno errno;
+	private final RandomFileStructure rfs;
+
+
+	public static void main(String[] args) {
+		if (args.length != 1) {
+			LOG.error("Invalid number of arguments. Expected {mountPoint}.");
+		}
+		Path mountPoint = Path.of(args[0]);
+		var builder = Fuse.builder();
+		var fuseOps = new RandomFileSystem(builder.errno());
+		try (var fuse = builder.build(fuseOps)) {
+			LOG.info("Mounting at {}...", mountPoint);
+			fuse.mount("jfuse", mountPoint, "-s");
+			LOG.info("Mounted to {}.", mountPoint);
+			LOG.info("Enter a anything to unmount...");
+			System.in.read();
+		} catch (MountFailedException | TimeoutException e) {
+			LOG.error("Un/Mounting failed. ", e);
+			System.exit(1);
+		} catch (IOException e) {
+			LOG.error("Failed to create mirror", e);
+			System.exit(1);
+		}
+	}
+
+	public RandomFileSystem(Errno errno) {
+		this.errno = errno;
+		this.rfs = RandomFileStructure.init(42L, 100);
+	}
+
+	@Override
+	public Errno errno() {
+		return errno;
+	}
+
+	@Override
+	public Set<Operation> supportedOperations() {
+		return EnumSet.of(Operation.GET_ATTR, Operation.OPEN, Operation.OPEN_DIR, Operation.READ, Operation.READ_DIR, Operation.RELEASE, Operation.RELEASE_DIR, Operation.STATFS, Operation.INIT);
+	}
+
+	@Override
+	public int getattr(String path, Stat stat, FileInfo fi) {
+		LOG.debug("getattr() {}", path);
+		var node = rfs.getNode(path);
+		if (node == null) {
+			return -errno.enoent();
+		} else {
+			fillStats(node, stat);
+			return 0;
+		}
+	}
+
+	@SuppressWarnings("OctalInteger")
+	private void fillStats(RandomFileStructure.Node node, Stat stat){
+		if (node.isDir()) {
+			stat.setMode(S_IFDIR | 0755);
+			stat.setNLink((short) (2 + node.children().values().stream().filter(RandomFileStructure.Node::isDir).count()));
+			stat.mTime().set(node.lastModified());
+		} else {
+			stat.setMode(S_IFREG | 0444);
+			stat.setNLink((short) 1);
+			stat.setSize(0);
+			stat.mTime().set(node.lastModified());
+		}
+	}
+
+	@Override
+	public int open(String path, FileInfo fi) {
+		return 0;
+	}
+
+	@Override
+	public int read(String path, ByteBuffer buf, long size, long offset, FileInfo fi) {
+		return 0;
+	}
+
+	@Override
+	public int release(String path, FileInfo fi) {
+		return 0;
+	}
+
+	@Override
+	public int opendir(String path, FileInfo fi) {
+		LOG.debug("opendir() {}", path);
+		return 0;
+	}
+
+	@Override
+	public int readdir(String path, DirFiller filler, long offset, FileInfo fi, int flags) {
+		LOG.debug("readdir() {} offset={} plus={}", path, offset, (flags & FUSE_READDIR_PLUS) == flags);
+		var node = rfs.getNode(path);
+		if (node == null) {
+			return -errno.enoent();
+		} else if (!node.isDir()) {
+			return -errno.enotdir();
+		} else {
+			if (offset == 0 && filler.fill(".", stat -> fillStats(node, stat), ++offset, DirFiller.FUSE_FILL_DIR_PLUS) != 0)
+				return 0;
+			if (offset == 1 && filler.fill("..", stat -> {}, ++offset, 0) != 0)
+				return 0;
+			assert offset > 1;
+			var childIter = node.children().values().stream().skip(offset - 2).iterator();
+			while (childIter.hasNext()) {
+				var child = childIter.next();
+				if (filler.fill(child.name(), stat -> fillStats(child, stat), ++offset, DirFiller.FUSE_FILL_DIR_PLUS) != 0) {
+					return 0;
+				}
+			}
+			return 0;
+		}
+	}
+
+	@Override
+	public int releasedir(String path, FileInfo fi) {
+		LOG.debug("releasedir() {}", path);
+		return 0;
+	}
+
+	@Override
+	public int statfs(String path, Statvfs statvfs) {
+		LOG.debug("statfs() {}", path);
+		statvfs.setNameMax(255);
+		statvfs.setBsize(4096);
+		statvfs.setBlocks(1000);
+		statvfs.setBfree(500);
+		statvfs.setBavail(500);
+		return 0;
+	}
+}
diff --git a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/WindowsMirrorFileSystem.java b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/WindowsMirrorFileSystem.java
index 8ccb5e18..16f52a34 100644
--- a/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/WindowsMirrorFileSystem.java
+++ b/jfuse-examples/src/main/java/org/cryptomator/jfuse/examples/WindowsMirrorFileSystem.java
@@ -2,6 +2,7 @@
 
 import org.cryptomator.jfuse.api.Errno;
 import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.MountFailedException;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -15,7 +16,6 @@
 import java.nio.file.attribute.FileAttribute;
 import java.nio.file.attribute.PosixFilePermission;
 import java.util.Set;
-import java.util.concurrent.CompletionException;
 import java.util.concurrent.TimeoutException;
 
 public final class WindowsMirrorFileSystem extends AbstractMirrorFileSystem {
@@ -31,15 +31,11 @@ public static void main(String[] args) {
 		var builder = Fuse.builder();
 		try (var fuse = builder.build(new WindowsMirrorFileSystem(mirrored, builder.errno()))) {
 			LOG.info("Mounting at {}...", mountPoint);
-			int result = fuse.mount("jfuse", mountPoint, "-s", "-ouid=-1", "-ogid=11", "-ovolname=mirror");
-			if (result == 0) {
-				LOG.info("Mounted to {}. Unmount to terminate this process", mountPoint);
-			} else {
-				LOG.error("Failed to mount to {}. Exit code: {}", mountPoint, result);
-			}
+			fuse.mount("jfuse", mountPoint, "-s", "-ouid=-1", "-ogid=11", "-ovolname=mirror");
+			LOG.info("Mounted to {}.", mountPoint);
 			LOG.info("Enter a anything to unmount...");
 			System.in.read();
-		} catch (TimeoutException | CompletionException e) {
+		} catch (MountFailedException | TimeoutException e) {
 			LOG.error("Un/Mounting failed. ", e);
 			System.exit(1);
 		} catch (IOException e) {
diff --git a/jfuse-linux-aarch64/pom.xml b/jfuse-linux-aarch64/pom.xml
index 91933b37..2f64bc68 100644
--- a/jfuse-linux-aarch64/pom.xml
+++ b/jfuse-linux-aarch64/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<artifactId>jfuse</artifactId>
 		<groupId>org.cryptomator</groupId>
-		<version>0.1.0</version>
+		<version>0.2.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jfuse-linux-aarch64</artifactId>
@@ -14,7 +14,7 @@
 	<url>https://github.com/cryptomator/jfuse/tree/develop/jfuse-linux-aarch64</url>
 
 	<properties>
-		<linux.headerSearchPath>/usr/aarch64-linux-gnu/include/</linux.headerSearchPath> <!-- debian package libc6-dev-aarch64-cross -->
+		<linux.headerSearchPath>/Users/sebastian/Documents/inc/aarch64-linux-gnu/include</linux.headerSearchPath> <!-- debian package libc6-dev-aarch64-cross -->
 	</properties>
 
 	<dependencies>
@@ -43,7 +43,6 @@
 									<rules>
 										<requireOS>
 											<family>unix</family>
-											<name>linux</name>
 											<message>This build configuration requires Linux.</message>
 										</requireOS>
 										<requireFilesExist>
@@ -88,16 +87,22 @@
 									<goal>sources</goal>
 								</goals>
 								<configuration>
-									<headerFile>${project.parent.basedir}/libfuse/include/fuse.h</headerFile>
+									<headerFile>${project.parent.basedir}/libfuse3/include/fuse.h</headerFile>
 									<headerClassName>fuse_h</headerClassName>
 									<cPreprocessorMacros>
 										<cPreprocessorMacro>_FILE_OFFSET_BITS=64</cPreprocessorMacro>
-										<cPreprocessorMacro>FUSE_USE_VERSION=29</cPreprocessorMacro>
+										<cPreprocessorMacro>FUSE_USE_VERSION=35</cPreprocessorMacro>
 									</cPreprocessorMacros>
 									<includeFunctions>
-										<includeFunction>fuse_main_real</includeFunction>
-										<includeFunction>fuse_get_context</includeFunction>
+										<includeFunction>fuse_lib_help</includeFunction>
+										<includeFunction>fuse_new</includeFunction>
+										<includeFunction>fuse_mount</includeFunction>
+										<includeFunction>fuse_get_session</includeFunction>
+										<includeFunction>fuse_loop</includeFunction>
+										<includeFunction>fuse_loop_mt</includeFunction>
 										<includeFunction>fuse_exit</includeFunction>
+										<includeFunction>fuse_unmount</includeFunction>
+										<includeFunction>fuse_destroy</includeFunction>
 									</includeFunctions>
 									<includeTypedefs>
 										<includeTypedef>fuse_fill_dir_t</includeTypedef>
@@ -105,11 +110,33 @@
 									<includeStructs>
 										<includeStruct>fuse_operations</includeStruct>
 										<includeStruct>fuse_file_info</includeStruct>
-										<includeStruct>fuse_context</includeStruct>
 										<includeStruct>stat</includeStruct>
 										<includeStruct>statvfs</includeStruct>
 										<includeStruct>timespec</includeStruct>
 										<includeStruct>fuse_conn_info</includeStruct>
+										<includeStruct>fuse_args</includeStruct>
+										<includeStruct>fuse_loop_config</includeStruct>
+									</includeStructs>
+								</configuration>
+							</execution>
+							<execution>
+								<id>jextract-fuse-lowlevel</id>
+								<goals>
+									<goal>sources</goal>
+								</goals>
+								<configuration>
+									<headerFile>${project.parent.basedir}/libfuse3/include/fuse_lowlevel.h</headerFile>
+									<targetPackage>org.cryptomator.jfuse.linux.aarch64.extr.ll</targetPackage>
+									<headerClassName>fuse_lowlevel_h</headerClassName>
+									<cPreprocessorMacros>
+										<cPreprocessorMacro>_FILE_OFFSET_BITS=64</cPreprocessorMacro>
+										<cPreprocessorMacro>FUSE_USE_VERSION=35</cPreprocessorMacro>
+									</cPreprocessorMacros>
+									<includeFunctions>
+										<includeFunction>fuse_parse_cmdline</includeFunction>
+									</includeFunctions>
+									<includeStructs>
+										<includeStruct>fuse_cmdline_opts</includeStruct>
 									</includeStructs>
 								</configuration>
 							</execution>
@@ -146,9 +173,6 @@
 									<headerFile>${linux.headerSearchPath}/sys/stat.h</headerFile>
 									<headerClassName>stat_h</headerClassName>
 									<includeMacros>
-										<includeMacro>S_IFREG</includeMacro>
-										<includeMacro>S_IFDIR</includeMacro>
-										<includeMacro>S_IFLNK</includeMacro>
 										<includeMacro>UTIME_NOW</includeMacro>
 										<includeMacro>UTIME_OMIT</includeMacro>
 									</includeMacros>
@@ -175,6 +199,25 @@
 									</includeMacros>
 								</configuration>
 							</execution>
+							<execution>
+								<id>jextract-stdio</id>
+								<goals>
+									<goal>sources</goal>
+								</goals>
+								<configuration>
+									<headerFile>${linux.headerSearchPath}/stdio.h</headerFile>
+									<headerClassName>stdio_h</headerClassName>
+									<cPreprocessorMacros>
+										<cPreprocessorMacro>_GNU_SOURCE=1</cPreprocessorMacro>
+									</cPreprocessorMacros>
+									<includeMacros>
+										<!-- GNU-specific flags for rename: -->
+										<includeMacro>RENAME_NOREPLACE</includeMacro>
+										<includeMacro>RENAME_EXCHANGE</includeMacro>
+										<includeMacro>RENAME_WHITEOUT</includeMacro>
+									</includeMacros>
+								</configuration>
+							</execution>
 						</executions>
 					</plugin>
 				</plugins>
diff --git a/jfuse-linux-aarch64/src/main/java/module-info.java b/jfuse-linux-aarch64/src/main/java/module-info.java
index dc6638c7..ef615d22 100644
--- a/jfuse-linux-aarch64/src/main/java/module-info.java
+++ b/jfuse-linux-aarch64/src/main/java/module-info.java
@@ -3,6 +3,8 @@
 
 @SuppressWarnings("JavaModuleNaming") // 64 is not a "version", see https://bugs.openjdk.java.net/browse/JDK-8264488
 module org.cryptomator.jfuse.linux.aarch64 {
+	requires static org.jetbrains.annotations;
+
 	requires org.cryptomator.jfuse.api;
 
 	provides FuseBuilder with LinuxFuseBuilder;
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java
index f86a7826..f1a8a503 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/DirFillerImpl.java
@@ -3,9 +3,13 @@
 import org.cryptomator.jfuse.api.DirFiller;
 import org.cryptomator.jfuse.api.Stat;
 import org.cryptomator.jfuse.linux.aarch64.extr.fuse_fill_dir_t;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_h;
+import org.cryptomator.jfuse.linux.aarch64.extr.stat;
 
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemorySession;
+import java.util.Set;
+import java.util.function.Consumer;
 
 record DirFillerImpl(MemoryAddress buf, fuse_fill_dir_t callback, MemorySession scope) implements DirFiller {
 
@@ -14,9 +18,10 @@ record DirFillerImpl(MemoryAddress buf, fuse_fill_dir_t callback, MemorySession
 	}
 
 	@Override
-	public int fill(String name, Stat stat, long offset) {
-		var statAddr = stat instanceof StatImpl s ? s.segment().address() : MemoryAddress.NULL;
-		return callback.apply(buf, scope.allocateUtf8String(name).address(), statAddr, offset);
+	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
+		var statSegment = stat.allocate(scope);
+		statFiller.accept(new StatImpl(statSegment));
+		return callback.apply(buf, scope.allocateUtf8String(name).address(), statSegment.address(), offset, flags);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseArgs.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseArgs.java
new file mode 100644
index 00000000..9d4014e3
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseArgs.java
@@ -0,0 +1,34 @@
+package org.cryptomator.jfuse.linux.aarch64;
+
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_args;
+import org.cryptomator.jfuse.linux.aarch64.extr.ll.fuse_cmdline_opts;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+record FuseArgs(MemorySegment args, MemorySegment cmdLineOpts) {
+
+	@Override
+	public String toString() {
+		var sb = new StringBuilder();
+		var argc = fuse_args.argc$get(args);
+		var argv = fuse_args.argv$get(args);
+		for (int i = 0; i < argc; i++) {
+			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i);
+			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+		}
+		sb.append("mountPoint = ").append(mountPoint().getUtf8String(0));
+		sb.append("debug = ").append(fuse_cmdline_opts.debug$get(cmdLineOpts));
+		sb.append("singlethreaded = ").append(!multithreaded());
+		return sb.toString();
+	}
+
+	public MemoryAddress mountPoint() {
+		return fuse_cmdline_opts.mountpoint$get(cmdLineOpts);
+	}
+
+	public boolean multithreaded() {
+		return fuse_cmdline_opts.singlethread$get(cmdLineOpts) == 0;
+	}
+}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java
index 30b6b147..91be8363 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImpl.java
@@ -22,4 +22,80 @@ public int protoMajor() {
 	public int protoMinor() {
 		return fuse_conn_info.proto_minor$get(segment);
 	}
+
+	@Override
+	public int capable() {
+		return fuse_conn_info.capable$get(segment);
+	}
+
+	@Override
+	public int want() {
+		return fuse_conn_info.want$get(segment);
+	}
+
+	@Override
+	public void setWant(int wanted) {
+		fuse_conn_info.want$set(segment, wanted);
+	}
+
+	@Override
+	public int maxWrite() {
+		return fuse_conn_info.max_write$get(segment);
+	}
+
+	@Override
+	public void setMaxWrite(int maxWrite) {
+		fuse_conn_info.max_write$set(segment, maxWrite);
+	}
+
+	@Override
+	public int maxRead() {
+		return fuse_conn_info.max_read$get(segment);
+	}
+
+	@Override
+	public void setMaxRead(int maxRead) {
+		fuse_conn_info.max_read$set(segment, maxRead);
+	}
+
+	@Override
+	public int maxReadahead() {
+		return fuse_conn_info.max_readahead$get(segment);
+	}
+
+	@Override
+	public void setMaxReadahead(int maxReadahead) {
+		fuse_conn_info.max_readahead$set(segment, maxReadahead);
+	}
+
+	@Override
+	public int maxBackground() {
+		return fuse_conn_info.max_background$get(segment);
+	}
+
+	@Override
+	public void setMaxBackground(int maxBackground) {
+		fuse_conn_info.max_background$set(segment, maxBackground);
+	}
+
+	@Override
+	public int congestionThreshold() {
+		return fuse_conn_info.congestion_threshold$get(segment);
+	}
+
+	@Override
+	public void setCongestionThreshold(int congestionThreshold) {
+		fuse_conn_info.congestion_threshold$set(segment, congestionThreshold);
+	}
+
+	@Override
+	public int timeGran() {
+		return fuse_conn_info.time_gran$get(segment);
+	}
+
+	@Override
+	public void setTimeGran(int timeGran) {
+		fuse_conn_info.time_gran$set(segment, timeGran);
+	}
+
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java
index 136202a3..b7e084a0 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseImpl.java
@@ -1,95 +1,122 @@
 package org.cryptomator.jfuse.linux.aarch64;
 
 import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.api.FuseMount;
 import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_args;
 import org.cryptomator.jfuse.linux.aarch64.extr.fuse_h;
 import org.cryptomator.jfuse.linux.aarch64.extr.fuse_operations;
+import org.cryptomator.jfuse.linux.aarch64.extr.ll.fuse_cmdline_opts;
+import org.cryptomator.jfuse.linux.aarch64.extr.ll.fuse_lowlevel_h;
 import org.cryptomator.jfuse.linux.aarch64.extr.stat_h;
 import org.cryptomator.jfuse.linux.aarch64.extr.timespec;
+import org.jetbrains.annotations.VisibleForTesting;
 
+import java.lang.foreign.Addressable;
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.MemorySession;
-import java.nio.ByteBuffer;
-import java.util.concurrent.CompletableFuture;
+import java.lang.foreign.ValueLayout;
+import java.util.List;
 
 public final class FuseImpl extends Fuse {
 
-	private final CompletableFuture<Integer> initialized = new CompletableFuture<>();
 	private final FuseOperations delegate;
-	private final MemorySegment struct;
+	private final MemorySegment fuseOps;
 
 	public FuseImpl(FuseOperations fuseOperations) {
-		this.struct = fuse_operations.allocate(fuseScope);
+		this.fuseOps = fuse_operations.allocate(fuseScope);
 		this.delegate = fuseOperations;
-		fuse_operations.init$set(struct, fuse_operations.init.allocate(this::init, fuseScope).address());
 		fuseOperations.supportedOperations().forEach(this::bind);
 	}
 
-	private MemoryAddress init(MemoryAddress conn) {
-		try (var scope = MemorySession.openConfined()) {
-			if (delegate.supportedOperations().contains(FuseOperations.Operation.INIT)) {
-				delegate.init(new FuseConnInfoImpl(conn, scope));
-			}
-			initialized.complete(0);
-		} catch (Exception e) {
-			initialized.completeExceptionally(e);
-		}
-		return MemoryAddress.NULL;
-	}
-
 	@Override
-	protected CompletableFuture<Integer> initialized() {
-		return initialized;
+	protected FuseMount mount(List<String> args) throws MountFailedException {
+		var fuseArgs = parseArgs(args);
+		var fuse = fuse_h.fuse_new(fuseArgs.args(), fuseOps, fuseOps.byteSize(), MemoryAddress.NULL);
+		if (MemoryAddress.NULL.equals(fuse)) {
+			throw new MountFailedException("fuse_new failed");
+		}
+		if (fuse_h.fuse_mount(fuse, fuseArgs.mountPoint()) != 0) {
+			throw new MountFailedException("fuse_mount failed");
+		}
+		return new FuseMountImpl(fuse, fuseArgs);
 	}
 
-	@Override
-	protected int fuseMain(int argc, MemorySegment argv) {
-		return fuse_h.fuse_main_real(argc, argv, struct, struct.byteSize(), MemoryAddress.NULL);
+	@VisibleForTesting
+	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
+		var args = fuse_args.allocate(fuseScope);
+		var argc = cmdLineArgs.size();
+		var argv = fuseScope.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		for (int i = 0; i < argc; i++) {
+			var cString = fuseScope.allocateUtf8String(cmdLineArgs.get(i));
+			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
+		}
+		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemoryAddress.NULL);
+		fuse_args.argc$set(args, argc);
+		fuse_args.argv$set(args, argv.address());
+		fuse_args.allocated$set(args, 0);
+
+		var opts = fuse_cmdline_opts.allocate(fuseScope);
+		int parseResult = fuse_lowlevel_h.fuse_parse_cmdline(args, opts);
+		if (parseResult != 0) {
+			throw new IllegalArgumentException("fuse_parse_cmdline failed to parse " + String.join(" ", cmdLineArgs));
+		}
+		if (fuse_cmdline_opts.show_help$get(opts) == 1) {
+			fuse_h.fuse_lib_help(args);
+			throw new IllegalArgumentException("Flags contained -h or --help. Processing cancelled after printing help");
+		}
+		return new FuseArgs(args, opts);
 	}
 
-//	private void exit() {
-//		try (var scope = ResourceScope.newConfinedScope()) {
-//			var ctx = fuse_context.ofAddress(fuse_h.fuse_get_context(), fuseScope);
-//			var fusePtr = fuse_context.fuse$get(ctx);
-//			fuse_h.fuse_exit(fusePtr);
-//		}
-//	}
-
 	private void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> { /* handled already */ }
-			case ACCESS -> fuse_operations.access$set(struct, fuse_operations.access.allocate(this::access, fuseScope).address());
-			case CHMOD -> fuse_operations.chmod$set(struct, fuse_operations.chmod.allocate(this::chmod, fuseScope).address());
-			case CREATE -> fuse_operations.create$set(struct, fuse_operations.create.allocate(this::create, fuseScope).address());
-			case DESTROY -> fuse_operations.destroy$set(struct, fuse_operations.destroy.allocate(this::destroy, fuseScope).address());
-			case GET_ATTR -> fuse_operations.getattr$set(struct, fuse_operations.getattr.allocate(this::getattr, fuseScope).address());
-			case MKDIR -> fuse_operations.mkdir$set(struct, fuse_operations.mkdir.allocate(this::mkdir, fuseScope).address());
-			case OPEN -> fuse_operations.open$set(struct, fuse_operations.open.allocate(this::open, fuseScope).address());
-			case OPEN_DIR -> fuse_operations.opendir$set(struct, fuse_operations.opendir.allocate(this::opendir, fuseScope).address());
-			case READ -> fuse_operations.read$set(struct, fuse_operations.read.allocate(this::read, fuseScope).address());
-			case READ_DIR -> fuse_operations.readdir$set(struct, fuse_operations.readdir.allocate(this::readdir, fuseScope).address());
-			case READLINK -> fuse_operations.readlink$set(struct, fuse_operations.readlink.allocate(this::readlink, fuseScope).address());
-			case RELEASE -> fuse_operations.release$set(struct, fuse_operations.release.allocate(this::release, fuseScope).address());
-			case RELEASE_DIR -> fuse_operations.releasedir$set(struct, fuse_operations.releasedir.allocate(this::releasedir, fuseScope).address());
-			case RENAME -> fuse_operations.rename$set(struct, fuse_operations.rename.allocate(this::rename, fuseScope).address());
-			case RMDIR -> fuse_operations.rmdir$set(struct, fuse_operations.rmdir.allocate(this::rmdir, fuseScope).address());
-			case STATFS -> fuse_operations.statfs$set(struct, fuse_operations.statfs.allocate(this::statfs, fuseScope).address());
-			case SYMLINK -> fuse_operations.symlink$set(struct, fuse_operations.symlink.allocate(this::symlink, fuseScope).address());
-			case TRUNCATE -> fuse_operations.truncate$set(struct, fuse_operations.truncate.allocate(this::truncate, fuseScope).address());
-			case UNLINK -> fuse_operations.unlink$set(struct, fuse_operations.unlink.allocate(this::unlink, fuseScope).address());
-			case UTIMENS -> fuse_operations.utimens$set(struct, fuse_operations.utimens.allocate(this::utimens, fuseScope).address());
-			case WRITE -> fuse_operations.write$set(struct, fuse_operations.write.allocate(this::write, fuseScope).address());
+			case INIT -> fuse_operations.init$set(fuseOps, fuse_operations.init.allocate(this::init, fuseScope).address());
+			case ACCESS -> fuse_operations.access$set(fuseOps, fuse_operations.access.allocate(this::access, fuseScope).address());
+			case CHMOD -> fuse_operations.chmod$set(fuseOps, fuse_operations.chmod.allocate(this::chmod, fuseScope).address());
+			case CREATE -> fuse_operations.create$set(fuseOps, fuse_operations.create.allocate(this::create, fuseScope).address());
+			case DESTROY -> fuse_operations.destroy$set(fuseOps, fuse_operations.destroy.allocate(this::destroy, fuseScope).address());
+			case GET_ATTR -> fuse_operations.getattr$set(fuseOps, fuse_operations.getattr.allocate(this::getattr, fuseScope).address());
+			case MKDIR -> fuse_operations.mkdir$set(fuseOps, fuse_operations.mkdir.allocate(this::mkdir, fuseScope).address());
+			case OPEN -> fuse_operations.open$set(fuseOps, fuse_operations.open.allocate(this::open, fuseScope).address());
+			case OPEN_DIR -> fuse_operations.opendir$set(fuseOps, fuse_operations.opendir.allocate(this::opendir, fuseScope).address());
+			case READ -> fuse_operations.read$set(fuseOps, fuse_operations.read.allocate(this::read, fuseScope).address());
+			case READ_DIR -> fuse_operations.readdir$set(fuseOps, fuse_operations.readdir.allocate(this::readdir, fuseScope).address());
+			case READLINK -> fuse_operations.readlink$set(fuseOps, fuse_operations.readlink.allocate(this::readlink, fuseScope).address());
+			case RELEASE -> fuse_operations.release$set(fuseOps, fuse_operations.release.allocate(this::release, fuseScope).address());
+			case RELEASE_DIR -> fuse_operations.releasedir$set(fuseOps, fuse_operations.releasedir.allocate(this::releasedir, fuseScope).address());
+			case RENAME -> fuse_operations.rename$set(fuseOps, fuse_operations.rename.allocate(this::rename, fuseScope).address());
+			case RMDIR -> fuse_operations.rmdir$set(fuseOps, fuse_operations.rmdir.allocate(this::rmdir, fuseScope).address());
+			case STATFS -> fuse_operations.statfs$set(fuseOps, fuse_operations.statfs.allocate(this::statfs, fuseScope).address());
+			case SYMLINK -> fuse_operations.symlink$set(fuseOps, fuse_operations.symlink.allocate(this::symlink, fuseScope).address());
+			case TRUNCATE -> fuse_operations.truncate$set(fuseOps, fuse_operations.truncate.allocate(this::truncate, fuseScope).address());
+			case UNLINK -> fuse_operations.unlink$set(fuseOps, fuse_operations.unlink.allocate(this::unlink, fuseScope).address());
+			case UTIMENS -> fuse_operations.utimens$set(fuseOps, fuse_operations.utimens.allocate(this::utimens, fuseScope).address());
+			case WRITE -> fuse_operations.write$set(fuseOps, fuse_operations.write.allocate(this::write, fuseScope).address());
+		}
+	}
+
+	@VisibleForTesting
+	Addressable init(MemoryAddress conn, MemoryAddress fuseConfig) {
+		try (var scope = MemorySession.openConfined()) {
+			var connInfo = new FuseConnInfoImpl(conn, scope);
+			connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
+			delegate.init(connInfo);
 		}
+		return MemoryAddress.NULL;
 	}
 
 	private int access(MemoryAddress path, int mask) {
 		return delegate.access(path.getUtf8String(0), mask);
 	}
 
-	private int chmod(MemoryAddress path, int mode) {
-		return delegate.chmod(path.getUtf8String(0), mode);
+	private int chmod(MemoryAddress path, int mode, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.chmod(path.getUtf8String(0), mode, new FileInfoImpl(fi, scope));
+		}
 	}
 
 	private int create(MemoryAddress path, int mode, MemoryAddress fi) {
@@ -102,9 +129,9 @@ private void destroy(MemoryAddress addr) {
 		delegate.destroy();
 	}
 
-	private int getattr(MemoryAddress path, MemoryAddress stat) {
+	private int getattr(MemoryAddress path, MemoryAddress stat, MemoryAddress fi) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope));
+			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope), new FileInfoImpl(fi, scope));
 		}
 	}
 
@@ -131,9 +158,9 @@ private int read(MemoryAddress path, MemoryAddress buf, long size, long offset,
 		}
 	}
 
-	private int readdir(MemoryAddress path, MemoryAddress buf, MemoryAddress filler, long offset, MemoryAddress fi) {
+	private int readdir(MemoryAddress path, MemoryAddress buf, MemoryAddress filler, long offset, MemoryAddress fi, int flags) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope));
+			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope), flags);
 		}
 	}
 
@@ -156,8 +183,8 @@ private int releasedir(MemoryAddress path, MemoryAddress fi) {
 		}
 	}
 
-	private int rename(MemoryAddress oldpath, MemoryAddress newpath) {
-		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0));
+	private int rename(MemoryAddress oldpath, MemoryAddress newpath, int flags) {
+		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), flags);
 	}
 
 	private int rmdir(MemoryAddress path) {
@@ -174,30 +201,33 @@ private int symlink(MemoryAddress linkname, MemoryAddress target) {
 		return delegate.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
 	}
 
-	private int truncate(MemoryAddress path, long size) {
-		return delegate.truncate(path.getUtf8String(0), size);
+	private int truncate(MemoryAddress path, long size, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.truncate(path.getUtf8String(0), size, new FileInfoImpl(fi, scope));
+		}
 	}
 
+
 	private int unlink(MemoryAddress path) {
 		return delegate.unlink(path.getUtf8String(0));
 	}
 
-	private int utimens(MemoryAddress path, MemoryAddress times) {
-		if (MemoryAddress.NULL.equals(times)) {
-			// set both times to current time (using on-heap memory segments)
-			var segment = MemorySegment.ofBuffer(ByteBuffer.allocate((int) timespec.$LAYOUT().byteSize()));
-			timespec.tv_sec$set(segment, 0);
-			timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
-			var time = new TimeSpecImpl(segment);
-			return delegate.utimens(path.getUtf8String(0), time, time);
-		} else {
-			try (var scope = MemorySession.openConfined()) {
+	@VisibleForTesting
+	int utimens(MemoryAddress path, MemoryAddress times, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			if (MemoryAddress.NULL.equals(times)) {
+				// set both times to current time (using on-heap memory segments)
+				var segment = MemorySegment.allocateNative(timespec.$LAYOUT().byteSize(), scope);
+				timespec.tv_sec$set(segment, 0);
+				timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
+				var time = new TimeSpecImpl(segment);
+				return delegate.utimens(path.getUtf8String(0), time, time, new FileInfoImpl(fi, scope));
+			} else {
 				var seq = MemoryLayout.sequenceLayout(2, timespec.$LAYOUT());
 				var segment = MemorySegment.ofAddress(times, seq.byteSize(), scope);
 				var time0 = segment.asSlice(0, timespec.$LAYOUT().byteSize());
 				var time1 = segment.asSlice(timespec.$LAYOUT().byteSize(), timespec.$LAYOUT().byteSize());
-//				var timeSpecs = segment.elements(seq.elementLayout()).map(MacTimeSpec::new).toArray(MacTimeSpec[]::new);
-				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1));
+				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), new FileInfoImpl(fi, scope));
 			}
 		}
 	}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseMountImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseMountImpl.java
new file mode 100644
index 00000000..f1dbf07b
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/FuseMountImpl.java
@@ -0,0 +1,36 @@
+package org.cryptomator.jfuse.linux.aarch64;
+
+import org.cryptomator.jfuse.api.FuseMount;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_h;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_loop_config;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySession;
+
+record FuseMountImpl(MemoryAddress fuse, FuseArgs fuseArgs) implements FuseMount {
+
+	@Override
+	public int loop() {
+		if (fuseArgs.multithreaded()) {
+			try (var scope = MemorySession.openConfined()) {
+				var loopCfg = fuse_loop_config.allocate(scope);
+				fuse_loop_config.clone_fd$set(loopCfg, 0);
+				fuse_loop_config.max_idle_threads$set(loopCfg, 10);
+				return fuse_h.fuse_loop_mt(fuse, loopCfg);
+			}
+		} else {
+			return fuse_h.fuse_loop(fuse);
+		}
+	}
+
+	@Override
+	public void unmount() {
+		fuse_h.fuse_exit(fuse);
+		fuse_h.fuse_unmount(fuse);
+	}
+
+	@Override
+	public void destroy() {
+		fuse_h.fuse_destroy(fuse);
+	}
+}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/LinuxFuseBuilder.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/LinuxFuseBuilder.java
index 7a1d5153..221c138f 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/LinuxFuseBuilder.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/LinuxFuseBuilder.java
@@ -11,7 +11,7 @@
 @SupportedPlatform(os = OperatingSystem.LINUX, arch = Architecture.ARM64)
 public class LinuxFuseBuilder implements FuseBuilder {
 
-	private static final String DEFAULT_LIB_PATH = "/lib/aarch64-linux-gnu/libfuse.so.2.9.9";
+	private static final String DEFAULT_LIB_PATH = "/lib/aarch64-linux-gnu/libfuse3.so.3";
 	private static final Errno ERRNO = new LinuxErrno();
 	private String libraryPath;
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java
index 57996856..35be683d 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/StatImpl.java
@@ -66,46 +66,4 @@ public long getSize() {
 		return stat.st_size$get(segment);
 	}
 
-	@Override
-	public boolean isDir() {
-		return (getMode() & stat_h.S_IFDIR()) == stat_h.S_IFDIR();
-	}
-
-	@Override
-	public void toggleDir(boolean isDir) {
-		if (isDir) {
-			setMode(getMode() | stat_h.S_IFDIR());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFDIR());
-		}
-	}
-
-	@Override
-	public boolean isReg() {
-		return (getMode() & stat_h.S_IFREG()) == stat_h.S_IFREG();
-	}
-
-	@Override
-	public void toggleReg(boolean isReg) {
-		if (isReg) {
-			setMode(getMode() | stat_h.S_IFREG());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFREG());
-		}
-	}
-
-	@Override
-	public boolean isLnk() {
-		return (getMode() & stat_h.S_IFLNK()) == stat_h.S_IFLNK();
-	}
-
-	@Override
-	public void toggleLnk(boolean isLnk) {
-		if (isLnk) {
-			setMode(getMode() | stat_h.S_IFLNK());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFLNK());
-		}
-	}
-
 }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/constants$0.java
index fccd980b..57a7d35a 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/constants$0.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/constants$0.java
@@ -13,33 +13,43 @@ class constants$0 {
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_INT$LAYOUT
     );
     static final MethodHandle fuse_fill_dir_t$MH = RuntimeHelper.downcallHandle(
         constants$0.fuse_fill_dir_t$FUNC
     );
-    static final FunctionDescriptor fuse_exit$FUNC = FunctionDescriptor.ofVoid(
+    static final FunctionDescriptor fuse_lib_help$FUNC = FunctionDescriptor.ofVoid(
         Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_exit$MH = RuntimeHelper.downcallHandle(
-        "fuse_exit",
-        constants$0.fuse_exit$FUNC
-    );
-    static final FunctionDescriptor fuse_get_context$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT);
-    static final MethodHandle fuse_get_context$MH = RuntimeHelper.downcallHandle(
-        "fuse_get_context",
-        constants$0.fuse_get_context$FUNC
+    static final MethodHandle fuse_lib_help$MH = RuntimeHelper.downcallHandle(
+        "fuse_lib_help",
+        constants$0.fuse_lib_help$FUNC
     );
-    static final FunctionDescriptor fuse_main_real$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_INT$LAYOUT,
+    static final FunctionDescriptor fuse_new$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_main_real$MH = RuntimeHelper.downcallHandle(
-        "fuse_main_real",
-        constants$0.fuse_main_real$FUNC
+    static final MethodHandle fuse_new$MH = RuntimeHelper.downcallHandle(
+        "fuse_new",
+        constants$0.fuse_new$FUNC
+    );
+    static final FunctionDescriptor fuse_mount$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_mount$MH = RuntimeHelper.downcallHandle(
+        "fuse_mount",
+        constants$0.fuse_mount$FUNC
+    );
+    static final FunctionDescriptor fuse_unmount$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_unmount$MH = RuntimeHelper.downcallHandle(
+        "fuse_unmount",
+        constants$0.fuse_unmount$FUNC
     );
 }
 
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/constants$1.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/constants$1.java
new file mode 100644
index 00000000..6640ad95
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/constants$1.java
@@ -0,0 +1,50 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+class constants$1 {
+
+    static final FunctionDescriptor fuse_destroy$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_destroy$MH = RuntimeHelper.downcallHandle(
+        "fuse_destroy",
+        constants$1.fuse_destroy$FUNC
+    );
+    static final FunctionDescriptor fuse_loop$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_loop$MH = RuntimeHelper.downcallHandle(
+        "fuse_loop",
+        constants$1.fuse_loop$FUNC
+    );
+    static final FunctionDescriptor fuse_exit$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_exit$MH = RuntimeHelper.downcallHandle(
+        "fuse_exit",
+        constants$1.fuse_exit$FUNC
+    );
+    static final FunctionDescriptor fuse_loop_mt$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_loop_mt$MH = RuntimeHelper.downcallHandle(
+        "fuse_loop_mt",
+        constants$1.fuse_loop_mt$FUNC
+    );
+    static final FunctionDescriptor fuse_get_session$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_get_session$MH = RuntimeHelper.downcallHandle(
+        "fuse_get_session",
+        constants$1.fuse_get_session$FUNC
+    );
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_args.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_args.java
new file mode 100644
index 00000000..6cc3f68c
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_args.java
@@ -0,0 +1,78 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_args {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_INT$LAYOUT.withName("argc"),
+        MemoryLayout.paddingLayout(32),
+        Constants$root.C_POINTER$LAYOUT.withName("argv"),
+        Constants$root.C_INT$LAYOUT.withName("allocated"),
+        MemoryLayout.paddingLayout(32)
+    ).withName("fuse_args");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_args.$struct$LAYOUT;
+    }
+    static final VarHandle argc$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argc"));
+    public static VarHandle argc$VH() {
+        return fuse_args.argc$VH;
+    }
+    public static int argc$get(MemorySegment seg) {
+        return (int)fuse_args.argc$VH.get(seg);
+    }
+    public static void argc$set( MemorySegment seg, int x) {
+        fuse_args.argc$VH.set(seg, x);
+    }
+    public static int argc$get(MemorySegment seg, long index) {
+        return (int)fuse_args.argc$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argc$set(MemorySegment seg, long index, int x) {
+        fuse_args.argc$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle argv$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argv"));
+    public static VarHandle argv$VH() {
+        return fuse_args.argv$VH;
+    }
+    public static MemoryAddress argv$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg);
+    }
+    public static void argv$set( MemorySegment seg, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg, x);
+    }
+    public static MemoryAddress argv$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argv$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle allocated$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
+    public static VarHandle allocated$VH() {
+        return fuse_args.allocated$VH;
+    }
+    public static int allocated$get(MemorySegment seg) {
+        return (int)fuse_args.allocated$VH.get(seg);
+    }
+    public static void allocated$set( MemorySegment seg, int x) {
+        fuse_args.allocated$VH.set(seg, x);
+    }
+    public static int allocated$get(MemorySegment seg, long index) {
+        return (int)fuse_args.allocated$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void allocated$set(MemorySegment seg, long index, int x) {
+        fuse_args.allocated$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_conn_info.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_conn_info.java
index 10fbc252..d03be0f1 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_conn_info.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_conn_info.java
@@ -12,14 +12,15 @@ public class fuse_conn_info {
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_INT$LAYOUT.withName("proto_major"),
         Constants$root.C_INT$LAYOUT.withName("proto_minor"),
-        Constants$root.C_INT$LAYOUT.withName("async_read"),
         Constants$root.C_INT$LAYOUT.withName("max_write"),
+        Constants$root.C_INT$LAYOUT.withName("max_read"),
         Constants$root.C_INT$LAYOUT.withName("max_readahead"),
         Constants$root.C_INT$LAYOUT.withName("capable"),
         Constants$root.C_INT$LAYOUT.withName("want"),
         Constants$root.C_INT$LAYOUT.withName("max_background"),
         Constants$root.C_INT$LAYOUT.withName("congestion_threshold"),
-        MemoryLayout.sequenceLayout(23, Constants$root.C_INT$LAYOUT).withName("reserved")
+        Constants$root.C_INT$LAYOUT.withName("time_gran"),
+        MemoryLayout.sequenceLayout(22, Constants$root.C_INT$LAYOUT).withName("reserved")
     ).withName("fuse_conn_info");
     public static MemoryLayout $LAYOUT() {
         return fuse_conn_info.$struct$LAYOUT;
@@ -56,22 +57,6 @@ public class fuse_conn_info {
     public static void proto_minor$set(MemorySegment seg, long index, int x) {
         fuse_conn_info.proto_minor$VH.set(seg.asSlice(index*sizeof()), x);
     }
-    static final VarHandle async_read$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("async_read"));
-    public static VarHandle async_read$VH() {
-        return fuse_conn_info.async_read$VH;
-    }
-    public static int async_read$get(MemorySegment seg) {
-        return (int)fuse_conn_info.async_read$VH.get(seg);
-    }
-    public static void async_read$set( MemorySegment seg, int x) {
-        fuse_conn_info.async_read$VH.set(seg, x);
-    }
-    public static int async_read$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.async_read$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void async_read$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.async_read$VH.set(seg.asSlice(index*sizeof()), x);
-    }
     static final VarHandle max_write$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
     public static VarHandle max_write$VH() {
         return fuse_conn_info.max_write$VH;
@@ -88,6 +73,22 @@ public class fuse_conn_info {
     public static void max_write$set(MemorySegment seg, long index, int x) {
         fuse_conn_info.max_write$VH.set(seg.asSlice(index*sizeof()), x);
     }
+    static final VarHandle max_read$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_read"));
+    public static VarHandle max_read$VH() {
+        return fuse_conn_info.max_read$VH;
+    }
+    public static int max_read$get(MemorySegment seg) {
+        return (int)fuse_conn_info.max_read$VH.get(seg);
+    }
+    public static void max_read$set( MemorySegment seg, int x) {
+        fuse_conn_info.max_read$VH.set(seg, x);
+    }
+    public static int max_read$get(MemorySegment seg, long index) {
+        return (int)fuse_conn_info.max_read$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_read$set(MemorySegment seg, long index, int x) {
+        fuse_conn_info.max_read$VH.set(seg.asSlice(index*sizeof()), x);
+    }
     static final VarHandle max_readahead$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
     public static VarHandle max_readahead$VH() {
         return fuse_conn_info.max_readahead$VH;
@@ -168,8 +169,24 @@ public class fuse_conn_info {
     public static void congestion_threshold$set(MemorySegment seg, long index, int x) {
         fuse_conn_info.congestion_threshold$VH.set(seg.asSlice(index*sizeof()), x);
     }
+    static final VarHandle time_gran$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("time_gran"));
+    public static VarHandle time_gran$VH() {
+        return fuse_conn_info.time_gran$VH;
+    }
+    public static int time_gran$get(MemorySegment seg) {
+        return (int)fuse_conn_info.time_gran$VH.get(seg);
+    }
+    public static void time_gran$set( MemorySegment seg, int x) {
+        fuse_conn_info.time_gran$VH.set(seg, x);
+    }
+    public static int time_gran$get(MemorySegment seg, long index) {
+        return (int)fuse_conn_info.time_gran$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void time_gran$set(MemorySegment seg, long index, int x) {
+        fuse_conn_info.time_gran$VH.set(seg.asSlice(index*sizeof()), x);
+    }
     public static MemorySegment reserved$slice(MemorySegment seg) {
-        return seg.asSlice(36, 92);
+        return seg.asSlice(40, 88);
     }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_context.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_context.java
deleted file mode 100644
index a2f1d546..00000000
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_context.java
+++ /dev/null
@@ -1,129 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.aarch64.extr;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-public class fuse_context {
-
-    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
-        Constants$root.C_POINTER$LAYOUT.withName("fuse"),
-        Constants$root.C_INT$LAYOUT.withName("uid"),
-        Constants$root.C_INT$LAYOUT.withName("gid"),
-        Constants$root.C_INT$LAYOUT.withName("pid"),
-        MemoryLayout.paddingLayout(32),
-        Constants$root.C_POINTER$LAYOUT.withName("private_data"),
-        Constants$root.C_INT$LAYOUT.withName("umask"),
-        MemoryLayout.paddingLayout(32)
-    ).withName("fuse_context");
-    public static MemoryLayout $LAYOUT() {
-        return fuse_context.$struct$LAYOUT;
-    }
-    static final VarHandle fuse$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fuse"));
-    public static VarHandle fuse$VH() {
-        return fuse_context.fuse$VH;
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg);
-    }
-    public static void fuse$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg, x);
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fuse$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle uid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("uid"));
-    public static VarHandle uid$VH() {
-        return fuse_context.uid$VH;
-    }
-    public static int uid$get(MemorySegment seg) {
-        return (int)fuse_context.uid$VH.get(seg);
-    }
-    public static void uid$set( MemorySegment seg, int x) {
-        fuse_context.uid$VH.set(seg, x);
-    }
-    public static int uid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.uid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void uid$set(MemorySegment seg, long index, int x) {
-        fuse_context.uid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle gid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("gid"));
-    public static VarHandle gid$VH() {
-        return fuse_context.gid$VH;
-    }
-    public static int gid$get(MemorySegment seg) {
-        return (int)fuse_context.gid$VH.get(seg);
-    }
-    public static void gid$set( MemorySegment seg, int x) {
-        fuse_context.gid$VH.set(seg, x);
-    }
-    public static int gid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.gid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void gid$set(MemorySegment seg, long index, int x) {
-        fuse_context.gid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle pid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("pid"));
-    public static VarHandle pid$VH() {
-        return fuse_context.pid$VH;
-    }
-    public static int pid$get(MemorySegment seg) {
-        return (int)fuse_context.pid$VH.get(seg);
-    }
-    public static void pid$set( MemorySegment seg, int x) {
-        fuse_context.pid$VH.set(seg, x);
-    }
-    public static int pid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.pid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void pid$set(MemorySegment seg, long index, int x) {
-        fuse_context.pid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle private_data$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("private_data"));
-    public static VarHandle private_data$VH() {
-        return fuse_context.private_data$VH;
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg);
-    }
-    public static void private_data$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg, x);
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void private_data$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle umask$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("umask"));
-    public static VarHandle umask$VH() {
-        return fuse_context.umask$VH;
-    }
-    public static int umask$get(MemorySegment seg) {
-        return (int)fuse_context.umask$VH.get(seg);
-    }
-    public static void umask$set( MemorySegment seg, int x) {
-        fuse_context.umask$VH.set(seg, x);
-    }
-    public static int umask$get(MemorySegment seg, long index) {
-        return (int)fuse_context.umask$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void umask$set(MemorySegment seg, long index, int x) {
-        fuse_context.umask$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
-    }
-    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
-}
-
-
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_file_info.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_file_info.java
index 7a727e71..02ff4c6f 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_file_info.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_file_info.java
@@ -11,19 +11,23 @@ public class fuse_file_info {
 
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_INT$LAYOUT.withName("flags"),
-        MemoryLayout.paddingLayout(32),
-        Constants$root.C_LONG_LONG$LAYOUT.withName("fh_old"),
-        Constants$root.C_INT$LAYOUT.withName("writepage"),
         MemoryLayout.structLayout(
+            MemoryLayout.paddingLayout(1).withName("writepage"),
             MemoryLayout.paddingLayout(1).withName("direct_io"),
             MemoryLayout.paddingLayout(1).withName("keep_cache"),
             MemoryLayout.paddingLayout(1).withName("flush"),
             MemoryLayout.paddingLayout(1).withName("nonseekable"),
             MemoryLayout.paddingLayout(1).withName("flock_release"),
-            MemoryLayout.paddingLayout(27).withName("padding")
+            MemoryLayout.paddingLayout(1).withName("cache_readdir"),
+            MemoryLayout.paddingLayout(1).withName("noflush"),
+            MemoryLayout.paddingLayout(24).withName("padding"),
+            MemoryLayout.paddingLayout(32).withName("padding2"),
+            MemoryLayout.paddingLayout(32)
         ),
         Constants$root.C_LONG_LONG$LAYOUT.withName("fh"),
-        Constants$root.C_LONG_LONG$LAYOUT.withName("lock_owner")
+        Constants$root.C_LONG_LONG$LAYOUT.withName("lock_owner"),
+        Constants$root.C_INT$LAYOUT.withName("poll_events"),
+        MemoryLayout.paddingLayout(32)
     ).withName("fuse_file_info");
     public static MemoryLayout $LAYOUT() {
         return fuse_file_info.$struct$LAYOUT;
@@ -44,38 +48,6 @@ public class fuse_file_info {
     public static void flags$set(MemorySegment seg, long index, int x) {
         fuse_file_info.flags$VH.set(seg.asSlice(index*sizeof()), x);
     }
-    static final VarHandle fh_old$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fh_old"));
-    public static VarHandle fh_old$VH() {
-        return fuse_file_info.fh_old$VH;
-    }
-    public static long fh_old$get(MemorySegment seg) {
-        return (long)fuse_file_info.fh_old$VH.get(seg);
-    }
-    public static void fh_old$set( MemorySegment seg, long x) {
-        fuse_file_info.fh_old$VH.set(seg, x);
-    }
-    public static long fh_old$get(MemorySegment seg, long index) {
-        return (long)fuse_file_info.fh_old$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fh_old$set(MemorySegment seg, long index, long x) {
-        fuse_file_info.fh_old$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle writepage$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("writepage"));
-    public static VarHandle writepage$VH() {
-        return fuse_file_info.writepage$VH;
-    }
-    public static int writepage$get(MemorySegment seg) {
-        return (int)fuse_file_info.writepage$VH.get(seg);
-    }
-    public static void writepage$set( MemorySegment seg, int x) {
-        fuse_file_info.writepage$VH.set(seg, x);
-    }
-    public static int writepage$get(MemorySegment seg, long index) {
-        return (int)fuse_file_info.writepage$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void writepage$set(MemorySegment seg, long index, int x) {
-        fuse_file_info.writepage$VH.set(seg.asSlice(index*sizeof()), x);
-    }
     static final VarHandle fh$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fh"));
     public static VarHandle fh$VH() {
         return fuse_file_info.fh$VH;
@@ -108,6 +80,22 @@ public class fuse_file_info {
     public static void lock_owner$set(MemorySegment seg, long index, long x) {
         fuse_file_info.lock_owner$VH.set(seg.asSlice(index*sizeof()), x);
     }
+    static final VarHandle poll_events$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("poll_events"));
+    public static VarHandle poll_events$VH() {
+        return fuse_file_info.poll_events$VH;
+    }
+    public static int poll_events$get(MemorySegment seg) {
+        return (int)fuse_file_info.poll_events$VH.get(seg);
+    }
+    public static void poll_events$set( MemorySegment seg, int x) {
+        fuse_file_info.poll_events$VH.set(seg, x);
+    }
+    public static int poll_events$get(MemorySegment seg, long index) {
+        return (int)fuse_file_info.poll_events$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void poll_events$set(MemorySegment seg, long index, int x) {
+        fuse_file_info.poll_events$VH.set(seg.asSlice(index*sizeof()), x);
+    }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
     public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_fill_dir_t.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_fill_dir_t.java
index b3ae19d2..b0e952bc 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_fill_dir_t.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_fill_dir_t.java
@@ -9,15 +9,15 @@
 import static java.lang.foreign.ValueLayout.*;
 public interface fuse_fill_dir_t {
 
-    int apply(java.lang.foreign.MemoryAddress buf, java.lang.foreign.MemoryAddress name, java.lang.foreign.MemoryAddress stbuf, long off);
+    int apply(java.lang.foreign.MemoryAddress buf, java.lang.foreign.MemoryAddress name, java.lang.foreign.MemoryAddress stbuf, long off, int flags);
     static MemorySegment allocate(fuse_fill_dir_t fi, MemorySession session) {
         return RuntimeHelper.upcallStub(fuse_fill_dir_t.class, fi, constants$0.fuse_fill_dir_t$FUNC, session);
     }
     static fuse_fill_dir_t ofAddress(MemoryAddress addr, MemorySession session) {
         MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-        return (java.lang.foreign.MemoryAddress _buf, java.lang.foreign.MemoryAddress _name, java.lang.foreign.MemoryAddress _stbuf, long _off) -> {
+        return (java.lang.foreign.MemoryAddress _buf, java.lang.foreign.MemoryAddress _name, java.lang.foreign.MemoryAddress _stbuf, long _off, int _flags) -> {
             try {
-                return (int)constants$0.fuse_fill_dir_t$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)_buf, (java.lang.foreign.Addressable)_name, (java.lang.foreign.Addressable)_stbuf, _off);
+                return (int)constants$0.fuse_fill_dir_t$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)_buf, (java.lang.foreign.Addressable)_name, (java.lang.foreign.Addressable)_stbuf, _off, _flags);
             } catch (Throwable ex$) {
                 throw new AssertionError("should not reach here", ex$);
             }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_h.java
index a1f12898..c15911bd 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_h.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_h.java
@@ -18,8 +18,74 @@ public class fuse_h  {
     public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
     public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
     public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
+    public static MethodHandle fuse_lib_help$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_lib_help$MH,"fuse_lib_help");
+    }
+    public static void fuse_lib_help ( Addressable args) {
+        var mh$ = fuse_lib_help$MH();
+        try {
+            mh$.invokeExact(args);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_new$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_new$MH,"fuse_new");
+    }
+    public static MemoryAddress fuse_new ( Addressable args,  Addressable op,  long op_size,  Addressable private_data) {
+        var mh$ = fuse_new$MH();
+        try {
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(args, op, op_size, private_data);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_mount$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_mount$MH,"fuse_mount");
+    }
+    public static int fuse_mount ( Addressable f,  Addressable mountpoint) {
+        var mh$ = fuse_mount$MH();
+        try {
+            return (int)mh$.invokeExact(f, mountpoint);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_unmount$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_unmount$MH,"fuse_unmount");
+    }
+    public static void fuse_unmount ( Addressable f) {
+        var mh$ = fuse_unmount$MH();
+        try {
+            mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_destroy$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_destroy$MH,"fuse_destroy");
+    }
+    public static void fuse_destroy ( Addressable f) {
+        var mh$ = fuse_destroy$MH();
+        try {
+            mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_loop$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_loop$MH,"fuse_loop");
+    }
+    public static int fuse_loop ( Addressable f) {
+        var mh$ = fuse_loop$MH();
+        try {
+            return (int)mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
     public static MethodHandle fuse_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_exit$MH,"fuse_exit");
+        return RuntimeHelper.requireNonNull(constants$1.fuse_exit$MH,"fuse_exit");
     }
     public static void fuse_exit ( Addressable f) {
         var mh$ = fuse_exit$MH();
@@ -29,24 +95,24 @@ public static void fuse_exit ( Addressable f) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_get_context$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_get_context$MH,"fuse_get_context");
+    public static MethodHandle fuse_loop_mt$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_loop_mt$MH,"fuse_loop_mt");
     }
-    public static MemoryAddress fuse_get_context () {
-        var mh$ = fuse_get_context$MH();
+    public static int fuse_loop_mt ( Addressable f,  Addressable config) {
+        var mh$ = fuse_loop_mt$MH();
         try {
-            return (java.lang.foreign.MemoryAddress)mh$.invokeExact();
+            return (int)mh$.invokeExact(f, config);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_main_real$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_main_real$MH,"fuse_main_real");
+    public static MethodHandle fuse_get_session$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_get_session$MH,"fuse_get_session");
     }
-    public static int fuse_main_real ( int argc,  Addressable argv,  Addressable op,  long op_size,  Addressable user_data) {
-        var mh$ = fuse_main_real$MH();
+    public static MemoryAddress fuse_get_session ( Addressable f) {
+        var mh$ = fuse_get_session$MH();
         try {
-            return (int)mh$.invokeExact(argc, argv, op, op_size, user_data);
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(f);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_loop_config.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_loop_config.java
new file mode 100644
index 00000000..1aeb84c4
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_loop_config.java
@@ -0,0 +1,59 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_loop_config {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_INT$LAYOUT.withName("clone_fd"),
+        Constants$root.C_INT$LAYOUT.withName("max_idle_threads")
+    ).withName("fuse_loop_config");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_loop_config.$struct$LAYOUT;
+    }
+    static final VarHandle clone_fd$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
+    public static VarHandle clone_fd$VH() {
+        return fuse_loop_config.clone_fd$VH;
+    }
+    public static int clone_fd$get(MemorySegment seg) {
+        return (int)fuse_loop_config.clone_fd$VH.get(seg);
+    }
+    public static void clone_fd$set( MemorySegment seg, int x) {
+        fuse_loop_config.clone_fd$VH.set(seg, x);
+    }
+    public static int clone_fd$get(MemorySegment seg, long index) {
+        return (int)fuse_loop_config.clone_fd$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void clone_fd$set(MemorySegment seg, long index, int x) {
+        fuse_loop_config.clone_fd$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_idle_threads$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
+    public static VarHandle max_idle_threads$VH() {
+        return fuse_loop_config.max_idle_threads$VH;
+    }
+    public static int max_idle_threads$get(MemorySegment seg) {
+        return (int)fuse_loop_config.max_idle_threads$VH.get(seg);
+    }
+    public static void max_idle_threads$set( MemorySegment seg, int x) {
+        fuse_loop_config.max_idle_threads$VH.set(seg, x);
+    }
+    public static int max_idle_threads$get(MemorySegment seg, long index) {
+        return (int)fuse_loop_config.max_idle_threads$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
+        fuse_loop_config.max_idle_threads$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_operations.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_operations.java
index a8338096..d0f09f89 100644
--- a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_operations.java
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/fuse_operations.java
@@ -12,7 +12,6 @@ public class fuse_operations {
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_POINTER$LAYOUT.withName("getattr"),
         Constants$root.C_POINTER$LAYOUT.withName("readlink"),
-        Constants$root.C_POINTER$LAYOUT.withName("getdir"),
         Constants$root.C_POINTER$LAYOUT.withName("mknod"),
         Constants$root.C_POINTER$LAYOUT.withName("mkdir"),
         Constants$root.C_POINTER$LAYOUT.withName("unlink"),
@@ -23,7 +22,6 @@ public class fuse_operations {
         Constants$root.C_POINTER$LAYOUT.withName("chmod"),
         Constants$root.C_POINTER$LAYOUT.withName("chown"),
         Constants$root.C_POINTER$LAYOUT.withName("truncate"),
-        Constants$root.C_POINTER$LAYOUT.withName("utime"),
         Constants$root.C_POINTER$LAYOUT.withName("open"),
         Constants$root.C_POINTER$LAYOUT.withName("read"),
         Constants$root.C_POINTER$LAYOUT.withName("write"),
@@ -43,29 +41,23 @@ public class fuse_operations {
         Constants$root.C_POINTER$LAYOUT.withName("destroy"),
         Constants$root.C_POINTER$LAYOUT.withName("access"),
         Constants$root.C_POINTER$LAYOUT.withName("create"),
-        Constants$root.C_POINTER$LAYOUT.withName("ftruncate"),
-        Constants$root.C_POINTER$LAYOUT.withName("fgetattr"),
         Constants$root.C_POINTER$LAYOUT.withName("lock"),
         Constants$root.C_POINTER$LAYOUT.withName("utimens"),
         Constants$root.C_POINTER$LAYOUT.withName("bmap"),
-        MemoryLayout.structLayout(
-            MemoryLayout.paddingLayout(1).withName("flag_nullpath_ok"),
-            MemoryLayout.paddingLayout(1).withName("flag_nopath"),
-            MemoryLayout.paddingLayout(1).withName("flag_utime_omit_ok"),
-            MemoryLayout.paddingLayout(29).withName("flag_reserved"),
-            MemoryLayout.paddingLayout(32)
-        ),
         Constants$root.C_POINTER$LAYOUT.withName("ioctl"),
         Constants$root.C_POINTER$LAYOUT.withName("poll"),
         Constants$root.C_POINTER$LAYOUT.withName("write_buf"),
         Constants$root.C_POINTER$LAYOUT.withName("read_buf"),
         Constants$root.C_POINTER$LAYOUT.withName("flock"),
-        Constants$root.C_POINTER$LAYOUT.withName("fallocate")
+        Constants$root.C_POINTER$LAYOUT.withName("fallocate"),
+        Constants$root.C_POINTER$LAYOUT.withName("copy_file_range"),
+        Constants$root.C_POINTER$LAYOUT.withName("lseek")
     ).withName("fuse_operations");
     public static MemoryLayout $LAYOUT() {
         return fuse_operations.$struct$LAYOUT;
     }
     static final FunctionDescriptor getattr$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
@@ -74,15 +66,15 @@ public class fuse_operations {
     );
     public interface getattr {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(getattr fi, MemorySession session) {
             return RuntimeHelper.upcallStub(getattr.class, fi, fuse_operations.getattr$FUNC, session);
         }
         static getattr ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.getattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse_operations.getattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -154,51 +146,6 @@ static readlink ofAddress(MemoryAddress addr, MemorySession session) {
     public static readlink readlink (MemorySegment segment, MemorySession session) {
         return readlink.ofAddress(readlink$get(segment), session);
     }
-    static final FunctionDescriptor getdir$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle getdir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.getdir$FUNC
-    );
-    public interface getdir {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(getdir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(getdir.class, fi, fuse_operations.getdir$FUNC, session);
-        }
-        static getdir ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.getdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle getdir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("getdir"));
-    public static VarHandle getdir$VH() {
-        return fuse_operations.getdir$VH;
-    }
-    public static MemoryAddress getdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getdir$VH.get(seg);
-    }
-    public static void getdir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.getdir$VH.set(seg, x);
-    }
-    public static MemoryAddress getdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getdir$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getdir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.getdir$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getdir getdir (MemorySegment segment, MemorySession session) {
-        return getdir.ofAddress(getdir$get(segment), session);
-    }
     static final FunctionDescriptor mknod$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_INT$LAYOUT,
@@ -420,22 +367,23 @@ public static symlink symlink (MemorySegment segment, MemorySession session) {
     }
     static final FunctionDescriptor rename$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_INT$LAYOUT
     );
     static final MethodHandle rename$MH = RuntimeHelper.downcallHandle(
         fuse_operations.rename$FUNC
     );
     public interface rename {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, int _x2);
         static MemorySegment allocate(rename fi, MemorySession session) {
             return RuntimeHelper.upcallStub(rename.class, fi, fuse_operations.rename$FUNC, session);
         }
         static rename ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, int __x2) -> {
                 try {
-                    return (int)fuse_operations.rename$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse_operations.rename$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -508,22 +456,23 @@ public static link link (MemorySegment segment, MemorySession session) {
     }
     static final FunctionDescriptor chmod$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_INT$LAYOUT
+        Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle chmod$MH = RuntimeHelper.downcallHandle(
         fuse_operations.chmod$FUNC
     );
     public interface chmod {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, int _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(chmod fi, MemorySession session) {
             return RuntimeHelper.upcallStub(chmod.class, fi, fuse_operations.chmod$FUNC, session);
         }
         static chmod ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, int __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, int __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.chmod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse_operations.chmod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -553,22 +502,23 @@ public static chmod chmod (MemorySegment segment, MemorySession session) {
     static final FunctionDescriptor chown$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_INT$LAYOUT,
-        Constants$root.C_INT$LAYOUT
+        Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle chown$MH = RuntimeHelper.downcallHandle(
         fuse_operations.chown$FUNC
     );
     public interface chown {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, int _x2);
+        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, int _x2, java.lang.foreign.MemoryAddress _x3);
         static MemorySegment allocate(chown fi, MemorySession session) {
             return RuntimeHelper.upcallStub(chown.class, fi, fuse_operations.chown$FUNC, session);
         }
         static chown ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, int __x1, int __x2) -> {
+            return (java.lang.foreign.MemoryAddress __x0, int __x1, int __x2, java.lang.foreign.MemoryAddress __x3) -> {
                 try {
-                    return (int)fuse_operations.chown$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2);
+                    return (int)fuse_operations.chown$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2, (java.lang.foreign.Addressable)__x3);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -597,22 +547,23 @@ public static chown chown (MemorySegment segment, MemorySession session) {
     }
     static final FunctionDescriptor truncate$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle truncate$MH = RuntimeHelper.downcallHandle(
         fuse_operations.truncate$FUNC
     );
     public interface truncate {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, long _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, long _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(truncate fi, MemorySession session) {
             return RuntimeHelper.upcallStub(truncate.class, fi, fuse_operations.truncate$FUNC, session);
         }
         static truncate ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, long __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, long __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.truncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse_operations.truncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -639,50 +590,6 @@ static truncate ofAddress(MemoryAddress addr, MemorySession session) {
     public static truncate truncate (MemorySegment segment, MemorySession session) {
         return truncate.ofAddress(truncate$get(segment), session);
     }
-    static final FunctionDescriptor utime$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle utime$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.utime$FUNC
-    );
-    public interface utime {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(utime fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(utime.class, fi, fuse_operations.utime$FUNC, session);
-        }
-        static utime ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.utime$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle utime$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("utime"));
-    public static VarHandle utime$VH() {
-        return fuse_operations.utime$VH;
-    }
-    public static MemoryAddress utime$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utime$VH.get(seg);
-    }
-    public static void utime$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.utime$VH.set(seg, x);
-    }
-    public static MemoryAddress utime$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utime$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utime$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.utime$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utime utime (MemorySegment segment, MemorySession session) {
-        return utime.ofAddress(utime$get(segment), session);
-    }
     static final FunctionDescriptor open$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
@@ -1229,22 +1136,23 @@ public static opendir opendir (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_INT$LAYOUT
     );
     static final MethodHandle readdir$MH = RuntimeHelper.downcallHandle(
         fuse_operations.readdir$FUNC
     );
     public interface readdir {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3, java.lang.foreign.MemoryAddress _x4);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3, java.lang.foreign.MemoryAddress _x4, int _x5);
         static MemorySegment allocate(readdir fi, MemorySession session) {
             return RuntimeHelper.upcallStub(readdir.class, fi, fuse_operations.readdir$FUNC, session);
         }
         static readdir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3, java.lang.foreign.MemoryAddress __x4) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3, java.lang.foreign.MemoryAddress __x4, int __x5) -> {
                 try {
-                    return (int)fuse_operations.readdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, (java.lang.foreign.Addressable)__x4);
+                    return (int)fuse_operations.readdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, (java.lang.foreign.Addressable)__x4, __x5);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1361,6 +1269,7 @@ public static fsyncdir fsyncdir (MemorySegment segment, MemorySession session) {
         return fsyncdir.ofAddress(fsyncdir$get(segment), session);
     }
     static final FunctionDescriptor init$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle init$MH = RuntimeHelper.downcallHandle(
@@ -1368,15 +1277,15 @@ public static fsyncdir fsyncdir (MemorySegment segment, MemorySession session) {
     );
     public interface init {
 
-        java.lang.foreign.Addressable apply(java.lang.foreign.MemoryAddress _x0);
+        java.lang.foreign.Addressable apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(init fi, MemorySession session) {
             return RuntimeHelper.upcallStub(init.class, fi, fuse_operations.init$FUNC, session);
         }
         static init ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (java.lang.foreign.Addressable)(java.lang.foreign.MemoryAddress)fuse_operations.init$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
+                    return (java.lang.foreign.Addressable)(java.lang.foreign.MemoryAddress)fuse_operations.init$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1535,96 +1444,6 @@ static create ofAddress(MemoryAddress addr, MemorySession session) {
     public static create create (MemorySegment segment, MemorySession session) {
         return create.ofAddress(create$get(segment), session);
     }
-    static final FunctionDescriptor ftruncate$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle ftruncate$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.ftruncate$FUNC
-    );
-    public interface ftruncate {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, long _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(ftruncate fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(ftruncate.class, fi, fuse_operations.ftruncate$FUNC, session);
-        }
-        static ftruncate ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, long __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.ftruncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle ftruncate$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("ftruncate"));
-    public static VarHandle ftruncate$VH() {
-        return fuse_operations.ftruncate$VH;
-    }
-    public static MemoryAddress ftruncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ftruncate$VH.get(seg);
-    }
-    public static void ftruncate$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.ftruncate$VH.set(seg, x);
-    }
-    public static MemoryAddress ftruncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ftruncate$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ftruncate$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.ftruncate$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ftruncate ftruncate (MemorySegment segment, MemorySession session) {
-        return ftruncate.ofAddress(ftruncate$get(segment), session);
-    }
-    static final FunctionDescriptor fgetattr$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle fgetattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.fgetattr$FUNC
-    );
-    public interface fgetattr {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(fgetattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(fgetattr.class, fi, fuse_operations.fgetattr$FUNC, session);
-        }
-        static fgetattr ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.fgetattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle fgetattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fgetattr"));
-    public static VarHandle fgetattr$VH() {
-        return fuse_operations.fgetattr$VH;
-    }
-    public static MemoryAddress fgetattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fgetattr$VH.get(seg);
-    }
-    public static void fgetattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.fgetattr$VH.set(seg, x);
-    }
-    public static MemoryAddress fgetattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fgetattr$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fgetattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.fgetattr$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fgetattr fgetattr (MemorySegment segment, MemorySession session) {
-        return fgetattr.ofAddress(fgetattr$get(segment), session);
-    }
     static final FunctionDescriptor lock$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
@@ -1672,6 +1491,7 @@ public static lock lock (MemorySegment segment, MemorySession session) {
         return lock.ofAddress(lock$get(segment), session);
     }
     static final FunctionDescriptor utimens$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
@@ -1680,15 +1500,15 @@ public static lock lock (MemorySegment segment, MemorySession session) {
     );
     public interface utimens {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(utimens fi, MemorySession session) {
             return RuntimeHelper.upcallStub(utimens.class, fi, fuse_operations.utimens$FUNC, session);
         }
         static utimens ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.utimens$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse_operations.utimens$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -2039,6 +1859,102 @@ static fallocate ofAddress(MemoryAddress addr, MemorySession session) {
     public static fallocate fallocate (MemorySegment segment, MemorySession session) {
         return fallocate.ofAddress(fallocate$get(segment), session);
     }
+    static final FunctionDescriptor copy_file_range$FUNC = FunctionDescriptor.of(Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_INT$LAYOUT
+    );
+    static final MethodHandle copy_file_range$MH = RuntimeHelper.downcallHandle(
+        fuse_operations.copy_file_range$FUNC
+    );
+    public interface copy_file_range {
+
+        long apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2, java.lang.foreign.MemoryAddress _x3, java.lang.foreign.MemoryAddress _x4, long _x5, long _x6, int _x7);
+        static MemorySegment allocate(copy_file_range fi, MemorySession session) {
+            return RuntimeHelper.upcallStub(copy_file_range.class, fi, fuse_operations.copy_file_range$FUNC, session);
+        }
+        static copy_file_range ofAddress(MemoryAddress addr, MemorySession session) {
+            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2, java.lang.foreign.MemoryAddress __x3, java.lang.foreign.MemoryAddress __x4, long __x5, long __x6, int __x7) -> {
+                try {
+                    return (long)fuse_operations.copy_file_range$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, (java.lang.foreign.Addressable)__x3, (java.lang.foreign.Addressable)__x4, __x5, __x6, __x7);
+                } catch (Throwable ex$) {
+                    throw new AssertionError("should not reach here", ex$);
+                }
+            };
+        }
+    }
+
+    static final VarHandle copy_file_range$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("copy_file_range"));
+    public static VarHandle copy_file_range$VH() {
+        return fuse_operations.copy_file_range$VH;
+    }
+    public static MemoryAddress copy_file_range$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.copy_file_range$VH.get(seg);
+    }
+    public static void copy_file_range$set( MemorySegment seg, MemoryAddress x) {
+        fuse_operations.copy_file_range$VH.set(seg, x);
+    }
+    public static MemoryAddress copy_file_range$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.copy_file_range$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void copy_file_range$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_operations.copy_file_range$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static copy_file_range copy_file_range (MemorySegment segment, MemorySession session) {
+        return copy_file_range.ofAddress(copy_file_range$get(segment), session);
+    }
+    static final FunctionDescriptor lseek$FUNC = FunctionDescriptor.of(Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle lseek$MH = RuntimeHelper.downcallHandle(
+        fuse_operations.lseek$FUNC
+    );
+    public interface lseek {
+
+        long apply(java.lang.foreign.MemoryAddress _x0, long _x1, int _x2, java.lang.foreign.MemoryAddress _x3);
+        static MemorySegment allocate(lseek fi, MemorySession session) {
+            return RuntimeHelper.upcallStub(lseek.class, fi, fuse_operations.lseek$FUNC, session);
+        }
+        static lseek ofAddress(MemoryAddress addr, MemorySession session) {
+            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
+            return (java.lang.foreign.MemoryAddress __x0, long __x1, int __x2, java.lang.foreign.MemoryAddress __x3) -> {
+                try {
+                    return (long)fuse_operations.lseek$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2, (java.lang.foreign.Addressable)__x3);
+                } catch (Throwable ex$) {
+                    throw new AssertionError("should not reach here", ex$);
+                }
+            };
+        }
+    }
+
+    static final VarHandle lseek$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("lseek"));
+    public static VarHandle lseek$VH() {
+        return fuse_operations.lseek$VH;
+    }
+    public static MemoryAddress lseek$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.lseek$VH.get(seg);
+    }
+    public static void lseek$set( MemorySegment seg, MemoryAddress x) {
+        fuse_operations.lseek$VH.set(seg, x);
+    }
+    public static MemoryAddress lseek$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.lseek$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void lseek$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_operations.lseek$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static lseek lseek (MemorySegment segment, MemorySession session) {
+        return lseek.ofAddress(lseek$get(segment), session);
+    }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
     public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/Constants$root.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/Constants$root.java
new file mode 100644
index 00000000..4fc85421
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/Constants$root.java
@@ -0,0 +1,23 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class Constants$root {
+
+    static final  OfBoolean C_BOOL$LAYOUT = JAVA_BOOLEAN;
+    static final  OfByte C_CHAR$LAYOUT = JAVA_BYTE;
+    static final  OfShort C_SHORT$LAYOUT = JAVA_SHORT.withBitAlignment(16);
+    static final  OfInt C_INT$LAYOUT = JAVA_INT.withBitAlignment(32);
+    static final  OfLong C_LONG$LAYOUT = JAVA_LONG.withBitAlignment(64);
+    static final  OfLong C_LONG_LONG$LAYOUT = JAVA_LONG.withBitAlignment(64);
+    static final  OfFloat C_FLOAT$LAYOUT = JAVA_FLOAT.withBitAlignment(32);
+    static final  OfDouble C_DOUBLE$LAYOUT = JAVA_DOUBLE.withBitAlignment(64);
+    static final  OfAddress C_POINTER$LAYOUT = ADDRESS.withBitAlignment(64);
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/RuntimeHelper.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/RuntimeHelper.java
new file mode 100644
index 00000000..89a36033
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/RuntimeHelper.java
@@ -0,0 +1,233 @@
+package org.cryptomator.jfuse.linux.aarch64.extr.ll;
+// Generated by jextract
+
+import java.lang.foreign.Addressable;
+import java.lang.foreign.Linker;
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.GroupLayout;
+import java.lang.foreign.SymbolLookup;
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemoryLayout;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.lang.foreign.SegmentAllocator;
+import java.lang.foreign.ValueLayout;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static java.lang.foreign.Linker.*;
+import static java.lang.foreign.ValueLayout.*;
+
+final class RuntimeHelper {
+
+    private RuntimeHelper() {}
+    private final static Linker LINKER = Linker.nativeLinker();
+    private final static ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
+    private final static MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
+    private final static SymbolLookup SYMBOL_LOOKUP;
+
+    final static SegmentAllocator CONSTANT_ALLOCATOR =
+            (size, align) -> MemorySegment.allocateNative(size, align, MemorySession.openImplicit());
+
+    static {
+        
+        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
+        SYMBOL_LOOKUP = name -> loaderLookup.lookup(name).or(() -> LINKER.defaultLookup().lookup(name));
+    }
+
+    static <T> T requireNonNull(T obj, String symbolName) {
+        if (obj == null) {
+            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
+        }
+        return obj;
+    }
+
+    private final static SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
+
+    static final MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
+        return SYMBOL_LOOKUP.lookup(name).map(symbol -> MemorySegment.ofAddress(symbol.address(), layout.byteSize(), MemorySession.openShared())).orElse(null);
+    }
+
+    static final MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
+        return SYMBOL_LOOKUP.lookup(name).
+                map(addr -> LINKER.downcallHandle(addr, fdesc)).
+                orElse(null);
+    }
+
+    static final MethodHandle downcallHandle(FunctionDescriptor fdesc) {
+        return LINKER.downcallHandle(fdesc);
+    }
+
+    static final MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
+        return SYMBOL_LOOKUP.lookup(name).
+                map(addr -> VarargsInvoker.make(addr, fdesc)).
+                orElse(null);
+    }
+
+    static final <Z> MemorySegment upcallStub(Class<Z> fi, Z z, FunctionDescriptor fdesc, MemorySession session) {
+        try {
+            MethodHandle handle = MH_LOOKUP.findVirtual(fi, "apply", Linker.upcallType(fdesc));
+            handle = handle.bindTo(z);
+            return LINKER.upcallStub(handle, fdesc, session);
+        } catch (Throwable ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemorySegment asArray(MemoryAddress addr, MemoryLayout layout, int numElements, MemorySession session) {
+         return MemorySegment.ofAddress(addr, numElements * layout.byteSize(), session);
+    }
+
+    // Internals only below this point
+
+    private static class VarargsInvoker {
+        private static final MethodHandle INVOKE_MH;
+        private final MemorySegment symbol;
+        private final FunctionDescriptor function;
+
+        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
+            this.symbol = symbol;
+            this.function = function;
+        }
+
+        static {
+            try {
+                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
+            } catch (ReflectiveOperationException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
+            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
+            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
+            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
+            for (MemoryLayout layout : function.argumentLayouts()) {
+                mtype = mtype.appendParameterTypes(carrier(layout, false));
+            }
+            mtype = mtype.appendParameterTypes(Object[].class);
+            if (mtype.returnType().equals(MemorySegment.class)) {
+                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
+            } else {
+                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
+            }
+            return handle.asType(mtype);
+        }
+
+        static Class<?> carrier(MemoryLayout layout, boolean ret) {
+            if (layout instanceof ValueLayout valueLayout) {
+                return (ret || valueLayout.carrier() != MemoryAddress.class) ?
+                        valueLayout.carrier() : Addressable.class;
+            } else if (layout instanceof GroupLayout) {
+                return MemorySegment.class;
+            } else {
+                throw new AssertionError("Cannot get here!");
+            }
+        }
+
+        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
+            // one trailing Object[]
+            int nNamedArgs = function.argumentLayouts().size();
+            assert(args.length == nNamedArgs + 1);
+            // The last argument is the array of vararg collector
+            Object[] unnamedArgs = (Object[]) args[args.length - 1];
+
+            int argsCount = nNamedArgs + unnamedArgs.length;
+            Class<?>[] argTypes = new Class<?>[argsCount];
+            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
+
+            int pos = 0;
+            for (pos = 0; pos < nNamedArgs; pos++) {
+                argLayouts[pos] = function.argumentLayouts().get(pos);
+            }
+
+            assert pos == nNamedArgs;
+            for (Object o: unnamedArgs) {
+                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
+                pos++;
+            }
+            assert pos == argsCount;
+
+            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
+                    FunctionDescriptor.ofVoid(argLayouts) :
+                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
+            MethodHandle mh = LINKER.downcallHandle(symbol, f);
+            if (mh.type().returnType() == MemorySegment.class) {
+                mh = mh.bindTo(allocator);
+            }
+            // flatten argument list so that it can be passed to an asSpreader MH
+            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
+            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
+            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
+
+            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
+        }
+
+        private static Class<?> unboxIfNeeded(Class<?> clazz) {
+            if (clazz == Boolean.class) {
+                return boolean.class;
+            } else if (clazz == Void.class) {
+                return void.class;
+            } else if (clazz == Byte.class) {
+                return byte.class;
+            } else if (clazz == Character.class) {
+                return char.class;
+            } else if (clazz == Short.class) {
+                return short.class;
+            } else if (clazz == Integer.class) {
+                return int.class;
+            } else if (clazz == Long.class) {
+                return long.class;
+            } else if (clazz == Float.class) {
+                return float.class;
+            } else if (clazz == Double.class) {
+                return double.class;
+            } else {
+                return clazz;
+            }
+        }
+
+        private Class<?> promote(Class<?> c) {
+            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
+                return long.class;
+            } else if (c == float.class) {
+                return double.class;
+            } else {
+                return c;
+            }
+        }
+
+        private Class<?> normalize(Class<?> c) {
+            c = unboxIfNeeded(c);
+            if (c.isPrimitive()) {
+                return promote(c);
+            }
+            if (MemoryAddress.class.isAssignableFrom(c)) {
+                return MemoryAddress.class;
+            }
+            if (MemorySegment.class.isAssignableFrom(c)) {
+                return MemorySegment.class;
+            }
+            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
+        }
+
+        private MemoryLayout variadicLayout(Class<?> c) {
+            if (c == long.class) {
+                return JAVA_LONG;
+            } else if (c == double.class) {
+                return JAVA_DOUBLE;
+            } else if (MemoryAddress.class.isAssignableFrom(c)) {
+                return ADDRESS;
+            } else {
+                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
+            }
+        }
+    }
+}
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/constants$0.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/constants$0.java
new file mode 100644
index 00000000..426dcc26
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/constants$0.java
@@ -0,0 +1,22 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+class constants$0 {
+
+    static final FunctionDescriptor fuse_parse_cmdline$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_parse_cmdline$MH = RuntimeHelper.downcallHandle(
+        "fuse_parse_cmdline",
+        constants$0.fuse_parse_cmdline$FUNC
+    );
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/fuse_cmdline_opts.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/fuse_cmdline_opts.java
new file mode 100644
index 00000000..34c36adb
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/fuse_cmdline_opts.java
@@ -0,0 +1,178 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_cmdline_opts {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_INT$LAYOUT.withName("singlethread"),
+        Constants$root.C_INT$LAYOUT.withName("foreground"),
+        Constants$root.C_INT$LAYOUT.withName("debug"),
+        Constants$root.C_INT$LAYOUT.withName("nodefault_subtype"),
+        Constants$root.C_POINTER$LAYOUT.withName("mountpoint"),
+        Constants$root.C_INT$LAYOUT.withName("show_version"),
+        Constants$root.C_INT$LAYOUT.withName("show_help"),
+        Constants$root.C_INT$LAYOUT.withName("clone_fd"),
+        Constants$root.C_INT$LAYOUT.withName("max_idle_threads")
+    ).withName("fuse_cmdline_opts");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_cmdline_opts.$struct$LAYOUT;
+    }
+    static final VarHandle singlethread$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("singlethread"));
+    public static VarHandle singlethread$VH() {
+        return fuse_cmdline_opts.singlethread$VH;
+    }
+    public static int singlethread$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.singlethread$VH.get(seg);
+    }
+    public static void singlethread$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.singlethread$VH.set(seg, x);
+    }
+    public static int singlethread$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.singlethread$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void singlethread$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.singlethread$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle foreground$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("foreground"));
+    public static VarHandle foreground$VH() {
+        return fuse_cmdline_opts.foreground$VH;
+    }
+    public static int foreground$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.foreground$VH.get(seg);
+    }
+    public static void foreground$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.foreground$VH.set(seg, x);
+    }
+    public static int foreground$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.foreground$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void foreground$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.foreground$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle debug$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("debug"));
+    public static VarHandle debug$VH() {
+        return fuse_cmdline_opts.debug$VH;
+    }
+    public static int debug$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.debug$VH.get(seg);
+    }
+    public static void debug$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.debug$VH.set(seg, x);
+    }
+    public static int debug$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.debug$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void debug$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.debug$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle nodefault_subtype$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("nodefault_subtype"));
+    public static VarHandle nodefault_subtype$VH() {
+        return fuse_cmdline_opts.nodefault_subtype$VH;
+    }
+    public static int nodefault_subtype$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.nodefault_subtype$VH.get(seg);
+    }
+    public static void nodefault_subtype$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.nodefault_subtype$VH.set(seg, x);
+    }
+    public static int nodefault_subtype$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.nodefault_subtype$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void nodefault_subtype$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.nodefault_subtype$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle mountpoint$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("mountpoint"));
+    public static VarHandle mountpoint$VH() {
+        return fuse_cmdline_opts.mountpoint$VH;
+    }
+    public static MemoryAddress mountpoint$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_cmdline_opts.mountpoint$VH.get(seg);
+    }
+    public static void mountpoint$set( MemorySegment seg, MemoryAddress x) {
+        fuse_cmdline_opts.mountpoint$VH.set(seg, x);
+    }
+    public static MemoryAddress mountpoint$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_cmdline_opts.mountpoint$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void mountpoint$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_cmdline_opts.mountpoint$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle show_version$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("show_version"));
+    public static VarHandle show_version$VH() {
+        return fuse_cmdline_opts.show_version$VH;
+    }
+    public static int show_version$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.show_version$VH.get(seg);
+    }
+    public static void show_version$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.show_version$VH.set(seg, x);
+    }
+    public static int show_version$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.show_version$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void show_version$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.show_version$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle show_help$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("show_help"));
+    public static VarHandle show_help$VH() {
+        return fuse_cmdline_opts.show_help$VH;
+    }
+    public static int show_help$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.show_help$VH.get(seg);
+    }
+    public static void show_help$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.show_help$VH.set(seg, x);
+    }
+    public static int show_help$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.show_help$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void show_help$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.show_help$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle clone_fd$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
+    public static VarHandle clone_fd$VH() {
+        return fuse_cmdline_opts.clone_fd$VH;
+    }
+    public static int clone_fd$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.clone_fd$VH.get(seg);
+    }
+    public static void clone_fd$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.clone_fd$VH.set(seg, x);
+    }
+    public static int clone_fd$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.clone_fd$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void clone_fd$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.clone_fd$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_idle_threads$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
+    public static VarHandle max_idle_threads$VH() {
+        return fuse_cmdline_opts.max_idle_threads$VH;
+    }
+    public static int max_idle_threads$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.max_idle_threads$VH.get(seg);
+    }
+    public static void max_idle_threads$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.max_idle_threads$VH.set(seg, x);
+    }
+    public static int max_idle_threads$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.max_idle_threads$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.max_idle_threads$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/fuse_lowlevel_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/fuse_lowlevel_h.java
new file mode 100644
index 00000000..b6462f4d
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/ll/fuse_lowlevel_h.java
@@ -0,0 +1,34 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_lowlevel_h  {
+
+    /* package-private */ fuse_lowlevel_h() {}
+    public static OfByte C_CHAR = Constants$root.C_CHAR$LAYOUT;
+    public static OfShort C_SHORT = Constants$root.C_SHORT$LAYOUT;
+    public static OfInt C_INT = Constants$root.C_INT$LAYOUT;
+    public static OfLong C_LONG = Constants$root.C_LONG_LONG$LAYOUT;
+    public static OfLong C_LONG_LONG = Constants$root.C_LONG_LONG$LAYOUT;
+    public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
+    public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
+    public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
+    public static MethodHandle fuse_parse_cmdline$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_parse_cmdline$MH,"fuse_parse_cmdline");
+    }
+    public static int fuse_parse_cmdline ( Addressable args,  Addressable opts) {
+        var mh$ = fuse_parse_cmdline$MH();
+        try {
+            return (int)mh$.invokeExact(args, opts);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio_h.java b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio_h.java
new file mode 100644
index 00000000..df67ea8d
--- /dev/null
+++ b/jfuse-linux-aarch64/src/main/java/org/cryptomator/jfuse/linux/aarch64/extr/stdio_h.java
@@ -0,0 +1,32 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.aarch64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class stdio_h  {
+
+    /* package-private */ stdio_h() {}
+    public static OfByte C_CHAR = Constants$root.C_CHAR$LAYOUT;
+    public static OfShort C_SHORT = Constants$root.C_SHORT$LAYOUT;
+    public static OfInt C_INT = Constants$root.C_INT$LAYOUT;
+    public static OfLong C_LONG = Constants$root.C_LONG_LONG$LAYOUT;
+    public static OfLong C_LONG_LONG = Constants$root.C_LONG_LONG$LAYOUT;
+    public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
+    public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
+    public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
+    public static int RENAME_NOREPLACE() {
+        return (int)1L;
+    }
+    public static int RENAME_EXCHANGE() {
+        return (int)2L;
+    }
+    public static int RENAME_WHITEOUT() {
+        return (int)4L;
+    }
+}
+
+
diff --git a/jfuse-linux-aarch64/src/main/resources/services/org.cryptomator.jfuse.api.FuseBuilder b/jfuse-linux-aarch64/src/main/resources/META-INF/services/org.cryptomator.jfuse.api.FuseBuilder
similarity index 100%
rename from jfuse-linux-aarch64/src/main/resources/services/org.cryptomator.jfuse.api.FuseBuilder
rename to jfuse-linux-aarch64/src/main/resources/META-INF/services/org.cryptomator.jfuse.api.FuseBuilder
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImplTest.java
new file mode 100644
index 00000000..0789d974
--- /dev/null
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseConnInfoImplTest.java
@@ -0,0 +1,83 @@
+package org.cryptomator.jfuse.linux.aarch64;
+
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_conn_info;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+public class FuseConnInfoImplTest {
+
+	@DisplayName("test getters")
+	@ParameterizedTest(name = "{1}")
+	@MethodSource
+	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(segment, 42);
+
+			Assertions.assertEquals(42, getter.apply(connInfo));
+		}
+	}
+
+	public static Stream<Arguments> testGetters() {
+		return Stream.of(
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_read$set, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::time_gran$set, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+		);
+	}
+
+	private interface SetInMemorySegment extends BiConsumer<MemorySegment, Integer> {}
+
+	private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
+
+	@DisplayName("test setters")
+	@ParameterizedTest(name = "{0}")
+	@MethodSource
+	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(connInfo, 42);
+
+			Assertions.assertEquals(42, getter.apply(segment));
+		}
+	}
+
+	public static Stream<Arguments> testSetters() {
+		return Stream.of(
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want$get),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write$get),
+				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse_conn_info::max_read$get),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead$get),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background$get),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold$get),
+				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse_conn_info::time_gran$get)
+		);
+	}
+
+	private interface SetInConnInfo extends BiConsumer<FuseConnInfo, Integer> {}
+
+	private interface GetInMemorySegment extends Function<MemorySegment, Integer> {}
+
+}
\ No newline at end of file
diff --git a/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseImplTest.java b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseImplTest.java
new file mode 100644
index 00000000..393d1569
--- /dev/null
+++ b/jfuse-linux-aarch64/src/test/java/org/cryptomator/jfuse/linux/aarch64/FuseImplTest.java
@@ -0,0 +1,191 @@
+package org.cryptomator.jfuse.linux.aarch64;
+
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.api.TimeSpec;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_conn_info;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_file_info;
+import org.cryptomator.jfuse.linux.aarch64.extr.fuse_h;
+import org.cryptomator.jfuse.linux.aarch64.extr.ll.fuse_cmdline_opts;
+import org.cryptomator.jfuse.linux.aarch64.extr.ll.fuse_lowlevel_h;
+import org.cryptomator.jfuse.linux.aarch64.extr.timespec;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.Answers;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+import org.mockito.verification.VerificationMode;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.time.Instant;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class FuseImplTest {
+
+	private FuseOperations fuseOps = Mockito.mock(FuseOperations.class);
+	private FuseImpl fuseImpl = new FuseImpl(fuseOps);
+
+	@Nested
+	@DisplayName("mount()")
+	public class Mount {
+
+		private List<String> args = List.of("foo", "bar");
+		private FuseImpl fuseImplSpy = Mockito.spy(fuseImpl);
+		private MockedStatic<fuse_h> fuseH;
+
+		@BeforeEach
+		public void setup() {
+			Mockito.doReturn(Mockito.mock(FuseArgs.class)).when(fuseImplSpy).parseArgs(args);
+			fuseH = Mockito.mockStatic(fuse_h.class);
+		}
+
+		@AfterEach
+		public void teardown() {
+			fuseH.close();
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_new fails")
+		public void testFuseNewFails() {
+			fuseH.when(() -> fuse_h.fuse_new(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any())).thenReturn(MemoryAddress.NULL);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			fuseH.verify(() -> fuse_h.fuse_mount(Mockito.any(), Mockito.any()), Mockito.never());
+			Assertions.assertEquals("fuse_new failed", thrown.getMessage());
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_mount fails")
+		public void testFuseMountFails() {
+			fuseH.when(() -> fuse_h.fuse_new(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any())).thenReturn(MemoryAddress.ofLong(42L));
+			fuseH.when(() -> fuse_h.fuse_mount(Mockito.any(), Mockito.any())).thenReturn(1);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			Assertions.assertEquals("fuse_mount failed", thrown.getMessage());
+		}
+
+	}
+
+	@ParameterizedTest(name = "fusefs {0}")
+	@DisplayName("parseArgs with -h/--help")
+	@ValueSource(strings = {"--help", "-h"})
+	public void testParseArgsHelp(String arg) {
+		var args = List.of("fusefs", arg);
+		try (var fuseLowlevelH = Mockito.mockStatic(fuse_lowlevel_h.class);
+			 var fuseH = Mockito.mockStatic(fuse_h.class)) {
+			fuseLowlevelH.when(() -> fuse_lowlevel_h.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
+				MemorySegment opts = invocation.getArgument(1);
+				fuse_cmdline_opts.show_help$set(opts, 1);
+				return 0;
+			});
+			fuseH.when(() -> fuse_h.fuse_lib_help(Mockito.any())).thenAnswer(Answers.RETURNS_DEFAULTS);
+
+			Assertions.assertThrows(IllegalArgumentException.class, () -> fuseImpl.parseArgs(args));
+			fuseH.verify(() -> fuse_h.fuse_lib_help(Mockito.any()));
+		}
+	}
+
+	@Test
+	@DisplayName("parseArgs")
+	public void testParseArgs() {
+		try (var fuseLowlevelH = Mockito.mockStatic(fuse_lowlevel_h.class);
+			 var scope = MemorySession.openConfined()) {
+			fuseLowlevelH.when(() -> fuse_lowlevel_h.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
+				MemorySegment opts = invocation.getArgument(1);
+				fuse_cmdline_opts.singlethread$set(opts, 0);
+				fuse_cmdline_opts.debug$set(opts, 1);
+				fuse_cmdline_opts.mountpoint$set(opts, scope.allocateUtf8String("/mount/point").address());
+				return 0;
+			});
+
+			var fuseArgs = fuseImpl.parseArgs(List.of("fusefs", "-foo", "-bar", "/mount/point"));
+
+			Assertions.assertTrue(fuseArgs.multithreaded());
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[0] = fusefs"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[1] = -foo"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[2] = -bar"));
+			Assertions.assertTrue(fuseArgs.toString().contains("singlethreaded = false"));
+			Assertions.assertTrue(fuseArgs.toString().contains("debug = 1"));
+			Assertions.assertTrue(fuseArgs.toString().contains("mountPoint = /mount/point"));
+		}
+	}
+
+	@DisplayName("init() sets fuse_conn_info.wants |= FUSE_CAP_READDIRPLUS")
+	@Test
+	public void testInit() {
+		try (var scope = MemorySession.openConfined()) {
+			var result = new AtomicInteger();
+			Mockito.doAnswer(invocation -> {
+				FuseConnInfo connInfo = invocation.getArgument(0);
+				result.set(connInfo.want());
+				return null;
+			}).when(fuseOps).init(Mockito.any());
+			var connInfo = fuse_conn_info.allocate(scope);
+			var fuseConfig = MemoryAddress.NULL; // TODO jextract fuse_config
+
+			fuseImpl.init(connInfo.address(), fuseConfig.address());
+
+			Assertions.assertEquals(FuseConnInfo.FUSE_CAP_READDIRPLUS, result.get() & FuseConnInfo.FUSE_CAP_READDIRPLUS);
+		}
+	}
+
+	@Nested
+	@DisplayName("utimens")
+	public class Utimens {
+
+		@DisplayName("utimens(\"/foo\", UTIME_NOW, UTIME_NOW)")
+		@Test
+		public void testUtimensNow() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var fi = scope.allocate(fuse_file_info.$LAYOUT());
+				var times = MemoryAddress.NULL;
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.any());
+
+				var result = fuseImpl.utimens(path.address(), times, fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+		@DisplayName("utimens(\"/foo\", ...)")
+		@ParameterizedTest
+		@CsvSource(value = {
+				"123456,789, 456789,123",
+				"111222,333, 444555,666",
+		})
+		public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
+			Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
+			Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var fi = scope.allocate(fuse_file_info.$LAYOUT());
+				var times = timespec.allocateArray(2, scope);
+				timespec.tv_sec$set(times, 0, sec0);
+				timespec.tv_nsec$set(times, 0, nsec0);
+				timespec.tv_sec$set(times, 1, sec1);
+				timespec.tv_nsec$set(times, 1, nsec1);
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.any());
+
+				var result = fuseImpl.utimens(path.address(), times.address(), fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/jfuse-linux-amd64/pom.xml b/jfuse-linux-amd64/pom.xml
index 8ae2e2f8..f8daae5b 100644
--- a/jfuse-linux-amd64/pom.xml
+++ b/jfuse-linux-amd64/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>jfuse</artifactId>
-		<version>0.1.0</version>
+		<version>0.2.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jfuse-linux-amd64</artifactId>
@@ -14,7 +14,7 @@
 	<url>https://github.com/cryptomator/jfuse/tree/develop/jfuse-linux-amd64</url>
 
 	<properties>
-		<linux.headerSearchPath>/usr/x86_64-linux-gnu/include/</linux.headerSearchPath> <!-- debian package libc6-dev-amd64-cross -->
+		<linux.headerSearchPath>/Users/sebastian/Documents/inc/x86_64-linux-gnu/include</linux.headerSearchPath> <!-- debian package libc6-dev-amd64-cross -->
 	</properties>
 
 	<dependencies>
@@ -43,7 +43,6 @@
 									<rules>
 										<requireOS>
 											<family>unix</family>
-											<name>linux</name>
 											<message>This build configuration requires Linux.</message>
 										</requireOS>
 										<requireFilesExist>
@@ -88,16 +87,22 @@
 									<goal>sources</goal>
 								</goals>
 								<configuration>
-									<headerFile>${project.parent.basedir}/libfuse/include/fuse.h</headerFile>
+									<headerFile>${project.parent.basedir}/libfuse3/include/fuse.h</headerFile>
 									<headerClassName>fuse_h</headerClassName>
 									<cPreprocessorMacros>
 										<cPreprocessorMacro>_FILE_OFFSET_BITS=64</cPreprocessorMacro>
-										<cPreprocessorMacro>FUSE_USE_VERSION=29</cPreprocessorMacro>
+										<cPreprocessorMacro>FUSE_USE_VERSION=35</cPreprocessorMacro>
 									</cPreprocessorMacros>
 									<includeFunctions>
-										<includeFunction>fuse_main_real</includeFunction>
-										<includeFunction>fuse_get_context</includeFunction>
+										<includeFunction>fuse_lib_help</includeFunction>
+										<includeFunction>fuse_new</includeFunction>
+										<includeFunction>fuse_mount</includeFunction>
+										<includeFunction>fuse_get_session</includeFunction>
+										<includeFunction>fuse_loop</includeFunction>
+										<includeFunction>fuse_loop_mt</includeFunction>
 										<includeFunction>fuse_exit</includeFunction>
+										<includeFunction>fuse_unmount</includeFunction>
+										<includeFunction>fuse_destroy</includeFunction>
 									</includeFunctions>
 									<includeTypedefs>
 										<includeTypedef>fuse_fill_dir_t</includeTypedef>
@@ -105,11 +110,33 @@
 									<includeStructs>
 										<includeStruct>fuse_operations</includeStruct>
 										<includeStruct>fuse_file_info</includeStruct>
-										<includeStruct>fuse_context</includeStruct>
 										<includeStruct>stat</includeStruct>
 										<includeStruct>statvfs</includeStruct>
 										<includeStruct>timespec</includeStruct>
 										<includeStruct>fuse_conn_info</includeStruct>
+										<includeStruct>fuse_args</includeStruct>
+										<includeStruct>fuse_loop_config</includeStruct>
+									</includeStructs>
+								</configuration>
+							</execution>
+							<execution>
+								<id>jextract-fuse-lowlevel</id>
+								<goals>
+									<goal>sources</goal>
+								</goals>
+								<configuration>
+									<headerFile>${project.parent.basedir}/libfuse3/include/fuse_lowlevel.h</headerFile>
+									<targetPackage>org.cryptomator.jfuse.linux.amd64.extr.ll</targetPackage>
+									<headerClassName>fuse_lowlevel_h</headerClassName>
+									<cPreprocessorMacros>
+										<cPreprocessorMacro>_FILE_OFFSET_BITS=64</cPreprocessorMacro>
+										<cPreprocessorMacro>FUSE_USE_VERSION=35</cPreprocessorMacro>
+									</cPreprocessorMacros>
+									<includeFunctions>
+										<includeFunction>fuse_parse_cmdline</includeFunction>
+									</includeFunctions>
+									<includeStructs>
+										<includeStruct>fuse_cmdline_opts</includeStruct>
 									</includeStructs>
 								</configuration>
 							</execution>
@@ -146,9 +173,6 @@
 									<headerFile>${linux.headerSearchPath}/sys/stat.h</headerFile>
 									<headerClassName>stat_h</headerClassName>
 									<includeMacros>
-										<includeMacro>S_IFREG</includeMacro>
-										<includeMacro>S_IFDIR</includeMacro>
-										<includeMacro>S_IFLNK</includeMacro>
 										<includeMacro>UTIME_NOW</includeMacro>
 										<includeMacro>UTIME_OMIT</includeMacro>
 									</includeMacros>
@@ -175,6 +199,25 @@
 									</includeMacros>
 								</configuration>
 							</execution>
+							<execution>
+								<id>jextract-stdio</id>
+								<goals>
+									<goal>sources</goal>
+								</goals>
+								<configuration>
+									<headerFile>${linux.headerSearchPath}/stdio.h</headerFile>
+									<headerClassName>stdio_h</headerClassName>
+									<cPreprocessorMacros>
+										<cPreprocessorMacro>_GNU_SOURCE=1</cPreprocessorMacro>
+									</cPreprocessorMacros>
+									<includeMacros>
+										<!-- GNU-specific flags for rename: -->
+										<includeMacro>RENAME_NOREPLACE</includeMacro>
+										<includeMacro>RENAME_EXCHANGE</includeMacro>
+										<includeMacro>RENAME_WHITEOUT</includeMacro>
+									</includeMacros>
+								</configuration>
+							</execution>
 						</executions>
 					</plugin>
 				</plugins>
diff --git a/jfuse-linux-amd64/src/main/java/module-info.java b/jfuse-linux-amd64/src/main/java/module-info.java
index 8e834c0b..1b8d5029 100644
--- a/jfuse-linux-amd64/src/main/java/module-info.java
+++ b/jfuse-linux-amd64/src/main/java/module-info.java
@@ -3,6 +3,8 @@
 
 @SuppressWarnings("JavaModuleNaming") // 64 is not a "version", see https://bugs.openjdk.java.net/browse/JDK-8264488
 module org.cryptomator.jfuse.linux.amd64 {
+	requires static org.jetbrains.annotations;
+
 	requires org.cryptomator.jfuse.api;
 
 	provides FuseBuilder with LinuxFuseBuilder;
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java
index ce3b1bb8..03256697 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/DirFillerImpl.java
@@ -3,9 +3,13 @@
 import org.cryptomator.jfuse.api.DirFiller;
 import org.cryptomator.jfuse.api.Stat;
 import org.cryptomator.jfuse.linux.amd64.extr.fuse_fill_dir_t;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_h;
+import org.cryptomator.jfuse.linux.amd64.extr.stat;
 
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemorySession;
+import java.util.Set;
+import java.util.function.Consumer;
 
 record DirFillerImpl(MemoryAddress buf, fuse_fill_dir_t callback, MemorySession scope) implements DirFiller {
 
@@ -14,9 +18,10 @@ record DirFillerImpl(MemoryAddress buf, fuse_fill_dir_t callback, MemorySession
 	}
 
 	@Override
-	public int fill(String name, Stat stat, long offset) {
-		var statAddr = stat instanceof StatImpl s ? s.segment().address() : MemoryAddress.NULL;
-		return callback.apply(buf, scope.allocateUtf8String(name).address(), statAddr, offset);
+	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
+		var statSegment = stat.allocate(scope);
+		statFiller.accept(new StatImpl(statSegment));
+		return callback.apply(buf, scope.allocateUtf8String(name).address(), statSegment.address(), offset, flags);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseArgs.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseArgs.java
new file mode 100644
index 00000000..4c7c5099
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseArgs.java
@@ -0,0 +1,35 @@
+package org.cryptomator.jfuse.linux.amd64;
+
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_args;
+import org.cryptomator.jfuse.linux.amd64.extr.ll.fuse_cmdline_opts;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+record FuseArgs(MemorySegment args, MemorySegment cmdLineOpts) {
+
+	@Override
+	public String toString() {
+		var sb = new StringBuilder();
+		var argc = fuse_args.argc$get(args);
+		var argv = fuse_args.argv$get(args);
+		for (int i = 0; i < argc; i++) {
+			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i);
+			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+		}
+		sb.append("mountPoint = ").append(mountPoint().getUtf8String(0));
+		sb.append("debug = ").append(fuse_cmdline_opts.debug$get(cmdLineOpts));
+		sb.append("singlethreaded = ").append(!multithreaded());
+		return sb.toString();
+	}
+
+	public MemoryAddress mountPoint() {
+		return fuse_cmdline_opts.mountpoint$get(cmdLineOpts);
+	}
+
+	public boolean multithreaded() {
+		return fuse_cmdline_opts.singlethread$get(cmdLineOpts) == 0;
+	}
+
+}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java
index 7b4e0233..8bc88436 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImpl.java
@@ -22,4 +22,80 @@ public int protoMajor() {
 	public int protoMinor() {
 		return fuse_conn_info.proto_minor$get(segment);
 	}
+
+	@Override
+	public int capable() {
+		return fuse_conn_info.capable$get(segment);
+	}
+
+	@Override
+	public int want() {
+		return fuse_conn_info.want$get(segment);
+	}
+
+	@Override
+	public void setWant(int wanted) {
+		fuse_conn_info.want$set(segment, wanted);
+	}
+
+	@Override
+	public int maxWrite() {
+		return fuse_conn_info.max_write$get(segment);
+	}
+
+	@Override
+	public void setMaxWrite(int maxWrite) {
+		fuse_conn_info.max_write$set(segment, maxWrite);
+	}
+
+	@Override
+	public int maxRead() {
+		return fuse_conn_info.max_read$get(segment);
+	}
+
+	@Override
+	public void setMaxRead(int maxRead) {
+		fuse_conn_info.max_read$set(segment, maxRead);
+	}
+
+	@Override
+	public int maxReadahead() {
+		return fuse_conn_info.max_readahead$get(segment);
+	}
+
+	@Override
+	public void setMaxReadahead(int maxReadahead) {
+		fuse_conn_info.max_readahead$set(segment, maxReadahead);
+	}
+
+	@Override
+	public int maxBackground() {
+		return fuse_conn_info.max_background$get(segment);
+	}
+
+	@Override
+	public void setMaxBackground(int maxBackground) {
+		fuse_conn_info.max_background$set(segment, maxBackground);
+	}
+
+	@Override
+	public int congestionThreshold() {
+		return fuse_conn_info.congestion_threshold$get(segment);
+	}
+
+	@Override
+	public void setCongestionThreshold(int congestionThreshold) {
+		fuse_conn_info.congestion_threshold$set(segment, congestionThreshold);
+	}
+
+	@Override
+	public int timeGran() {
+		return fuse_conn_info.time_gran$get(segment);
+	}
+
+	@Override
+	public void setTimeGran(int timeGran) {
+		fuse_conn_info.time_gran$set(segment, timeGran);
+	}
+
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java
index b84d63a8..55bdb212 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseImpl.java
@@ -1,95 +1,122 @@
 package org.cryptomator.jfuse.linux.amd64;
 
 import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.api.FuseMount;
 import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_args;
 import org.cryptomator.jfuse.linux.amd64.extr.fuse_h;
 import org.cryptomator.jfuse.linux.amd64.extr.fuse_operations;
+import org.cryptomator.jfuse.linux.amd64.extr.ll.fuse_cmdline_opts;
+import org.cryptomator.jfuse.linux.amd64.extr.ll.fuse_lowlevel_h;
 import org.cryptomator.jfuse.linux.amd64.extr.stat_h;
 import org.cryptomator.jfuse.linux.amd64.extr.timespec;
+import org.jetbrains.annotations.VisibleForTesting;
 
+import java.lang.foreign.Addressable;
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.MemorySession;
-import java.nio.ByteBuffer;
-import java.util.concurrent.CompletableFuture;
+import java.lang.foreign.ValueLayout;
+import java.util.List;
 
 public final class FuseImpl extends Fuse {
 
-	private final CompletableFuture<Integer> initialized = new CompletableFuture<>();
 	private final FuseOperations delegate;
-	private final MemorySegment struct;
+	private final MemorySegment fuseOps;
 
 	public FuseImpl(FuseOperations fuseOperations) {
-		this.struct = fuse_operations.allocate(fuseScope);
+		this.fuseOps = fuse_operations.allocate(fuseScope);
 		this.delegate = fuseOperations;
-		fuse_operations.init$set(struct, fuse_operations.init.allocate(this::init, fuseScope).address());
 		fuseOperations.supportedOperations().forEach(this::bind);
 	}
 
-	private MemoryAddress init(MemoryAddress conn) {
-		try (var scope = MemorySession.openConfined()) {
-			if (delegate.supportedOperations().contains(FuseOperations.Operation.INIT)) {
-				delegate.init(new FuseConnInfoImpl(conn, scope));
-			}
-			initialized.complete(0);
-		} catch (Exception e) {
-			initialized.completeExceptionally(e);
-		}
-		return MemoryAddress.NULL;
-	}
-
 	@Override
-	protected CompletableFuture<Integer> initialized() {
-		return initialized;
+	protected FuseMount mount(List<String> args) throws MountFailedException {
+		var fuseArgs = parseArgs(args);
+		var fuse = fuse_h.fuse_new(fuseArgs.args(), fuseOps, fuseOps.byteSize(), MemoryAddress.NULL);
+		if (MemoryAddress.NULL.equals(fuse)) {
+			throw new MountFailedException("fuse_new failed");
+		}
+		if (fuse_h.fuse_mount(fuse, fuseArgs.mountPoint()) != 0) {
+			throw new MountFailedException("fuse_mount failed");
+		}
+		return new FuseMountImpl(fuse, fuseArgs);
 	}
 
-	@Override
-	protected int fuseMain(int argc, MemorySegment argv) {
-		return fuse_h.fuse_main_real(argc, argv, struct, struct.byteSize(), MemoryAddress.NULL);
+	@VisibleForTesting
+	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
+		var args = fuse_args.allocate(fuseScope);
+		var argc = cmdLineArgs.size();
+		var argv = fuseScope.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		for (int i = 0; i < argc; i++) {
+			var cString = fuseScope.allocateUtf8String(cmdLineArgs.get(i));
+			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
+		}
+		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemoryAddress.NULL);
+		fuse_args.argc$set(args, argc);
+		fuse_args.argv$set(args, argv.address());
+		fuse_args.allocated$set(args, 0);
+
+		var opts = fuse_cmdline_opts.allocate(fuseScope);
+		int parseResult = fuse_lowlevel_h.fuse_parse_cmdline(args, opts);
+		if (parseResult != 0) {
+			throw new IllegalArgumentException("fuse_parse_cmdline failed to parse " + String.join(" ", cmdLineArgs));
+		}
+		if (fuse_cmdline_opts.show_help$get(opts) == 1) {
+			fuse_h.fuse_lib_help(args);
+			throw new IllegalArgumentException("Flags contained -h or --help. Processing cancelled after printing help");
+		}
+		return new FuseArgs(args, opts);
 	}
 
-//	private void exit() {
-//		try (var scope = ResourceScope.newConfinedScope()) {
-//			var ctx = fuse_context.ofAddress(fuse_h.fuse_get_context(), fuseScope);
-//			var fusePtr = fuse_context.fuse$get(ctx);
-//			fuse_h.fuse_exit(fusePtr);
-//		}
-//	}
-
 	private void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> { /* handled already */ }
-			case ACCESS -> fuse_operations.access$set(struct, fuse_operations.access.allocate(this::access, fuseScope).address());
-			case CHMOD -> fuse_operations.chmod$set(struct, fuse_operations.chmod.allocate(this::chmod, fuseScope).address());
-			case CREATE -> fuse_operations.create$set(struct, fuse_operations.create.allocate(this::create, fuseScope).address());
-			case DESTROY -> fuse_operations.destroy$set(struct, fuse_operations.destroy.allocate(this::destroy, fuseScope).address());
-			case GET_ATTR -> fuse_operations.getattr$set(struct, fuse_operations.getattr.allocate(this::getattr, fuseScope).address());
-			case MKDIR -> fuse_operations.mkdir$set(struct, fuse_operations.mkdir.allocate(this::mkdir, fuseScope).address());
-			case OPEN -> fuse_operations.open$set(struct, fuse_operations.open.allocate(this::open, fuseScope).address());
-			case OPEN_DIR -> fuse_operations.opendir$set(struct, fuse_operations.opendir.allocate(this::opendir, fuseScope).address());
-			case READ -> fuse_operations.read$set(struct, fuse_operations.read.allocate(this::read, fuseScope).address());
-			case READ_DIR -> fuse_operations.readdir$set(struct, fuse_operations.readdir.allocate(this::readdir, fuseScope).address());
-			case READLINK -> fuse_operations.readlink$set(struct, fuse_operations.readlink.allocate(this::readlink, fuseScope).address());
-			case RELEASE -> fuse_operations.release$set(struct, fuse_operations.release.allocate(this::release, fuseScope).address());
-			case RELEASE_DIR -> fuse_operations.releasedir$set(struct, fuse_operations.releasedir.allocate(this::releasedir, fuseScope).address());
-			case RENAME -> fuse_operations.rename$set(struct, fuse_operations.rename.allocate(this::rename, fuseScope).address());
-			case RMDIR -> fuse_operations.rmdir$set(struct, fuse_operations.rmdir.allocate(this::rmdir, fuseScope).address());
-			case STATFS -> fuse_operations.statfs$set(struct, fuse_operations.statfs.allocate(this::statfs, fuseScope).address());
-			case SYMLINK -> fuse_operations.symlink$set(struct, fuse_operations.symlink.allocate(this::symlink, fuseScope).address());
-			case TRUNCATE -> fuse_operations.truncate$set(struct, fuse_operations.truncate.allocate(this::truncate, fuseScope).address());
-			case UNLINK -> fuse_operations.unlink$set(struct, fuse_operations.unlink.allocate(this::unlink, fuseScope).address());
-			case UTIMENS -> fuse_operations.utimens$set(struct, fuse_operations.utimens.allocate(this::utimens, fuseScope).address());
-			case WRITE -> fuse_operations.write$set(struct, fuse_operations.write.allocate(this::write, fuseScope).address());
+			case INIT -> fuse_operations.init$set(fuseOps, fuse_operations.init.allocate(this::init, fuseScope).address());
+			case ACCESS -> fuse_operations.access$set(fuseOps, fuse_operations.access.allocate(this::access, fuseScope).address());
+			case CHMOD -> fuse_operations.chmod$set(fuseOps, fuse_operations.chmod.allocate(this::chmod, fuseScope).address());
+			case CREATE -> fuse_operations.create$set(fuseOps, fuse_operations.create.allocate(this::create, fuseScope).address());
+			case DESTROY -> fuse_operations.destroy$set(fuseOps, fuse_operations.destroy.allocate(this::destroy, fuseScope).address());
+			case GET_ATTR -> fuse_operations.getattr$set(fuseOps, fuse_operations.getattr.allocate(this::getattr, fuseScope).address());
+			case MKDIR -> fuse_operations.mkdir$set(fuseOps, fuse_operations.mkdir.allocate(this::mkdir, fuseScope).address());
+			case OPEN -> fuse_operations.open$set(fuseOps, fuse_operations.open.allocate(this::open, fuseScope).address());
+			case OPEN_DIR -> fuse_operations.opendir$set(fuseOps, fuse_operations.opendir.allocate(this::opendir, fuseScope).address());
+			case READ -> fuse_operations.read$set(fuseOps, fuse_operations.read.allocate(this::read, fuseScope).address());
+			case READ_DIR -> fuse_operations.readdir$set(fuseOps, fuse_operations.readdir.allocate(this::readdir, fuseScope).address());
+			case READLINK -> fuse_operations.readlink$set(fuseOps, fuse_operations.readlink.allocate(this::readlink, fuseScope).address());
+			case RELEASE -> fuse_operations.release$set(fuseOps, fuse_operations.release.allocate(this::release, fuseScope).address());
+			case RELEASE_DIR -> fuse_operations.releasedir$set(fuseOps, fuse_operations.releasedir.allocate(this::releasedir, fuseScope).address());
+			case RENAME -> fuse_operations.rename$set(fuseOps, fuse_operations.rename.allocate(this::rename, fuseScope).address());
+			case RMDIR -> fuse_operations.rmdir$set(fuseOps, fuse_operations.rmdir.allocate(this::rmdir, fuseScope).address());
+			case STATFS -> fuse_operations.statfs$set(fuseOps, fuse_operations.statfs.allocate(this::statfs, fuseScope).address());
+			case SYMLINK -> fuse_operations.symlink$set(fuseOps, fuse_operations.symlink.allocate(this::symlink, fuseScope).address());
+			case TRUNCATE -> fuse_operations.truncate$set(fuseOps, fuse_operations.truncate.allocate(this::truncate, fuseScope).address());
+			case UNLINK -> fuse_operations.unlink$set(fuseOps, fuse_operations.unlink.allocate(this::unlink, fuseScope).address());
+			case UTIMENS -> fuse_operations.utimens$set(fuseOps, fuse_operations.utimens.allocate(this::utimens, fuseScope).address());
+			case WRITE -> fuse_operations.write$set(fuseOps, fuse_operations.write.allocate(this::write, fuseScope).address());
+		}
+	}
+
+	@VisibleForTesting
+	Addressable init(MemoryAddress conn, MemoryAddress fuseConfig) {
+		try (var scope = MemorySession.openConfined()) {
+			var connInfo = new FuseConnInfoImpl(conn, scope);
+			connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
+			delegate.init(connInfo);
 		}
+		return MemoryAddress.NULL;
 	}
 
 	private int access(MemoryAddress path, int mask) {
 		return delegate.access(path.getUtf8String(0), mask);
 	}
 
-	private int chmod(MemoryAddress path, int mode) {
-		return delegate.chmod(path.getUtf8String(0), mode);
+	private int chmod(MemoryAddress path, int mode, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.chmod(path.getUtf8String(0), mode, new FileInfoImpl(fi, scope));
+		}
 	}
 
 	private int create(MemoryAddress path, int mode, MemoryAddress fi) {
@@ -102,9 +129,9 @@ private void destroy(MemoryAddress addr) {
 		delegate.destroy();
 	}
 
-	private int getattr(MemoryAddress path, MemoryAddress stat) {
+	private int getattr(MemoryAddress path, MemoryAddress stat, MemoryAddress fi) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope));
+			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope), new FileInfoImpl(fi, scope));
 		}
 	}
 
@@ -131,9 +158,9 @@ private int read(MemoryAddress path, MemoryAddress buf, long size, long offset,
 		}
 	}
 
-	private int readdir(MemoryAddress path, MemoryAddress buf, MemoryAddress filler, long offset, MemoryAddress fi) {
+	private int readdir(MemoryAddress path, MemoryAddress buf, MemoryAddress filler, long offset, MemoryAddress fi, int flags) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope));
+			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope), flags);
 		}
 	}
 
@@ -156,8 +183,8 @@ private int releasedir(MemoryAddress path, MemoryAddress fi) {
 		}
 	}
 
-	private int rename(MemoryAddress oldpath, MemoryAddress newpath) {
-		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0));
+	private int rename(MemoryAddress oldpath, MemoryAddress newpath, int flags) {
+		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), flags);
 	}
 
 	private int rmdir(MemoryAddress path) {
@@ -174,30 +201,32 @@ private int symlink(MemoryAddress linkname, MemoryAddress target) {
 		return delegate.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
 	}
 
-	private int truncate(MemoryAddress path, long size) {
-		return delegate.truncate(path.getUtf8String(0), size);
+	private int truncate(MemoryAddress path, long size, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.truncate(path.getUtf8String(0), size, new FileInfoImpl(fi, scope));
+		}
 	}
 
 	private int unlink(MemoryAddress path) {
 		return delegate.unlink(path.getUtf8String(0));
 	}
 
-	private int utimens(MemoryAddress path, MemoryAddress times) {
-		if (MemoryAddress.NULL.equals(times)) {
-			// set both times to current time (using on-heap memory segments)
-			var segment = MemorySegment.ofBuffer(ByteBuffer.allocate((int) timespec.$LAYOUT().byteSize()));
-			timespec.tv_sec$set(segment, 0);
-			timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
-			var time = new TimeSpecImpl(segment);
-			return delegate.utimens(path.getUtf8String(0), time, time);
-		} else {
-			try (var scope = MemorySession.openConfined()) {
+	@VisibleForTesting
+	int utimens(MemoryAddress path, MemoryAddress times, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			if (MemoryAddress.NULL.equals(times)) {
+				// set both times to current time (using on-heap memory segments)
+				var segment = MemorySegment.allocateNative(timespec.$LAYOUT().byteSize(), scope);
+				timespec.tv_sec$set(segment, 0);
+				timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
+				var time = new TimeSpecImpl(segment);
+				return delegate.utimens(path.getUtf8String(0), time, time, new FileInfoImpl(fi, scope));
+			} else {
 				var seq = MemoryLayout.sequenceLayout(2, timespec.$LAYOUT());
 				var segment = MemorySegment.ofAddress(times, seq.byteSize(), scope);
 				var time0 = segment.asSlice(0, timespec.$LAYOUT().byteSize());
 				var time1 = segment.asSlice(timespec.$LAYOUT().byteSize(), timespec.$LAYOUT().byteSize());
-//				var timeSpecs = segment.elements(seq.elementLayout()).map(MacTimeSpec::new).toArray(MacTimeSpec[]::new);
-				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1));
+				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), new FileInfoImpl(fi, scope));
 			}
 		}
 	}
@@ -209,4 +238,4 @@ private int write(MemoryAddress path, MemoryAddress buf, long size, long offset,
 		}
 	}
 
-}
+}
\ No newline at end of file
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseMountImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseMountImpl.java
new file mode 100644
index 00000000..60e9a2da
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/FuseMountImpl.java
@@ -0,0 +1,36 @@
+package org.cryptomator.jfuse.linux.amd64;
+
+import org.cryptomator.jfuse.api.FuseMount;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_h;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_loop_config;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySession;
+
+record FuseMountImpl(MemoryAddress fuse, FuseArgs fuseArgs) implements FuseMount {
+
+	@Override
+	public int loop() {
+		if (fuseArgs.multithreaded()) {
+			try (var scope = MemorySession.openConfined()) {
+				var loopCfg = fuse_loop_config.allocate(scope);
+				fuse_loop_config.clone_fd$set(loopCfg, 0);
+				fuse_loop_config.max_idle_threads$set(loopCfg, 10);
+				return fuse_h.fuse_loop_mt(fuse, loopCfg);
+			}
+		} else {
+			return fuse_h.fuse_loop(fuse);
+		}
+	}
+
+	@Override
+	public void unmount() {
+		fuse_h.fuse_exit(fuse);
+		fuse_h.fuse_unmount(fuse);
+	}
+
+	@Override
+	public void destroy() {
+		fuse_h.fuse_destroy(fuse);
+	}
+}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/LinuxFuseBuilder.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/LinuxFuseBuilder.java
index d4803ed5..b9dd262e 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/LinuxFuseBuilder.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/LinuxFuseBuilder.java
@@ -11,7 +11,7 @@
 @SupportedPlatform(os = OperatingSystem.LINUX, arch = Architecture.AMD64)
 public class LinuxFuseBuilder implements FuseBuilder {
 
-	private static final String DEFAULT_LIB_PATH = "/lib/x86_64-linux-gnu/libfuse.so.2.9.9";
+	private static final String DEFAULT_LIB_PATH = "/lib/x86_64-linux-gnu/libfuse3.so.3";
 	private static final Errno ERRNO = new LinuxErrno();
 	private String libraryPath;
 
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java
index 20ca2222..ad68f710 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/StatImpl.java
@@ -65,46 +65,4 @@ public long getSize() {
 		return stat.st_size$get(segment);
 	}
 
-	@Override
-	public boolean isDir() {
-		return (getMode() & stat_h.S_IFDIR()) == stat_h.S_IFDIR();
-	}
-
-	@Override
-	public void toggleDir(boolean isDir) {
-		if (isDir) {
-			setMode(getMode() | stat_h.S_IFDIR());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFDIR());
-		}
-	}
-
-	@Override
-	public boolean isReg() {
-		return (getMode() & stat_h.S_IFREG()) == stat_h.S_IFREG();
-	}
-
-	@Override
-	public void toggleReg(boolean isReg) {
-		if (isReg) {
-			setMode(getMode() | stat_h.S_IFREG());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFREG());
-		}
-	}
-
-	@Override
-	public boolean isLnk() {
-		return (getMode() & stat_h.S_IFLNK()) == stat_h.S_IFLNK();
-	}
-
-	@Override
-	public void toggleLnk(boolean isLnk) {
-		if (isLnk) {
-			setMode(getMode() | stat_h.S_IFLNK());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFLNK());
-		}
-	}
-
 }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/constants$0.java
index a7a3b33c..8ee42214 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/constants$0.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/constants$0.java
@@ -13,33 +13,43 @@ class constants$0 {
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_INT$LAYOUT
     );
     static final MethodHandle fuse_fill_dir_t$MH = RuntimeHelper.downcallHandle(
         constants$0.fuse_fill_dir_t$FUNC
     );
-    static final FunctionDescriptor fuse_exit$FUNC = FunctionDescriptor.ofVoid(
+    static final FunctionDescriptor fuse_lib_help$FUNC = FunctionDescriptor.ofVoid(
         Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_exit$MH = RuntimeHelper.downcallHandle(
-        "fuse_exit",
-        constants$0.fuse_exit$FUNC
-    );
-    static final FunctionDescriptor fuse_get_context$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT);
-    static final MethodHandle fuse_get_context$MH = RuntimeHelper.downcallHandle(
-        "fuse_get_context",
-        constants$0.fuse_get_context$FUNC
+    static final MethodHandle fuse_lib_help$MH = RuntimeHelper.downcallHandle(
+        "fuse_lib_help",
+        constants$0.fuse_lib_help$FUNC
     );
-    static final FunctionDescriptor fuse_main_real$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_INT$LAYOUT,
+    static final FunctionDescriptor fuse_new$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_main_real$MH = RuntimeHelper.downcallHandle(
-        "fuse_main_real",
-        constants$0.fuse_main_real$FUNC
+    static final MethodHandle fuse_new$MH = RuntimeHelper.downcallHandle(
+        "fuse_new",
+        constants$0.fuse_new$FUNC
+    );
+    static final FunctionDescriptor fuse_mount$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_mount$MH = RuntimeHelper.downcallHandle(
+        "fuse_mount",
+        constants$0.fuse_mount$FUNC
+    );
+    static final FunctionDescriptor fuse_unmount$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_unmount$MH = RuntimeHelper.downcallHandle(
+        "fuse_unmount",
+        constants$0.fuse_unmount$FUNC
     );
 }
 
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/constants$1.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/constants$1.java
new file mode 100644
index 00000000..a6d7fef2
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/constants$1.java
@@ -0,0 +1,50 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.amd64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+class constants$1 {
+
+    static final FunctionDescriptor fuse_destroy$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_destroy$MH = RuntimeHelper.downcallHandle(
+        "fuse_destroy",
+        constants$1.fuse_destroy$FUNC
+    );
+    static final FunctionDescriptor fuse_loop$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_loop$MH = RuntimeHelper.downcallHandle(
+        "fuse_loop",
+        constants$1.fuse_loop$FUNC
+    );
+    static final FunctionDescriptor fuse_exit$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_exit$MH = RuntimeHelper.downcallHandle(
+        "fuse_exit",
+        constants$1.fuse_exit$FUNC
+    );
+    static final FunctionDescriptor fuse_loop_mt$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_loop_mt$MH = RuntimeHelper.downcallHandle(
+        "fuse_loop_mt",
+        constants$1.fuse_loop_mt$FUNC
+    );
+    static final FunctionDescriptor fuse_get_session$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_get_session$MH = RuntimeHelper.downcallHandle(
+        "fuse_get_session",
+        constants$1.fuse_get_session$FUNC
+    );
+}
+
+
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_args.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_args.java
new file mode 100644
index 00000000..ad44b601
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_args.java
@@ -0,0 +1,78 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.amd64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_args {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_INT$LAYOUT.withName("argc"),
+        MemoryLayout.paddingLayout(32),
+        Constants$root.C_POINTER$LAYOUT.withName("argv"),
+        Constants$root.C_INT$LAYOUT.withName("allocated"),
+        MemoryLayout.paddingLayout(32)
+    ).withName("fuse_args");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_args.$struct$LAYOUT;
+    }
+    static final VarHandle argc$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argc"));
+    public static VarHandle argc$VH() {
+        return fuse_args.argc$VH;
+    }
+    public static int argc$get(MemorySegment seg) {
+        return (int)fuse_args.argc$VH.get(seg);
+    }
+    public static void argc$set( MemorySegment seg, int x) {
+        fuse_args.argc$VH.set(seg, x);
+    }
+    public static int argc$get(MemorySegment seg, long index) {
+        return (int)fuse_args.argc$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argc$set(MemorySegment seg, long index, int x) {
+        fuse_args.argc$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle argv$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argv"));
+    public static VarHandle argv$VH() {
+        return fuse_args.argv$VH;
+    }
+    public static MemoryAddress argv$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg);
+    }
+    public static void argv$set( MemorySegment seg, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg, x);
+    }
+    public static MemoryAddress argv$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argv$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle allocated$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
+    public static VarHandle allocated$VH() {
+        return fuse_args.allocated$VH;
+    }
+    public static int allocated$get(MemorySegment seg) {
+        return (int)fuse_args.allocated$VH.get(seg);
+    }
+    public static void allocated$set( MemorySegment seg, int x) {
+        fuse_args.allocated$VH.set(seg, x);
+    }
+    public static int allocated$get(MemorySegment seg, long index) {
+        return (int)fuse_args.allocated$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void allocated$set(MemorySegment seg, long index, int x) {
+        fuse_args.allocated$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_conn_info.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_conn_info.java
index e1142c51..1dda6cea 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_conn_info.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_conn_info.java
@@ -12,14 +12,15 @@ public class fuse_conn_info {
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_INT$LAYOUT.withName("proto_major"),
         Constants$root.C_INT$LAYOUT.withName("proto_minor"),
-        Constants$root.C_INT$LAYOUT.withName("async_read"),
         Constants$root.C_INT$LAYOUT.withName("max_write"),
+        Constants$root.C_INT$LAYOUT.withName("max_read"),
         Constants$root.C_INT$LAYOUT.withName("max_readahead"),
         Constants$root.C_INT$LAYOUT.withName("capable"),
         Constants$root.C_INT$LAYOUT.withName("want"),
         Constants$root.C_INT$LAYOUT.withName("max_background"),
         Constants$root.C_INT$LAYOUT.withName("congestion_threshold"),
-        MemoryLayout.sequenceLayout(23, Constants$root.C_INT$LAYOUT).withName("reserved")
+        Constants$root.C_INT$LAYOUT.withName("time_gran"),
+        MemoryLayout.sequenceLayout(22, Constants$root.C_INT$LAYOUT).withName("reserved")
     ).withName("fuse_conn_info");
     public static MemoryLayout $LAYOUT() {
         return fuse_conn_info.$struct$LAYOUT;
@@ -56,22 +57,6 @@ public class fuse_conn_info {
     public static void proto_minor$set(MemorySegment seg, long index, int x) {
         fuse_conn_info.proto_minor$VH.set(seg.asSlice(index*sizeof()), x);
     }
-    static final VarHandle async_read$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("async_read"));
-    public static VarHandle async_read$VH() {
-        return fuse_conn_info.async_read$VH;
-    }
-    public static int async_read$get(MemorySegment seg) {
-        return (int)fuse_conn_info.async_read$VH.get(seg);
-    }
-    public static void async_read$set( MemorySegment seg, int x) {
-        fuse_conn_info.async_read$VH.set(seg, x);
-    }
-    public static int async_read$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.async_read$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void async_read$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.async_read$VH.set(seg.asSlice(index*sizeof()), x);
-    }
     static final VarHandle max_write$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
     public static VarHandle max_write$VH() {
         return fuse_conn_info.max_write$VH;
@@ -88,6 +73,22 @@ public class fuse_conn_info {
     public static void max_write$set(MemorySegment seg, long index, int x) {
         fuse_conn_info.max_write$VH.set(seg.asSlice(index*sizeof()), x);
     }
+    static final VarHandle max_read$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_read"));
+    public static VarHandle max_read$VH() {
+        return fuse_conn_info.max_read$VH;
+    }
+    public static int max_read$get(MemorySegment seg) {
+        return (int)fuse_conn_info.max_read$VH.get(seg);
+    }
+    public static void max_read$set( MemorySegment seg, int x) {
+        fuse_conn_info.max_read$VH.set(seg, x);
+    }
+    public static int max_read$get(MemorySegment seg, long index) {
+        return (int)fuse_conn_info.max_read$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_read$set(MemorySegment seg, long index, int x) {
+        fuse_conn_info.max_read$VH.set(seg.asSlice(index*sizeof()), x);
+    }
     static final VarHandle max_readahead$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
     public static VarHandle max_readahead$VH() {
         return fuse_conn_info.max_readahead$VH;
@@ -168,8 +169,24 @@ public class fuse_conn_info {
     public static void congestion_threshold$set(MemorySegment seg, long index, int x) {
         fuse_conn_info.congestion_threshold$VH.set(seg.asSlice(index*sizeof()), x);
     }
+    static final VarHandle time_gran$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("time_gran"));
+    public static VarHandle time_gran$VH() {
+        return fuse_conn_info.time_gran$VH;
+    }
+    public static int time_gran$get(MemorySegment seg) {
+        return (int)fuse_conn_info.time_gran$VH.get(seg);
+    }
+    public static void time_gran$set( MemorySegment seg, int x) {
+        fuse_conn_info.time_gran$VH.set(seg, x);
+    }
+    public static int time_gran$get(MemorySegment seg, long index) {
+        return (int)fuse_conn_info.time_gran$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void time_gran$set(MemorySegment seg, long index, int x) {
+        fuse_conn_info.time_gran$VH.set(seg.asSlice(index*sizeof()), x);
+    }
     public static MemorySegment reserved$slice(MemorySegment seg) {
-        return seg.asSlice(36, 92);
+        return seg.asSlice(40, 88);
     }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_context.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_context.java
deleted file mode 100644
index 1f25faca..00000000
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_context.java
+++ /dev/null
@@ -1,129 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.linux.amd64.extr;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-public class fuse_context {
-
-    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
-        Constants$root.C_POINTER$LAYOUT.withName("fuse"),
-        Constants$root.C_INT$LAYOUT.withName("uid"),
-        Constants$root.C_INT$LAYOUT.withName("gid"),
-        Constants$root.C_INT$LAYOUT.withName("pid"),
-        MemoryLayout.paddingLayout(32),
-        Constants$root.C_POINTER$LAYOUT.withName("private_data"),
-        Constants$root.C_INT$LAYOUT.withName("umask"),
-        MemoryLayout.paddingLayout(32)
-    ).withName("fuse_context");
-    public static MemoryLayout $LAYOUT() {
-        return fuse_context.$struct$LAYOUT;
-    }
-    static final VarHandle fuse$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fuse"));
-    public static VarHandle fuse$VH() {
-        return fuse_context.fuse$VH;
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg);
-    }
-    public static void fuse$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg, x);
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fuse$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle uid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("uid"));
-    public static VarHandle uid$VH() {
-        return fuse_context.uid$VH;
-    }
-    public static int uid$get(MemorySegment seg) {
-        return (int)fuse_context.uid$VH.get(seg);
-    }
-    public static void uid$set( MemorySegment seg, int x) {
-        fuse_context.uid$VH.set(seg, x);
-    }
-    public static int uid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.uid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void uid$set(MemorySegment seg, long index, int x) {
-        fuse_context.uid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle gid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("gid"));
-    public static VarHandle gid$VH() {
-        return fuse_context.gid$VH;
-    }
-    public static int gid$get(MemorySegment seg) {
-        return (int)fuse_context.gid$VH.get(seg);
-    }
-    public static void gid$set( MemorySegment seg, int x) {
-        fuse_context.gid$VH.set(seg, x);
-    }
-    public static int gid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.gid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void gid$set(MemorySegment seg, long index, int x) {
-        fuse_context.gid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle pid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("pid"));
-    public static VarHandle pid$VH() {
-        return fuse_context.pid$VH;
-    }
-    public static int pid$get(MemorySegment seg) {
-        return (int)fuse_context.pid$VH.get(seg);
-    }
-    public static void pid$set( MemorySegment seg, int x) {
-        fuse_context.pid$VH.set(seg, x);
-    }
-    public static int pid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.pid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void pid$set(MemorySegment seg, long index, int x) {
-        fuse_context.pid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle private_data$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("private_data"));
-    public static VarHandle private_data$VH() {
-        return fuse_context.private_data$VH;
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg);
-    }
-    public static void private_data$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg, x);
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void private_data$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle umask$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("umask"));
-    public static VarHandle umask$VH() {
-        return fuse_context.umask$VH;
-    }
-    public static int umask$get(MemorySegment seg) {
-        return (int)fuse_context.umask$VH.get(seg);
-    }
-    public static void umask$set( MemorySegment seg, int x) {
-        fuse_context.umask$VH.set(seg, x);
-    }
-    public static int umask$get(MemorySegment seg, long index) {
-        return (int)fuse_context.umask$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void umask$set(MemorySegment seg, long index, int x) {
-        fuse_context.umask$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
-    }
-    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
-}
-
-
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_file_info.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_file_info.java
index 4665a84b..60c07e93 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_file_info.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_file_info.java
@@ -11,19 +11,23 @@ public class fuse_file_info {
 
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_INT$LAYOUT.withName("flags"),
-        MemoryLayout.paddingLayout(32),
-        Constants$root.C_LONG_LONG$LAYOUT.withName("fh_old"),
-        Constants$root.C_INT$LAYOUT.withName("writepage"),
         MemoryLayout.structLayout(
+            MemoryLayout.paddingLayout(1).withName("writepage"),
             MemoryLayout.paddingLayout(1).withName("direct_io"),
             MemoryLayout.paddingLayout(1).withName("keep_cache"),
             MemoryLayout.paddingLayout(1).withName("flush"),
             MemoryLayout.paddingLayout(1).withName("nonseekable"),
             MemoryLayout.paddingLayout(1).withName("flock_release"),
-            MemoryLayout.paddingLayout(27).withName("padding")
+            MemoryLayout.paddingLayout(1).withName("cache_readdir"),
+            MemoryLayout.paddingLayout(1).withName("noflush"),
+            MemoryLayout.paddingLayout(24).withName("padding"),
+            MemoryLayout.paddingLayout(32).withName("padding2"),
+            MemoryLayout.paddingLayout(32)
         ),
         Constants$root.C_LONG_LONG$LAYOUT.withName("fh"),
-        Constants$root.C_LONG_LONG$LAYOUT.withName("lock_owner")
+        Constants$root.C_LONG_LONG$LAYOUT.withName("lock_owner"),
+        Constants$root.C_INT$LAYOUT.withName("poll_events"),
+        MemoryLayout.paddingLayout(32)
     ).withName("fuse_file_info");
     public static MemoryLayout $LAYOUT() {
         return fuse_file_info.$struct$LAYOUT;
@@ -44,38 +48,6 @@ public class fuse_file_info {
     public static void flags$set(MemorySegment seg, long index, int x) {
         fuse_file_info.flags$VH.set(seg.asSlice(index*sizeof()), x);
     }
-    static final VarHandle fh_old$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fh_old"));
-    public static VarHandle fh_old$VH() {
-        return fuse_file_info.fh_old$VH;
-    }
-    public static long fh_old$get(MemorySegment seg) {
-        return (long)fuse_file_info.fh_old$VH.get(seg);
-    }
-    public static void fh_old$set( MemorySegment seg, long x) {
-        fuse_file_info.fh_old$VH.set(seg, x);
-    }
-    public static long fh_old$get(MemorySegment seg, long index) {
-        return (long)fuse_file_info.fh_old$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fh_old$set(MemorySegment seg, long index, long x) {
-        fuse_file_info.fh_old$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle writepage$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("writepage"));
-    public static VarHandle writepage$VH() {
-        return fuse_file_info.writepage$VH;
-    }
-    public static int writepage$get(MemorySegment seg) {
-        return (int)fuse_file_info.writepage$VH.get(seg);
-    }
-    public static void writepage$set( MemorySegment seg, int x) {
-        fuse_file_info.writepage$VH.set(seg, x);
-    }
-    public static int writepage$get(MemorySegment seg, long index) {
-        return (int)fuse_file_info.writepage$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void writepage$set(MemorySegment seg, long index, int x) {
-        fuse_file_info.writepage$VH.set(seg.asSlice(index*sizeof()), x);
-    }
     static final VarHandle fh$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fh"));
     public static VarHandle fh$VH() {
         return fuse_file_info.fh$VH;
@@ -108,6 +80,22 @@ public class fuse_file_info {
     public static void lock_owner$set(MemorySegment seg, long index, long x) {
         fuse_file_info.lock_owner$VH.set(seg.asSlice(index*sizeof()), x);
     }
+    static final VarHandle poll_events$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("poll_events"));
+    public static VarHandle poll_events$VH() {
+        return fuse_file_info.poll_events$VH;
+    }
+    public static int poll_events$get(MemorySegment seg) {
+        return (int)fuse_file_info.poll_events$VH.get(seg);
+    }
+    public static void poll_events$set( MemorySegment seg, int x) {
+        fuse_file_info.poll_events$VH.set(seg, x);
+    }
+    public static int poll_events$get(MemorySegment seg, long index) {
+        return (int)fuse_file_info.poll_events$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void poll_events$set(MemorySegment seg, long index, int x) {
+        fuse_file_info.poll_events$VH.set(seg.asSlice(index*sizeof()), x);
+    }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
     public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_fill_dir_t.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_fill_dir_t.java
index fe18e103..e7fe2602 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_fill_dir_t.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_fill_dir_t.java
@@ -9,15 +9,15 @@
 import static java.lang.foreign.ValueLayout.*;
 public interface fuse_fill_dir_t {
 
-    int apply(java.lang.foreign.MemoryAddress buf, java.lang.foreign.MemoryAddress name, java.lang.foreign.MemoryAddress stbuf, long off);
+    int apply(java.lang.foreign.MemoryAddress buf, java.lang.foreign.MemoryAddress name, java.lang.foreign.MemoryAddress stbuf, long off, int flags);
     static MemorySegment allocate(fuse_fill_dir_t fi, MemorySession session) {
         return RuntimeHelper.upcallStub(fuse_fill_dir_t.class, fi, constants$0.fuse_fill_dir_t$FUNC, session);
     }
     static fuse_fill_dir_t ofAddress(MemoryAddress addr, MemorySession session) {
         MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-        return (java.lang.foreign.MemoryAddress _buf, java.lang.foreign.MemoryAddress _name, java.lang.foreign.MemoryAddress _stbuf, long _off) -> {
+        return (java.lang.foreign.MemoryAddress _buf, java.lang.foreign.MemoryAddress _name, java.lang.foreign.MemoryAddress _stbuf, long _off, int _flags) -> {
             try {
-                return (int)constants$0.fuse_fill_dir_t$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)_buf, (java.lang.foreign.Addressable)_name, (java.lang.foreign.Addressable)_stbuf, _off);
+                return (int)constants$0.fuse_fill_dir_t$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)_buf, (java.lang.foreign.Addressable)_name, (java.lang.foreign.Addressable)_stbuf, _off, _flags);
             } catch (Throwable ex$) {
                 throw new AssertionError("should not reach here", ex$);
             }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_h.java
index 7480a376..e188e1d8 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_h.java
@@ -18,8 +18,74 @@ public class fuse_h  {
     public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
     public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
     public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
+    public static MethodHandle fuse_lib_help$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_lib_help$MH,"fuse_lib_help");
+    }
+    public static void fuse_lib_help ( Addressable args) {
+        var mh$ = fuse_lib_help$MH();
+        try {
+            mh$.invokeExact(args);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_new$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_new$MH,"fuse_new");
+    }
+    public static MemoryAddress fuse_new ( Addressable args,  Addressable op,  long op_size,  Addressable private_data) {
+        var mh$ = fuse_new$MH();
+        try {
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(args, op, op_size, private_data);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_mount$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_mount$MH,"fuse_mount");
+    }
+    public static int fuse_mount ( Addressable f,  Addressable mountpoint) {
+        var mh$ = fuse_mount$MH();
+        try {
+            return (int)mh$.invokeExact(f, mountpoint);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_unmount$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_unmount$MH,"fuse_unmount");
+    }
+    public static void fuse_unmount ( Addressable f) {
+        var mh$ = fuse_unmount$MH();
+        try {
+            mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_destroy$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_destroy$MH,"fuse_destroy");
+    }
+    public static void fuse_destroy ( Addressable f) {
+        var mh$ = fuse_destroy$MH();
+        try {
+            mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_loop$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_loop$MH,"fuse_loop");
+    }
+    public static int fuse_loop ( Addressable f) {
+        var mh$ = fuse_loop$MH();
+        try {
+            return (int)mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
     public static MethodHandle fuse_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_exit$MH,"fuse_exit");
+        return RuntimeHelper.requireNonNull(constants$1.fuse_exit$MH,"fuse_exit");
     }
     public static void fuse_exit ( Addressable f) {
         var mh$ = fuse_exit$MH();
@@ -29,24 +95,24 @@ public static void fuse_exit ( Addressable f) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_get_context$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_get_context$MH,"fuse_get_context");
+    public static MethodHandle fuse_loop_mt$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_loop_mt$MH,"fuse_loop_mt");
     }
-    public static MemoryAddress fuse_get_context () {
-        var mh$ = fuse_get_context$MH();
+    public static int fuse_loop_mt ( Addressable f,  Addressable config) {
+        var mh$ = fuse_loop_mt$MH();
         try {
-            return (java.lang.foreign.MemoryAddress)mh$.invokeExact();
+            return (int)mh$.invokeExact(f, config);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_main_real$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_main_real$MH,"fuse_main_real");
+    public static MethodHandle fuse_get_session$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_get_session$MH,"fuse_get_session");
     }
-    public static int fuse_main_real ( int argc,  Addressable argv,  Addressable op,  long op_size,  Addressable user_data) {
-        var mh$ = fuse_main_real$MH();
+    public static MemoryAddress fuse_get_session ( Addressable f) {
+        var mh$ = fuse_get_session$MH();
         try {
-            return (int)mh$.invokeExact(argc, argv, op, op_size, user_data);
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(f);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_loop_config.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_loop_config.java
new file mode 100644
index 00000000..093a4f0d
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_loop_config.java
@@ -0,0 +1,59 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.amd64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_loop_config {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_INT$LAYOUT.withName("clone_fd"),
+        Constants$root.C_INT$LAYOUT.withName("max_idle_threads")
+    ).withName("fuse_loop_config");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_loop_config.$struct$LAYOUT;
+    }
+    static final VarHandle clone_fd$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
+    public static VarHandle clone_fd$VH() {
+        return fuse_loop_config.clone_fd$VH;
+    }
+    public static int clone_fd$get(MemorySegment seg) {
+        return (int)fuse_loop_config.clone_fd$VH.get(seg);
+    }
+    public static void clone_fd$set( MemorySegment seg, int x) {
+        fuse_loop_config.clone_fd$VH.set(seg, x);
+    }
+    public static int clone_fd$get(MemorySegment seg, long index) {
+        return (int)fuse_loop_config.clone_fd$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void clone_fd$set(MemorySegment seg, long index, int x) {
+        fuse_loop_config.clone_fd$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_idle_threads$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
+    public static VarHandle max_idle_threads$VH() {
+        return fuse_loop_config.max_idle_threads$VH;
+    }
+    public static int max_idle_threads$get(MemorySegment seg) {
+        return (int)fuse_loop_config.max_idle_threads$VH.get(seg);
+    }
+    public static void max_idle_threads$set( MemorySegment seg, int x) {
+        fuse_loop_config.max_idle_threads$VH.set(seg, x);
+    }
+    public static int max_idle_threads$get(MemorySegment seg, long index) {
+        return (int)fuse_loop_config.max_idle_threads$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
+        fuse_loop_config.max_idle_threads$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_operations.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_operations.java
index 5bb84475..37795014 100644
--- a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_operations.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/fuse_operations.java
@@ -12,7 +12,6 @@ public class fuse_operations {
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_POINTER$LAYOUT.withName("getattr"),
         Constants$root.C_POINTER$LAYOUT.withName("readlink"),
-        Constants$root.C_POINTER$LAYOUT.withName("getdir"),
         Constants$root.C_POINTER$LAYOUT.withName("mknod"),
         Constants$root.C_POINTER$LAYOUT.withName("mkdir"),
         Constants$root.C_POINTER$LAYOUT.withName("unlink"),
@@ -23,7 +22,6 @@ public class fuse_operations {
         Constants$root.C_POINTER$LAYOUT.withName("chmod"),
         Constants$root.C_POINTER$LAYOUT.withName("chown"),
         Constants$root.C_POINTER$LAYOUT.withName("truncate"),
-        Constants$root.C_POINTER$LAYOUT.withName("utime"),
         Constants$root.C_POINTER$LAYOUT.withName("open"),
         Constants$root.C_POINTER$LAYOUT.withName("read"),
         Constants$root.C_POINTER$LAYOUT.withName("write"),
@@ -43,29 +41,23 @@ public class fuse_operations {
         Constants$root.C_POINTER$LAYOUT.withName("destroy"),
         Constants$root.C_POINTER$LAYOUT.withName("access"),
         Constants$root.C_POINTER$LAYOUT.withName("create"),
-        Constants$root.C_POINTER$LAYOUT.withName("ftruncate"),
-        Constants$root.C_POINTER$LAYOUT.withName("fgetattr"),
         Constants$root.C_POINTER$LAYOUT.withName("lock"),
         Constants$root.C_POINTER$LAYOUT.withName("utimens"),
         Constants$root.C_POINTER$LAYOUT.withName("bmap"),
-        MemoryLayout.structLayout(
-            MemoryLayout.paddingLayout(1).withName("flag_nullpath_ok"),
-            MemoryLayout.paddingLayout(1).withName("flag_nopath"),
-            MemoryLayout.paddingLayout(1).withName("flag_utime_omit_ok"),
-            MemoryLayout.paddingLayout(29).withName("flag_reserved"),
-            MemoryLayout.paddingLayout(32)
-        ),
         Constants$root.C_POINTER$LAYOUT.withName("ioctl"),
         Constants$root.C_POINTER$LAYOUT.withName("poll"),
         Constants$root.C_POINTER$LAYOUT.withName("write_buf"),
         Constants$root.C_POINTER$LAYOUT.withName("read_buf"),
         Constants$root.C_POINTER$LAYOUT.withName("flock"),
-        Constants$root.C_POINTER$LAYOUT.withName("fallocate")
+        Constants$root.C_POINTER$LAYOUT.withName("fallocate"),
+        Constants$root.C_POINTER$LAYOUT.withName("copy_file_range"),
+        Constants$root.C_POINTER$LAYOUT.withName("lseek")
     ).withName("fuse_operations");
     public static MemoryLayout $LAYOUT() {
         return fuse_operations.$struct$LAYOUT;
     }
     static final FunctionDescriptor getattr$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
@@ -74,15 +66,15 @@ public class fuse_operations {
     );
     public interface getattr {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(getattr fi, MemorySession session) {
             return RuntimeHelper.upcallStub(getattr.class, fi, fuse_operations.getattr$FUNC, session);
         }
         static getattr ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.getattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse_operations.getattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -154,51 +146,6 @@ static readlink ofAddress(MemoryAddress addr, MemorySession session) {
     public static readlink readlink (MemorySegment segment, MemorySession session) {
         return readlink.ofAddress(readlink$get(segment), session);
     }
-    static final FunctionDescriptor getdir$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle getdir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.getdir$FUNC
-    );
-    public interface getdir {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(getdir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(getdir.class, fi, fuse_operations.getdir$FUNC, session);
-        }
-        static getdir ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.getdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle getdir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("getdir"));
-    public static VarHandle getdir$VH() {
-        return fuse_operations.getdir$VH;
-    }
-    public static MemoryAddress getdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getdir$VH.get(seg);
-    }
-    public static void getdir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.getdir$VH.set(seg, x);
-    }
-    public static MemoryAddress getdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getdir$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getdir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.getdir$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getdir getdir (MemorySegment segment, MemorySession session) {
-        return getdir.ofAddress(getdir$get(segment), session);
-    }
     static final FunctionDescriptor mknod$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_INT$LAYOUT,
@@ -420,22 +367,23 @@ public static symlink symlink (MemorySegment segment, MemorySession session) {
     }
     static final FunctionDescriptor rename$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_INT$LAYOUT
     );
     static final MethodHandle rename$MH = RuntimeHelper.downcallHandle(
         fuse_operations.rename$FUNC
     );
     public interface rename {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, int _x2);
         static MemorySegment allocate(rename fi, MemorySession session) {
             return RuntimeHelper.upcallStub(rename.class, fi, fuse_operations.rename$FUNC, session);
         }
         static rename ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, int __x2) -> {
                 try {
-                    return (int)fuse_operations.rename$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse_operations.rename$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -508,22 +456,23 @@ public static link link (MemorySegment segment, MemorySession session) {
     }
     static final FunctionDescriptor chmod$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_INT$LAYOUT
+        Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle chmod$MH = RuntimeHelper.downcallHandle(
         fuse_operations.chmod$FUNC
     );
     public interface chmod {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, int _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(chmod fi, MemorySession session) {
             return RuntimeHelper.upcallStub(chmod.class, fi, fuse_operations.chmod$FUNC, session);
         }
         static chmod ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, int __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, int __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.chmod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse_operations.chmod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -553,22 +502,23 @@ public static chmod chmod (MemorySegment segment, MemorySession session) {
     static final FunctionDescriptor chown$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_INT$LAYOUT,
-        Constants$root.C_INT$LAYOUT
+        Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle chown$MH = RuntimeHelper.downcallHandle(
         fuse_operations.chown$FUNC
     );
     public interface chown {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, int _x2);
+        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, int _x2, java.lang.foreign.MemoryAddress _x3);
         static MemorySegment allocate(chown fi, MemorySession session) {
             return RuntimeHelper.upcallStub(chown.class, fi, fuse_operations.chown$FUNC, session);
         }
         static chown ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, int __x1, int __x2) -> {
+            return (java.lang.foreign.MemoryAddress __x0, int __x1, int __x2, java.lang.foreign.MemoryAddress __x3) -> {
                 try {
-                    return (int)fuse_operations.chown$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2);
+                    return (int)fuse_operations.chown$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2, (java.lang.foreign.Addressable)__x3);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -597,22 +547,23 @@ public static chown chown (MemorySegment segment, MemorySession session) {
     }
     static final FunctionDescriptor truncate$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle truncate$MH = RuntimeHelper.downcallHandle(
         fuse_operations.truncate$FUNC
     );
     public interface truncate {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, long _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, long _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(truncate fi, MemorySession session) {
             return RuntimeHelper.upcallStub(truncate.class, fi, fuse_operations.truncate$FUNC, session);
         }
         static truncate ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, long __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, long __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.truncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse_operations.truncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -639,50 +590,6 @@ static truncate ofAddress(MemoryAddress addr, MemorySession session) {
     public static truncate truncate (MemorySegment segment, MemorySession session) {
         return truncate.ofAddress(truncate$get(segment), session);
     }
-    static final FunctionDescriptor utime$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle utime$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.utime$FUNC
-    );
-    public interface utime {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(utime fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(utime.class, fi, fuse_operations.utime$FUNC, session);
-        }
-        static utime ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.utime$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle utime$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("utime"));
-    public static VarHandle utime$VH() {
-        return fuse_operations.utime$VH;
-    }
-    public static MemoryAddress utime$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utime$VH.get(seg);
-    }
-    public static void utime$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.utime$VH.set(seg, x);
-    }
-    public static MemoryAddress utime$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utime$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utime$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.utime$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utime utime (MemorySegment segment, MemorySession session) {
-        return utime.ofAddress(utime$get(segment), session);
-    }
     static final FunctionDescriptor open$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
@@ -1229,22 +1136,23 @@ public static opendir opendir (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_INT$LAYOUT
     );
     static final MethodHandle readdir$MH = RuntimeHelper.downcallHandle(
         fuse_operations.readdir$FUNC
     );
     public interface readdir {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3, java.lang.foreign.MemoryAddress _x4);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3, java.lang.foreign.MemoryAddress _x4, int _x5);
         static MemorySegment allocate(readdir fi, MemorySession session) {
             return RuntimeHelper.upcallStub(readdir.class, fi, fuse_operations.readdir$FUNC, session);
         }
         static readdir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3, java.lang.foreign.MemoryAddress __x4) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3, java.lang.foreign.MemoryAddress __x4, int __x5) -> {
                 try {
-                    return (int)fuse_operations.readdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, (java.lang.foreign.Addressable)__x4);
+                    return (int)fuse_operations.readdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, (java.lang.foreign.Addressable)__x4, __x5);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1361,6 +1269,7 @@ public static fsyncdir fsyncdir (MemorySegment segment, MemorySession session) {
         return fsyncdir.ofAddress(fsyncdir$get(segment), session);
     }
     static final FunctionDescriptor init$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle init$MH = RuntimeHelper.downcallHandle(
@@ -1368,15 +1277,15 @@ public static fsyncdir fsyncdir (MemorySegment segment, MemorySession session) {
     );
     public interface init {
 
-        java.lang.foreign.Addressable apply(java.lang.foreign.MemoryAddress _x0);
+        java.lang.foreign.Addressable apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(init fi, MemorySession session) {
             return RuntimeHelper.upcallStub(init.class, fi, fuse_operations.init$FUNC, session);
         }
         static init ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (java.lang.foreign.Addressable)(java.lang.foreign.MemoryAddress)fuse_operations.init$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
+                    return (java.lang.foreign.Addressable)(java.lang.foreign.MemoryAddress)fuse_operations.init$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1535,96 +1444,6 @@ static create ofAddress(MemoryAddress addr, MemorySession session) {
     public static create create (MemorySegment segment, MemorySession session) {
         return create.ofAddress(create$get(segment), session);
     }
-    static final FunctionDescriptor ftruncate$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle ftruncate$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.ftruncate$FUNC
-    );
-    public interface ftruncate {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, long _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(ftruncate fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(ftruncate.class, fi, fuse_operations.ftruncate$FUNC, session);
-        }
-        static ftruncate ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, long __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.ftruncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle ftruncate$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("ftruncate"));
-    public static VarHandle ftruncate$VH() {
-        return fuse_operations.ftruncate$VH;
-    }
-    public static MemoryAddress ftruncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ftruncate$VH.get(seg);
-    }
-    public static void ftruncate$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.ftruncate$VH.set(seg, x);
-    }
-    public static MemoryAddress ftruncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ftruncate$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ftruncate$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.ftruncate$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ftruncate ftruncate (MemorySegment segment, MemorySession session) {
-        return ftruncate.ofAddress(ftruncate$get(segment), session);
-    }
-    static final FunctionDescriptor fgetattr$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle fgetattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.fgetattr$FUNC
-    );
-    public interface fgetattr {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(fgetattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(fgetattr.class, fi, fuse_operations.fgetattr$FUNC, session);
-        }
-        static fgetattr ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.fgetattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle fgetattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fgetattr"));
-    public static VarHandle fgetattr$VH() {
-        return fuse_operations.fgetattr$VH;
-    }
-    public static MemoryAddress fgetattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fgetattr$VH.get(seg);
-    }
-    public static void fgetattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.fgetattr$VH.set(seg, x);
-    }
-    public static MemoryAddress fgetattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fgetattr$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fgetattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.fgetattr$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fgetattr fgetattr (MemorySegment segment, MemorySession session) {
-        return fgetattr.ofAddress(fgetattr$get(segment), session);
-    }
     static final FunctionDescriptor lock$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
@@ -1672,6 +1491,7 @@ public static lock lock (MemorySegment segment, MemorySession session) {
         return lock.ofAddress(lock$get(segment), session);
     }
     static final FunctionDescriptor utimens$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
@@ -1680,15 +1500,15 @@ public static lock lock (MemorySegment segment, MemorySession session) {
     );
     public interface utimens {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(utimens fi, MemorySession session) {
             return RuntimeHelper.upcallStub(utimens.class, fi, fuse_operations.utimens$FUNC, session);
         }
         static utimens ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.utimens$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse_operations.utimens$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -2039,6 +1859,102 @@ static fallocate ofAddress(MemoryAddress addr, MemorySession session) {
     public static fallocate fallocate (MemorySegment segment, MemorySession session) {
         return fallocate.ofAddress(fallocate$get(segment), session);
     }
+    static final FunctionDescriptor copy_file_range$FUNC = FunctionDescriptor.of(Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_INT$LAYOUT
+    );
+    static final MethodHandle copy_file_range$MH = RuntimeHelper.downcallHandle(
+        fuse_operations.copy_file_range$FUNC
+    );
+    public interface copy_file_range {
+
+        long apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2, java.lang.foreign.MemoryAddress _x3, java.lang.foreign.MemoryAddress _x4, long _x5, long _x6, int _x7);
+        static MemorySegment allocate(copy_file_range fi, MemorySession session) {
+            return RuntimeHelper.upcallStub(copy_file_range.class, fi, fuse_operations.copy_file_range$FUNC, session);
+        }
+        static copy_file_range ofAddress(MemoryAddress addr, MemorySession session) {
+            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2, java.lang.foreign.MemoryAddress __x3, java.lang.foreign.MemoryAddress __x4, long __x5, long __x6, int __x7) -> {
+                try {
+                    return (long)fuse_operations.copy_file_range$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, (java.lang.foreign.Addressable)__x3, (java.lang.foreign.Addressable)__x4, __x5, __x6, __x7);
+                } catch (Throwable ex$) {
+                    throw new AssertionError("should not reach here", ex$);
+                }
+            };
+        }
+    }
+
+    static final VarHandle copy_file_range$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("copy_file_range"));
+    public static VarHandle copy_file_range$VH() {
+        return fuse_operations.copy_file_range$VH;
+    }
+    public static MemoryAddress copy_file_range$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.copy_file_range$VH.get(seg);
+    }
+    public static void copy_file_range$set( MemorySegment seg, MemoryAddress x) {
+        fuse_operations.copy_file_range$VH.set(seg, x);
+    }
+    public static MemoryAddress copy_file_range$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.copy_file_range$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void copy_file_range$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_operations.copy_file_range$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static copy_file_range copy_file_range (MemorySegment segment, MemorySession session) {
+        return copy_file_range.ofAddress(copy_file_range$get(segment), session);
+    }
+    static final FunctionDescriptor lseek$FUNC = FunctionDescriptor.of(Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle lseek$MH = RuntimeHelper.downcallHandle(
+        fuse_operations.lseek$FUNC
+    );
+    public interface lseek {
+
+        long apply(java.lang.foreign.MemoryAddress _x0, long _x1, int _x2, java.lang.foreign.MemoryAddress _x3);
+        static MemorySegment allocate(lseek fi, MemorySession session) {
+            return RuntimeHelper.upcallStub(lseek.class, fi, fuse_operations.lseek$FUNC, session);
+        }
+        static lseek ofAddress(MemoryAddress addr, MemorySession session) {
+            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
+            return (java.lang.foreign.MemoryAddress __x0, long __x1, int __x2, java.lang.foreign.MemoryAddress __x3) -> {
+                try {
+                    return (long)fuse_operations.lseek$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2, (java.lang.foreign.Addressable)__x3);
+                } catch (Throwable ex$) {
+                    throw new AssertionError("should not reach here", ex$);
+                }
+            };
+        }
+    }
+
+    static final VarHandle lseek$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("lseek"));
+    public static VarHandle lseek$VH() {
+        return fuse_operations.lseek$VH;
+    }
+    public static MemoryAddress lseek$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.lseek$VH.get(seg);
+    }
+    public static void lseek$set( MemorySegment seg, MemoryAddress x) {
+        fuse_operations.lseek$VH.set(seg, x);
+    }
+    public static MemoryAddress lseek$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_operations.lseek$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void lseek$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_operations.lseek$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static lseek lseek (MemorySegment segment, MemorySession session) {
+        return lseek.ofAddress(lseek$get(segment), session);
+    }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
     public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/Constants$root.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/Constants$root.java
new file mode 100644
index 00000000..1985592f
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/Constants$root.java
@@ -0,0 +1,23 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.amd64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class Constants$root {
+
+    static final  OfBoolean C_BOOL$LAYOUT = JAVA_BOOLEAN;
+    static final  OfByte C_CHAR$LAYOUT = JAVA_BYTE;
+    static final  OfShort C_SHORT$LAYOUT = JAVA_SHORT.withBitAlignment(16);
+    static final  OfInt C_INT$LAYOUT = JAVA_INT.withBitAlignment(32);
+    static final  OfLong C_LONG$LAYOUT = JAVA_LONG.withBitAlignment(64);
+    static final  OfLong C_LONG_LONG$LAYOUT = JAVA_LONG.withBitAlignment(64);
+    static final  OfFloat C_FLOAT$LAYOUT = JAVA_FLOAT.withBitAlignment(32);
+    static final  OfDouble C_DOUBLE$LAYOUT = JAVA_DOUBLE.withBitAlignment(64);
+    static final  OfAddress C_POINTER$LAYOUT = ADDRESS.withBitAlignment(64);
+}
+
+
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/RuntimeHelper.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/RuntimeHelper.java
new file mode 100644
index 00000000..626b76e3
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/RuntimeHelper.java
@@ -0,0 +1,233 @@
+package org.cryptomator.jfuse.linux.amd64.extr.ll;
+// Generated by jextract
+
+import java.lang.foreign.Addressable;
+import java.lang.foreign.Linker;
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.GroupLayout;
+import java.lang.foreign.SymbolLookup;
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemoryLayout;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.lang.foreign.SegmentAllocator;
+import java.lang.foreign.ValueLayout;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static java.lang.foreign.Linker.*;
+import static java.lang.foreign.ValueLayout.*;
+
+final class RuntimeHelper {
+
+    private RuntimeHelper() {}
+    private final static Linker LINKER = Linker.nativeLinker();
+    private final static ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
+    private final static MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
+    private final static SymbolLookup SYMBOL_LOOKUP;
+
+    final static SegmentAllocator CONSTANT_ALLOCATOR =
+            (size, align) -> MemorySegment.allocateNative(size, align, MemorySession.openImplicit());
+
+    static {
+        
+        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
+        SYMBOL_LOOKUP = name -> loaderLookup.lookup(name).or(() -> LINKER.defaultLookup().lookup(name));
+    }
+
+    static <T> T requireNonNull(T obj, String symbolName) {
+        if (obj == null) {
+            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
+        }
+        return obj;
+    }
+
+    private final static SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
+
+    static final MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
+        return SYMBOL_LOOKUP.lookup(name).map(symbol -> MemorySegment.ofAddress(symbol.address(), layout.byteSize(), MemorySession.openShared())).orElse(null);
+    }
+
+    static final MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
+        return SYMBOL_LOOKUP.lookup(name).
+                map(addr -> LINKER.downcallHandle(addr, fdesc)).
+                orElse(null);
+    }
+
+    static final MethodHandle downcallHandle(FunctionDescriptor fdesc) {
+        return LINKER.downcallHandle(fdesc);
+    }
+
+    static final MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
+        return SYMBOL_LOOKUP.lookup(name).
+                map(addr -> VarargsInvoker.make(addr, fdesc)).
+                orElse(null);
+    }
+
+    static final <Z> MemorySegment upcallStub(Class<Z> fi, Z z, FunctionDescriptor fdesc, MemorySession session) {
+        try {
+            MethodHandle handle = MH_LOOKUP.findVirtual(fi, "apply", Linker.upcallType(fdesc));
+            handle = handle.bindTo(z);
+            return LINKER.upcallStub(handle, fdesc, session);
+        } catch (Throwable ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemorySegment asArray(MemoryAddress addr, MemoryLayout layout, int numElements, MemorySession session) {
+         return MemorySegment.ofAddress(addr, numElements * layout.byteSize(), session);
+    }
+
+    // Internals only below this point
+
+    private static class VarargsInvoker {
+        private static final MethodHandle INVOKE_MH;
+        private final MemorySegment symbol;
+        private final FunctionDescriptor function;
+
+        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
+            this.symbol = symbol;
+            this.function = function;
+        }
+
+        static {
+            try {
+                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
+            } catch (ReflectiveOperationException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
+            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
+            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
+            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
+            for (MemoryLayout layout : function.argumentLayouts()) {
+                mtype = mtype.appendParameterTypes(carrier(layout, false));
+            }
+            mtype = mtype.appendParameterTypes(Object[].class);
+            if (mtype.returnType().equals(MemorySegment.class)) {
+                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
+            } else {
+                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
+            }
+            return handle.asType(mtype);
+        }
+
+        static Class<?> carrier(MemoryLayout layout, boolean ret) {
+            if (layout instanceof ValueLayout valueLayout) {
+                return (ret || valueLayout.carrier() != MemoryAddress.class) ?
+                        valueLayout.carrier() : Addressable.class;
+            } else if (layout instanceof GroupLayout) {
+                return MemorySegment.class;
+            } else {
+                throw new AssertionError("Cannot get here!");
+            }
+        }
+
+        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
+            // one trailing Object[]
+            int nNamedArgs = function.argumentLayouts().size();
+            assert(args.length == nNamedArgs + 1);
+            // The last argument is the array of vararg collector
+            Object[] unnamedArgs = (Object[]) args[args.length - 1];
+
+            int argsCount = nNamedArgs + unnamedArgs.length;
+            Class<?>[] argTypes = new Class<?>[argsCount];
+            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
+
+            int pos = 0;
+            for (pos = 0; pos < nNamedArgs; pos++) {
+                argLayouts[pos] = function.argumentLayouts().get(pos);
+            }
+
+            assert pos == nNamedArgs;
+            for (Object o: unnamedArgs) {
+                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
+                pos++;
+            }
+            assert pos == argsCount;
+
+            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
+                    FunctionDescriptor.ofVoid(argLayouts) :
+                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
+            MethodHandle mh = LINKER.downcallHandle(symbol, f);
+            if (mh.type().returnType() == MemorySegment.class) {
+                mh = mh.bindTo(allocator);
+            }
+            // flatten argument list so that it can be passed to an asSpreader MH
+            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
+            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
+            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
+
+            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
+        }
+
+        private static Class<?> unboxIfNeeded(Class<?> clazz) {
+            if (clazz == Boolean.class) {
+                return boolean.class;
+            } else if (clazz == Void.class) {
+                return void.class;
+            } else if (clazz == Byte.class) {
+                return byte.class;
+            } else if (clazz == Character.class) {
+                return char.class;
+            } else if (clazz == Short.class) {
+                return short.class;
+            } else if (clazz == Integer.class) {
+                return int.class;
+            } else if (clazz == Long.class) {
+                return long.class;
+            } else if (clazz == Float.class) {
+                return float.class;
+            } else if (clazz == Double.class) {
+                return double.class;
+            } else {
+                return clazz;
+            }
+        }
+
+        private Class<?> promote(Class<?> c) {
+            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
+                return long.class;
+            } else if (c == float.class) {
+                return double.class;
+            } else {
+                return c;
+            }
+        }
+
+        private Class<?> normalize(Class<?> c) {
+            c = unboxIfNeeded(c);
+            if (c.isPrimitive()) {
+                return promote(c);
+            }
+            if (MemoryAddress.class.isAssignableFrom(c)) {
+                return MemoryAddress.class;
+            }
+            if (MemorySegment.class.isAssignableFrom(c)) {
+                return MemorySegment.class;
+            }
+            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
+        }
+
+        private MemoryLayout variadicLayout(Class<?> c) {
+            if (c == long.class) {
+                return JAVA_LONG;
+            } else if (c == double.class) {
+                return JAVA_DOUBLE;
+            } else if (MemoryAddress.class.isAssignableFrom(c)) {
+                return ADDRESS;
+            } else {
+                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
+            }
+        }
+    }
+}
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/constants$0.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/constants$0.java
new file mode 100644
index 00000000..30f27df1
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/constants$0.java
@@ -0,0 +1,22 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.amd64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+class constants$0 {
+
+    static final FunctionDescriptor fuse_parse_cmdline$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_parse_cmdline$MH = RuntimeHelper.downcallHandle(
+        "fuse_parse_cmdline",
+        constants$0.fuse_parse_cmdline$FUNC
+    );
+}
+
+
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/fuse_cmdline_opts.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/fuse_cmdline_opts.java
new file mode 100644
index 00000000..56734379
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/fuse_cmdline_opts.java
@@ -0,0 +1,178 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.amd64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_cmdline_opts {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_INT$LAYOUT.withName("singlethread"),
+        Constants$root.C_INT$LAYOUT.withName("foreground"),
+        Constants$root.C_INT$LAYOUT.withName("debug"),
+        Constants$root.C_INT$LAYOUT.withName("nodefault_subtype"),
+        Constants$root.C_POINTER$LAYOUT.withName("mountpoint"),
+        Constants$root.C_INT$LAYOUT.withName("show_version"),
+        Constants$root.C_INT$LAYOUT.withName("show_help"),
+        Constants$root.C_INT$LAYOUT.withName("clone_fd"),
+        Constants$root.C_INT$LAYOUT.withName("max_idle_threads")
+    ).withName("fuse_cmdline_opts");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_cmdline_opts.$struct$LAYOUT;
+    }
+    static final VarHandle singlethread$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("singlethread"));
+    public static VarHandle singlethread$VH() {
+        return fuse_cmdline_opts.singlethread$VH;
+    }
+    public static int singlethread$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.singlethread$VH.get(seg);
+    }
+    public static void singlethread$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.singlethread$VH.set(seg, x);
+    }
+    public static int singlethread$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.singlethread$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void singlethread$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.singlethread$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle foreground$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("foreground"));
+    public static VarHandle foreground$VH() {
+        return fuse_cmdline_opts.foreground$VH;
+    }
+    public static int foreground$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.foreground$VH.get(seg);
+    }
+    public static void foreground$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.foreground$VH.set(seg, x);
+    }
+    public static int foreground$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.foreground$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void foreground$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.foreground$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle debug$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("debug"));
+    public static VarHandle debug$VH() {
+        return fuse_cmdline_opts.debug$VH;
+    }
+    public static int debug$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.debug$VH.get(seg);
+    }
+    public static void debug$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.debug$VH.set(seg, x);
+    }
+    public static int debug$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.debug$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void debug$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.debug$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle nodefault_subtype$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("nodefault_subtype"));
+    public static VarHandle nodefault_subtype$VH() {
+        return fuse_cmdline_opts.nodefault_subtype$VH;
+    }
+    public static int nodefault_subtype$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.nodefault_subtype$VH.get(seg);
+    }
+    public static void nodefault_subtype$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.nodefault_subtype$VH.set(seg, x);
+    }
+    public static int nodefault_subtype$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.nodefault_subtype$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void nodefault_subtype$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.nodefault_subtype$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle mountpoint$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("mountpoint"));
+    public static VarHandle mountpoint$VH() {
+        return fuse_cmdline_opts.mountpoint$VH;
+    }
+    public static MemoryAddress mountpoint$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_cmdline_opts.mountpoint$VH.get(seg);
+    }
+    public static void mountpoint$set( MemorySegment seg, MemoryAddress x) {
+        fuse_cmdline_opts.mountpoint$VH.set(seg, x);
+    }
+    public static MemoryAddress mountpoint$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_cmdline_opts.mountpoint$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void mountpoint$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_cmdline_opts.mountpoint$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle show_version$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("show_version"));
+    public static VarHandle show_version$VH() {
+        return fuse_cmdline_opts.show_version$VH;
+    }
+    public static int show_version$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.show_version$VH.get(seg);
+    }
+    public static void show_version$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.show_version$VH.set(seg, x);
+    }
+    public static int show_version$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.show_version$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void show_version$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.show_version$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle show_help$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("show_help"));
+    public static VarHandle show_help$VH() {
+        return fuse_cmdline_opts.show_help$VH;
+    }
+    public static int show_help$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.show_help$VH.get(seg);
+    }
+    public static void show_help$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.show_help$VH.set(seg, x);
+    }
+    public static int show_help$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.show_help$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void show_help$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.show_help$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle clone_fd$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("clone_fd"));
+    public static VarHandle clone_fd$VH() {
+        return fuse_cmdline_opts.clone_fd$VH;
+    }
+    public static int clone_fd$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.clone_fd$VH.get(seg);
+    }
+    public static void clone_fd$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.clone_fd$VH.set(seg, x);
+    }
+    public static int clone_fd$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.clone_fd$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void clone_fd$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.clone_fd$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_idle_threads$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_idle_threads"));
+    public static VarHandle max_idle_threads$VH() {
+        return fuse_cmdline_opts.max_idle_threads$VH;
+    }
+    public static int max_idle_threads$get(MemorySegment seg) {
+        return (int)fuse_cmdline_opts.max_idle_threads$VH.get(seg);
+    }
+    public static void max_idle_threads$set( MemorySegment seg, int x) {
+        fuse_cmdline_opts.max_idle_threads$VH.set(seg, x);
+    }
+    public static int max_idle_threads$get(MemorySegment seg, long index) {
+        return (int)fuse_cmdline_opts.max_idle_threads$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_idle_threads$set(MemorySegment seg, long index, int x) {
+        fuse_cmdline_opts.max_idle_threads$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/fuse_lowlevel_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/fuse_lowlevel_h.java
new file mode 100644
index 00000000..2c3c67de
--- /dev/null
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/ll/fuse_lowlevel_h.java
@@ -0,0 +1,34 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.linux.amd64.extr.ll;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_lowlevel_h  {
+
+    /* package-private */ fuse_lowlevel_h() {}
+    public static OfByte C_CHAR = Constants$root.C_CHAR$LAYOUT;
+    public static OfShort C_SHORT = Constants$root.C_SHORT$LAYOUT;
+    public static OfInt C_INT = Constants$root.C_INT$LAYOUT;
+    public static OfLong C_LONG = Constants$root.C_LONG_LONG$LAYOUT;
+    public static OfLong C_LONG_LONG = Constants$root.C_LONG_LONG$LAYOUT;
+    public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
+    public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
+    public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
+    public static MethodHandle fuse_parse_cmdline$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_parse_cmdline$MH,"fuse_parse_cmdline");
+    }
+    public static int fuse_parse_cmdline ( Addressable args,  Addressable opts) {
+        var mh$ = fuse_parse_cmdline$MH();
+        try {
+            return (int)mh$.invokeExact(args, opts);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+}
+
+
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/winfsp_fuse_h.java b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio_h.java
similarity index 57%
rename from jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/winfsp_fuse_h.java
rename to jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio_h.java
index 8469bc8b..5e7c828c 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/winfsp_fuse_h.java
+++ b/jfuse-linux-amd64/src/main/java/org/cryptomator/jfuse/linux/amd64/extr/stdio_h.java
@@ -1,23 +1,32 @@
 // Generated by jextract
 
-package org.cryptomator.jfuse.win.amd64.extr;
+package org.cryptomator.jfuse.linux.amd64.extr;
 
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.VarHandle;
 import java.nio.ByteOrder;
 import java.lang.foreign.*;
 import static java.lang.foreign.ValueLayout.*;
-public class winfsp_fuse_h  {
+public class stdio_h  {
 
-    /* package-private */ winfsp_fuse_h() {}
+    /* package-private */ stdio_h() {}
     public static OfByte C_CHAR = Constants$root.C_CHAR$LAYOUT;
     public static OfShort C_SHORT = Constants$root.C_SHORT$LAYOUT;
-    public static OfInt C_INT = Constants$root.C_LONG$LAYOUT;
-    public static OfInt C_LONG = Constants$root.C_LONG$LAYOUT;
+    public static OfInt C_INT = Constants$root.C_INT$LAYOUT;
+    public static OfLong C_LONG = Constants$root.C_LONG_LONG$LAYOUT;
     public static OfLong C_LONG_LONG = Constants$root.C_LONG_LONG$LAYOUT;
     public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
     public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
     public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
+    public static int RENAME_NOREPLACE() {
+        return (int)1L;
+    }
+    public static int RENAME_EXCHANGE() {
+        return (int)2L;
+    }
+    public static int RENAME_WHITEOUT() {
+        return (int)4L;
+    }
 }
 
 
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImplTest.java
new file mode 100644
index 00000000..7ae3917c
--- /dev/null
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseConnInfoImplTest.java
@@ -0,0 +1,83 @@
+package org.cryptomator.jfuse.linux.amd64;
+
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_conn_info;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+public class FuseConnInfoImplTest {
+
+	@DisplayName("test getters")
+	@ParameterizedTest(name = "{1}")
+	@MethodSource
+	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(segment, 42);
+
+			Assertions.assertEquals(42, getter.apply(connInfo));
+		}
+	}
+
+	public static Stream<Arguments> testGetters() {
+		return Stream.of(
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_read$set, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::time_gran$set, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+		);
+	}
+
+	private interface SetInMemorySegment extends BiConsumer<MemorySegment, Integer> {}
+
+	private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
+
+	@DisplayName("test setters")
+	@ParameterizedTest(name = "{0}")
+	@MethodSource
+	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(connInfo, 42);
+
+			Assertions.assertEquals(42, getter.apply(segment));
+		}
+	}
+
+	public static Stream<Arguments> testSetters() {
+		return Stream.of(
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want$get),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write$get),
+				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse_conn_info::max_read$get),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead$get),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background$get),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold$get),
+				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse_conn_info::time_gran$get)
+		);
+	}
+
+	private interface SetInConnInfo extends BiConsumer<FuseConnInfo, Integer> {}
+
+	private interface GetInMemorySegment extends Function<MemorySegment, Integer> {}
+
+}
\ No newline at end of file
diff --git a/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseImplTest.java b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseImplTest.java
new file mode 100644
index 00000000..590a5155
--- /dev/null
+++ b/jfuse-linux-amd64/src/test/java/org/cryptomator/jfuse/linux/amd64/FuseImplTest.java
@@ -0,0 +1,189 @@
+package org.cryptomator.jfuse.linux.amd64;
+
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.api.TimeSpec;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_conn_info;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_file_info;
+import org.cryptomator.jfuse.linux.amd64.extr.fuse_h;
+import org.cryptomator.jfuse.linux.amd64.extr.ll.fuse_cmdline_opts;
+import org.cryptomator.jfuse.linux.amd64.extr.ll.fuse_lowlevel_h;
+import org.cryptomator.jfuse.linux.amd64.extr.timespec;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.Answers;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.time.Instant;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class FuseImplTest {
+
+	private FuseOperations fuseOps = Mockito.mock(FuseOperations.class);
+	private FuseImpl fuseImpl = new FuseImpl(fuseOps);
+
+	@Nested
+	@DisplayName("mount()")
+	public class Mount {
+
+		private List<String> args = List.of("foo", "bar");
+		private FuseImpl fuseImplSpy = Mockito.spy(fuseImpl);
+		private MockedStatic<fuse_h> fuseH;
+
+		@BeforeEach
+		public void setup() {
+			Mockito.doReturn(Mockito.mock(FuseArgs.class)).when(fuseImplSpy).parseArgs(args);
+			fuseH = Mockito.mockStatic(fuse_h.class);
+		}
+
+		@AfterEach
+		public void teardown() {
+			fuseH.close();
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_new fails")
+		public void testFuseNewFails() {
+			fuseH.when(() -> fuse_h.fuse_new(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any())).thenReturn(MemoryAddress.NULL);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			fuseH.verify(() -> fuse_h.fuse_mount(Mockito.any(), Mockito.any()), Mockito.never());
+			Assertions.assertEquals("fuse_new failed", thrown.getMessage());
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_mount fails")
+		public void testFuseMountFails() {
+			fuseH.when(() -> fuse_h.fuse_new(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any())).thenReturn(MemoryAddress.ofLong(42L));
+			fuseH.when(() -> fuse_h.fuse_mount(Mockito.any(), Mockito.any())).thenReturn(1);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			Assertions.assertEquals("fuse_mount failed", thrown.getMessage());
+		}
+
+	}
+
+	@ParameterizedTest(name = "fusefs {0}")
+	@DisplayName("parseArgs with -h/--help")
+	@ValueSource(strings = {"--help", "-h"})
+	public void testParseArgsHelp(String arg) {
+		var args = List.of("fusefs", arg);
+		try (var fuseLowlevelH = Mockito.mockStatic(fuse_lowlevel_h.class);
+			 var fuseH = Mockito.mockStatic(fuse_h.class)) {
+			fuseLowlevelH.when(() -> fuse_lowlevel_h.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
+				MemorySegment opts = invocation.getArgument(1);
+				fuse_cmdline_opts.show_help$set(opts, 1);
+				return 0;
+			});
+			fuseH.when(() -> fuse_h.fuse_lib_help(Mockito.any())).thenAnswer(Answers.RETURNS_DEFAULTS);
+
+			Assertions.assertThrows(IllegalArgumentException.class, () -> fuseImpl.parseArgs(args));
+			fuseH.verify(() -> fuse_h.fuse_lib_help(Mockito.any()));
+		}
+	}
+
+	@Test
+	@DisplayName("parseArgs")
+	public void testParseArgs() {
+		try (var fuseLowlevelH = Mockito.mockStatic(fuse_lowlevel_h.class);
+			 var scope = MemorySession.openConfined()) {
+			fuseLowlevelH.when(() -> fuse_lowlevel_h.fuse_parse_cmdline(Mockito.any(), Mockito.any())).then(invocation -> {
+				MemorySegment opts = invocation.getArgument(1);
+				fuse_cmdline_opts.singlethread$set(opts, 0);
+				fuse_cmdline_opts.debug$set(opts, 1);
+				fuse_cmdline_opts.mountpoint$set(opts, scope.allocateUtf8String("/mount/point").address());
+				return 0;
+			});
+
+			var fuseArgs = fuseImpl.parseArgs(List.of("fusefs", "-foo", "-bar", "/mount/point"));
+
+			Assertions.assertTrue(fuseArgs.multithreaded());
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[0] = fusefs"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[1] = -foo"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[2] = -bar"));
+			Assertions.assertTrue(fuseArgs.toString().contains("singlethreaded = false"));
+			Assertions.assertTrue(fuseArgs.toString().contains("debug = 1"));
+			Assertions.assertTrue(fuseArgs.toString().contains("mountPoint = /mount/point"));
+		}
+	}
+
+	@DisplayName("init() sets fuse_conn_info.wants |= FUSE_CAP_READDIRPLUS")
+	@Test
+	public void testInit() {
+		try (var scope = MemorySession.openConfined()) {
+			var result = new AtomicInteger();
+			Mockito.doAnswer(invocation -> {
+				FuseConnInfo connInfo = invocation.getArgument(0);
+				result.set(connInfo.want());
+				return null;
+			}).when(fuseOps).init(Mockito.any());
+			var connInfo = fuse_conn_info.allocate(scope);
+			var fuseConfig = MemoryAddress.NULL; // TODO jextract fuse_config
+
+			fuseImpl.init(connInfo.address(), fuseConfig.address());
+
+			Assertions.assertEquals(FuseConnInfo.FUSE_CAP_READDIRPLUS, result.get() & FuseConnInfo.FUSE_CAP_READDIRPLUS);
+		}
+	}
+
+	@Nested
+	@DisplayName("utimens")
+	public class Utimens {
+
+		@DisplayName("utimens(\"/foo\", UTIME_NOW, UTIME_NOW)")
+		@Test
+		public void testUtimensNow() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var fi = scope.allocate(fuse_file_info.$LAYOUT());
+				var times = MemoryAddress.NULL;
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.any());
+
+				var result = fuseImpl.utimens(path.address(), times, fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+		@DisplayName("utimens(\"/foo\", ...)")
+		@ParameterizedTest
+		@CsvSource(value = {
+				"123456,789, 456789,123",
+				"111222,333, 444555,666",
+		})
+		public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
+			Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
+			Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var fi = scope.allocate(fuse_file_info.$LAYOUT());
+				var times = timespec.allocateArray(2, scope);
+				timespec.tv_sec$set(times, 0, sec0);
+				timespec.tv_nsec$set(times, 0, nsec0);
+				timespec.tv_sec$set(times, 1, sec1);
+				timespec.tv_nsec$set(times, 1, nsec1);
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.any());
+
+				var result = fuseImpl.utimens(path.address(), times.address(), fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/jfuse-mac/pom.xml b/jfuse-mac/pom.xml
index 1e645769..0b24fae9 100644
--- a/jfuse-mac/pom.xml
+++ b/jfuse-mac/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>jfuse</artifactId>
-		<version>0.1.0</version>
+		<version>0.2.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jfuse-mac</artifactId>
@@ -87,16 +87,21 @@
 									<goal>sources</goal>
 								</goals>
 								<configuration>
-									<headerFile>${project.parent.basedir}/libfuse/include/fuse.h</headerFile>
+									<headerFile>${project.parent.basedir}/libfuse2/include/fuse.h</headerFile>
 									<headerClassName>fuse_h</headerClassName>
 									<cPreprocessorMacros>
 										<cPreprocessorMacro>_FILE_OFFSET_BITS=64</cPreprocessorMacro>
 										<cPreprocessorMacro>FUSE_USE_VERSION=29</cPreprocessorMacro>
 									</cPreprocessorMacros>
 									<includeFunctions>
-										<includeFunction>fuse_main_real</includeFunction>
-										<includeFunction>fuse_get_context</includeFunction>
+										<includeFunction>fuse_parse_cmdline</includeFunction>
+										<includeFunction>fuse_mount</includeFunction>
+										<includeFunction>fuse_new</includeFunction>
+										<includeFunction>fuse_loop</includeFunction>
+										<includeFunction>fuse_loop_mt</includeFunction>
 										<includeFunction>fuse_exit</includeFunction>
+										<includeFunction>fuse_unmount</includeFunction>
+										<includeFunction>fuse_destroy</includeFunction>
 									</includeFunctions>
 									<includeTypedefs>
 										<includeTypedef>fuse_fill_dir_t</includeTypedef>
@@ -104,11 +109,11 @@
 									<includeStructs>
 										<includeStruct>fuse_operations</includeStruct>
 										<includeStruct>fuse_file_info</includeStruct>
-										<includeStruct>fuse_context</includeStruct>
 										<includeStruct>stat</includeStruct>
 										<includeStruct>statvfs</includeStruct>
 										<includeStruct>timespec</includeStruct>
 										<includeStruct>fuse_conn_info</includeStruct>
+										<includeStruct>fuse_args</includeStruct>
 									</includeStructs>
 								</configuration>
 							</execution>
@@ -145,9 +150,6 @@
 									<headerFile>${mac.headerSearchPath}/sys/stat.h</headerFile>
 									<headerClassName>stat_h</headerClassName>
 									<includeMacros>
-										<includeMacro>S_IFREG</includeMacro>
-										<includeMacro>S_IFDIR</includeMacro>
-										<includeMacro>S_IFLNK</includeMacro>
 										<includeMacro>UTIME_NOW</includeMacro>
 										<includeMacro>UTIME_OMIT</includeMacro>
 									</includeMacros>
diff --git a/jfuse-mac/src/main/java/module-info.java b/jfuse-mac/src/main/java/module-info.java
index 459f103a..a3191a75 100644
--- a/jfuse-mac/src/main/java/module-info.java
+++ b/jfuse-mac/src/main/java/module-info.java
@@ -2,6 +2,8 @@
 import org.cryptomator.jfuse.mac.MacFuseBuilder;
 
 module org.cryptomator.jfuse.mac {
+	requires static org.jetbrains.annotations;
+
 	requires org.cryptomator.jfuse.api;
 
 	provides FuseBuilder with MacFuseBuilder;
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java
index 77cf64db..62e115d4 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/DirFillerImpl.java
@@ -3,9 +3,11 @@
 import org.cryptomator.jfuse.api.DirFiller;
 import org.cryptomator.jfuse.api.Stat;
 import org.cryptomator.jfuse.mac.extr.fuse_fill_dir_t;
+import org.cryptomator.jfuse.mac.extr.stat;
 
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemorySession;
+import java.util.function.Consumer;
 
 record DirFillerImpl(MemoryAddress buf, fuse_fill_dir_t callback, MemorySession scope) implements DirFiller {
 
@@ -14,9 +16,10 @@ record DirFillerImpl(MemoryAddress buf, fuse_fill_dir_t callback, MemorySession
 	}
 
 	@Override
-	public int fill(String name, Stat stat, long offset) {
-		var statAddr = stat instanceof StatImpl s ? s.segment().address() : MemoryAddress.NULL;
-		return callback.apply(buf, scope.allocateUtf8String(name).address(), statAddr, offset);
+	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
+		var statSegment = stat.allocate(scope);
+		statFiller.accept(new StatImpl(statSegment));
+		return callback.apply(buf, scope.allocateUtf8String(name).address(), statSegment.address(), offset);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseArgs.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseArgs.java
new file mode 100644
index 00000000..42c92539
--- /dev/null
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseArgs.java
@@ -0,0 +1,24 @@
+package org.cryptomator.jfuse.mac;
+
+import org.cryptomator.jfuse.mac.extr.fuse_args;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+record FuseArgs(MemorySegment args, MemoryAddress mountPoint, boolean multiThreaded) {
+
+	@Override
+	public String toString() {
+		var sb = new StringBuilder();
+		var argc = fuse_args.argc$get(args);
+		var argv = fuse_args.argv$get(args);
+		for (int i = 0; i < argc; i++) {
+			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i);
+			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+		}
+		sb.append("mountPoint = ").append(mountPoint.getUtf8String(0)).append(", ");
+		sb.append("multiThreaded = ").append(multiThreaded);
+		return sb.toString();
+	}
+}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java
index 71e3ac20..fc68702a 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseConnInfoImpl.java
@@ -22,4 +22,68 @@ public int protoMajor() {
 	public int protoMinor() {
 		return fuse_conn_info.proto_minor$get(segment);
 	}
+	@Override
+	public int capable() {
+		return fuse_conn_info.capable$get(segment);
+	}
+
+	@Override
+	public int want() {
+		return fuse_conn_info.want$get(segment);
+	}
+	@Override
+	public void setWant(int wanted) {
+		fuse_conn_info.want$set(segment, wanted);
+	}
+
+	@Override
+	public int maxWrite() {
+		return fuse_conn_info.max_write$get(segment);
+	}
+
+	@Override
+	public void setMaxWrite(int maxWrite) {
+		fuse_conn_info.max_write$set(segment, maxWrite);
+	}
+
+	@Override
+	public int maxReadahead() {
+		return fuse_conn_info.max_readahead$get(segment);
+	}
+
+	@Override
+	public void setMaxReadahead(int maxReadahead) {
+		fuse_conn_info.max_readahead$set(segment, maxReadahead);
+	}
+
+	@Override
+	public int maxBackground() {
+		return fuse_conn_info.max_background$get(segment);
+	}
+
+	@Override
+	public void setMaxBackground(int maxBackground) {
+		fuse_conn_info.max_background$set(segment, maxBackground);
+	}
+
+	@Override
+	public int congestionThreshold() {
+		return fuse_conn_info.congestion_threshold$get(segment);
+	}
+
+	@Override
+	public void setCongestionThreshold(int congestionThreshold) {
+		fuse_conn_info.congestion_threshold$set(segment, congestionThreshold);
+	}
+
+	@Override
+	public int asyncRead() {
+		return fuse_conn_info.async_read$get(segment);
+	}
+
+	@Override
+	public void setAsyncRead(int asyncRead) {
+		fuse_conn_info.async_read$set(segment, asyncRead);
+	}
+
 }
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java
index ca58fd30..f4655367 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseImpl.java
@@ -1,95 +1,124 @@
 package org.cryptomator.jfuse.mac;
 
 import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.FuseMount;
 import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.mac.extr.fuse_args;
 import org.cryptomator.jfuse.mac.extr.fuse_h;
 import org.cryptomator.jfuse.mac.extr.fuse_operations;
 import org.cryptomator.jfuse.mac.extr.stat_h;
 import org.cryptomator.jfuse.mac.extr.timespec;
+import org.jetbrains.annotations.VisibleForTesting;
 
+import java.lang.foreign.Addressable;
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.MemorySession;
-import java.nio.ByteBuffer;
-import java.util.concurrent.CompletableFuture;
+import java.lang.foreign.ValueLayout;
+import java.util.List;
+
+import static java.lang.foreign.ValueLayout.JAVA_INT;
 
 public final class FuseImpl extends Fuse {
 
-	private final CompletableFuture<Integer> initialized = new CompletableFuture<>();
 	private final FuseOperations delegate;
-	private final MemorySegment struct;
+	private final MemorySegment fuseOps;
 
 	public FuseImpl(FuseOperations fuseOperations) {
-		this.struct = fuse_operations.allocate(fuseScope);
+		this.fuseOps = fuse_operations.allocate(fuseScope);
 		this.delegate = fuseOperations;
-		fuse_operations.init$set(struct, fuse_operations.init.allocate(this::init, fuseScope).address());
 		fuseOperations.supportedOperations().forEach(this::bind);
 	}
 
-	private MemoryAddress init(MemoryAddress conn) {
-		try (var scope = MemorySession.openConfined()) {
-			if (delegate.supportedOperations().contains(FuseOperations.Operation.INIT)) {
-				delegate.init(new FuseConnInfoImpl(conn, scope));
-			}
-			initialized.complete(0);
-		} catch (Exception e) {
-			initialized.completeExceptionally(e);
-		}
-		return MemoryAddress.NULL;
-	}
-
 	@Override
-	protected CompletableFuture<Integer> initialized() {
-		return initialized;
+	protected FuseMount mount(List<String> args) throws MountFailedException {
+		var fuseArgs = parseArgs(args);
+		var ch  = fuse_h.fuse_mount(fuseArgs.mountPoint(), fuseArgs.args());
+		if (MemoryAddress.NULL.equals(ch)) {
+			throw new MountFailedException("fuse_mount failed");
+		}
+		var fuse = fuse_h.fuse_new(ch, fuseArgs.args(), fuseOps, fuseOps.byteSize(), MemoryAddress.NULL);
+		if (MemoryAddress.NULL.equals(fuse)) {
+			fuse_h.fuse_unmount(fuseArgs.mountPoint(), ch);
+			throw new MountFailedException("fuse_new failed");
+		}
+		return new FuseMountImpl(fuse, ch, fuseArgs);
 	}
 
-	@Override
-	protected int fuseMain(int argc, MemorySegment argv) {
-		return fuse_h.fuse_main_real(argc, argv, struct, struct.byteSize(), MemoryAddress.NULL);
+	@VisibleForTesting
+	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
+		var args = fuse_args.allocate(fuseScope);
+		var argc = cmdLineArgs.size();
+		var argv = fuseScope.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		for (int i = 0; i < argc; i++) {
+			var cString = fuseScope.allocateUtf8String(cmdLineArgs.get(i));
+			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
+		}
+		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemoryAddress.NULL);
+		fuse_args.argc$set(args, argc);
+		fuse_args.argv$set(args, argv.address());
+		fuse_args.allocated$set(args, 0);
+
+		var multithreaded = fuseScope.allocate(JAVA_INT, 1);
+		var foreground = fuseScope.allocate(JAVA_INT, 1);
+		var mountPointPtr = fuseScope.allocate(ValueLayout.ADDRESS);
+		int parseResult = fuse_h.fuse_parse_cmdline(args, mountPointPtr, multithreaded, foreground);
+		if (parseResult != 0) {
+			throw new IllegalArgumentException("fuse_parse_cmdline failed to parse " + String.join(" ", cmdLineArgs));
+		}
+		var isMultiThreaded = multithreaded.get(JAVA_INT, 0) == 1;
+		var mountPoint = mountPointPtr.get(ValueLayout.ADDRESS, 0);
+		return new FuseArgs(args, mountPoint, isMultiThreaded);
 	}
 
-//	private void exit() {
-//		try (var scope = ResourceScope.newConfinedScope()) {
-//			var ctx = fuse_context.ofAddress(fuse_h.fuse_get_context(), fuseScope);
-//			var fusePtr = fuse_context.fuse$get(ctx);
-//			fuse_h.fuse_exit(fusePtr);
-//		}
-//	}
-
 	private void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> { /* handled already */ }
-			case ACCESS -> fuse_operations.access$set(struct, fuse_operations.access.allocate(this::access, fuseScope).address());
-			case CHMOD -> fuse_operations.chmod$set(struct, fuse_operations.chmod.allocate(this::chmod, fuseScope).address());
-			case CREATE -> fuse_operations.create$set(struct, fuse_operations.create.allocate(this::create, fuseScope).address());
-			case DESTROY -> fuse_operations.destroy$set(struct, fuse_operations.destroy.allocate(this::destroy, fuseScope).address());
-			case GET_ATTR -> fuse_operations.getattr$set(struct, fuse_operations.getattr.allocate(this::getattr, fuseScope).address());
-			case MKDIR -> fuse_operations.mkdir$set(struct, fuse_operations.mkdir.allocate(this::mkdir, fuseScope).address());
-			case OPEN -> fuse_operations.open$set(struct, fuse_operations.open.allocate(this::open, fuseScope).address());
-			case OPEN_DIR -> fuse_operations.opendir$set(struct, fuse_operations.opendir.allocate(this::opendir, fuseScope).address());
-			case READ -> fuse_operations.read$set(struct, fuse_operations.read.allocate(this::read, fuseScope).address());
-			case READ_DIR -> fuse_operations.readdir$set(struct, fuse_operations.readdir.allocate(this::readdir, fuseScope).address());
-			case READLINK -> fuse_operations.readlink$set(struct, fuse_operations.readlink.allocate(this::readlink, fuseScope).address());
-			case RELEASE -> fuse_operations.release$set(struct, fuse_operations.release.allocate(this::release, fuseScope).address());
-			case RELEASE_DIR -> fuse_operations.releasedir$set(struct, fuse_operations.releasedir.allocate(this::releasedir, fuseScope).address());
-			case RENAME -> fuse_operations.rename$set(struct, fuse_operations.rename.allocate(this::rename, fuseScope).address());
-			case RMDIR -> fuse_operations.rmdir$set(struct, fuse_operations.rmdir.allocate(this::rmdir, fuseScope).address());
-			case STATFS -> fuse_operations.statfs$set(struct, fuse_operations.statfs.allocate(this::statfs, fuseScope).address());
-			case SYMLINK -> fuse_operations.symlink$set(struct, fuse_operations.symlink.allocate(this::symlink, fuseScope).address());
-			case TRUNCATE -> fuse_operations.truncate$set(struct, fuse_operations.truncate.allocate(this::truncate, fuseScope).address());
-			case UNLINK -> fuse_operations.unlink$set(struct, fuse_operations.unlink.allocate(this::unlink, fuseScope).address());
-			case UTIMENS -> fuse_operations.utimens$set(struct, fuse_operations.utimens.allocate(this::utimens, fuseScope).address());
-			case WRITE -> fuse_operations.write$set(struct, fuse_operations.write.allocate(this::write, fuseScope).address());
+			case INIT -> fuse_operations.init$set(fuseOps, fuse_operations.init.allocate(this::init, fuseScope).address());
+			case ACCESS -> fuse_operations.access$set(fuseOps, fuse_operations.access.allocate(this::access, fuseScope).address());
+			case CHMOD -> fuse_operations.chmod$set(fuseOps, fuse_operations.chmod.allocate(this::chmod, fuseScope).address());
+			case CREATE -> fuse_operations.create$set(fuseOps, fuse_operations.create.allocate(this::create, fuseScope).address());
+			case DESTROY -> fuse_operations.destroy$set(fuseOps, fuse_operations.destroy.allocate(this::destroy, fuseScope).address());
+			case GET_ATTR -> {
+				fuse_operations.getattr$set(fuseOps, fuse_operations.getattr.allocate(this::getattr, fuseScope).address());
+				fuse_operations.fgetattr$set(fuseOps, fuse_operations.fgetattr.allocate(this::fgetattr, fuseScope).address());
+			}
+			case MKDIR -> fuse_operations.mkdir$set(fuseOps, fuse_operations.mkdir.allocate(this::mkdir, fuseScope).address());
+			case OPEN -> fuse_operations.open$set(fuseOps, fuse_operations.open.allocate(this::open, fuseScope).address());
+			case OPEN_DIR -> fuse_operations.opendir$set(fuseOps, fuse_operations.opendir.allocate(this::opendir, fuseScope).address());
+			case READ -> fuse_operations.read$set(fuseOps, fuse_operations.read.allocate(this::read, fuseScope).address());
+			case READ_DIR -> fuse_operations.readdir$set(fuseOps, fuse_operations.readdir.allocate(this::readdir, fuseScope).address());
+			case READLINK -> fuse_operations.readlink$set(fuseOps, fuse_operations.readlink.allocate(this::readlink, fuseScope).address());
+			case RELEASE -> fuse_operations.release$set(fuseOps, fuse_operations.release.allocate(this::release, fuseScope).address());
+			case RELEASE_DIR -> fuse_operations.releasedir$set(fuseOps, fuse_operations.releasedir.allocate(this::releasedir, fuseScope).address());
+			case RENAME -> fuse_operations.rename$set(fuseOps, fuse_operations.rename.allocate(this::rename, fuseScope).address());
+			case RMDIR -> fuse_operations.rmdir$set(fuseOps, fuse_operations.rmdir.allocate(this::rmdir, fuseScope).address());
+			case STATFS -> fuse_operations.statfs$set(fuseOps, fuse_operations.statfs.allocate(this::statfs, fuseScope).address());
+			case SYMLINK -> fuse_operations.symlink$set(fuseOps, fuse_operations.symlink.allocate(this::symlink, fuseScope).address());
+			case TRUNCATE -> {
+				fuse_operations.truncate$set(fuseOps, fuse_operations.truncate.allocate(this::truncate, fuseScope).address());
+				fuse_operations.ftruncate$set(fuseOps, fuse_operations.ftruncate.allocate(this::ftruncate, fuseScope).address());
+			}
+			case UNLINK -> fuse_operations.unlink$set(fuseOps, fuse_operations.unlink.allocate(this::unlink, fuseScope).address());
+			case UTIMENS -> fuse_operations.utimens$set(fuseOps, fuse_operations.utimens.allocate(this::utimens, fuseScope).address());
+			case WRITE -> fuse_operations.write$set(fuseOps, fuse_operations.write.allocate(this::write, fuseScope).address());
 		}
 	}
 
+	private Addressable init(MemoryAddress conn) {
+		try (var scope = MemorySession.openConfined()) {
+			delegate.init(new FuseConnInfoImpl(conn, scope));
+		}
+		return MemoryAddress.NULL;
+	}
+
 	private int access(MemoryAddress path, int mask) {
 		return delegate.access(path.getUtf8String(0), mask);
 	}
 
 	private int chmod(MemoryAddress path, short mode) {
-		return delegate.chmod(path.getUtf8String(0), mode);
+		return delegate.chmod(path.getUtf8String(0), mode, null);
 	}
 
 	private int create(MemoryAddress path, short mode, MemoryAddress fi) {
@@ -102,9 +131,17 @@ private void destroy(MemoryAddress addr) {
 		delegate.destroy();
 	}
 
-	private int getattr(MemoryAddress path, MemoryAddress stat) {
+	@VisibleForTesting
+	int getattr(MemoryAddress path, MemoryAddress stat) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope), null);
+		}
+	}
+
+	@VisibleForTesting
+	int fgetattr(MemoryAddress path, MemoryAddress stat, MemoryAddress fi) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope));
+			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope), new FileInfoImpl(fi, scope));
 		}
 	}
 
@@ -133,7 +170,7 @@ private int read(MemoryAddress path, MemoryAddress buf, long size, long offset,
 
 	private int readdir(MemoryAddress path, MemoryAddress buf, MemoryAddress filler, long offset, MemoryAddress fi) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope));
+			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope), 0);
 		}
 	}
 
@@ -157,7 +194,7 @@ private int releasedir(MemoryAddress path, MemoryAddress fi) {
 	}
 
 	private int rename(MemoryAddress oldpath, MemoryAddress newpath) {
-		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0));
+		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), 0);
 	}
 
 	private int rmdir(MemoryAddress path) {
@@ -174,30 +211,38 @@ private int symlink(MemoryAddress linkname, MemoryAddress target) {
 		return delegate.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
 	}
 
-	private int truncate(MemoryAddress path, long size) {
-		return delegate.truncate(path.getUtf8String(0), size);
+	@VisibleForTesting
+	int truncate(MemoryAddress path, long size) {
+		return delegate.truncate(path.getUtf8String(0), size, null);
+	}
+
+	@VisibleForTesting
+	int ftruncate(MemoryAddress path, long size, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.truncate(path.getUtf8String(0), size, new FileInfoImpl(fi, scope));
+		}
 	}
 
 	private int unlink(MemoryAddress path) {
 		return delegate.unlink(path.getUtf8String(0));
 	}
 
-	private int utimens(MemoryAddress path, MemoryAddress times) {
-		if (MemoryAddress.NULL.equals(times)) {
-			// set both times to current time (using on-heap memory segments)
-			var segment = MemorySegment.ofBuffer(ByteBuffer.allocate((int) timespec.$LAYOUT().byteSize()));
-			timespec.tv_sec$set(segment, 0);
-			timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
-			var time = new TimeSpecImpl(segment);
-			return delegate.utimens(path.getUtf8String(0), time, time);
-		} else {
-			try (var scope = MemorySession.openConfined()) {
+	@VisibleForTesting
+	int utimens(MemoryAddress path, MemoryAddress times) {
+		try (var scope = MemorySession.openConfined()) {
+			if (MemoryAddress.NULL.equals(times)) {
+				// set both times to current time (using on-heap memory segments)
+				var segment = MemorySegment.allocateNative(timespec.$LAYOUT().byteSize(), scope);
+				timespec.tv_sec$set(segment, 0);
+				timespec.tv_nsec$set(segment, stat_h.UTIME_NOW());
+				var time = new TimeSpecImpl(segment);
+				return delegate.utimens(path.getUtf8String(0), time, time, null);
+			} else {
 				var seq = MemoryLayout.sequenceLayout(2, timespec.$LAYOUT());
 				var segment = MemorySegment.ofAddress(times, seq.byteSize(), scope);
 				var time0 = segment.asSlice(0, timespec.$LAYOUT().byteSize());
 				var time1 = segment.asSlice(timespec.$LAYOUT().byteSize(), timespec.$LAYOUT().byteSize());
-//				var timeSpecs = segment.elements(seq.elementLayout()).map(MacTimeSpec::new).toArray(MacTimeSpec[]::new);
-				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1));
+				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), null);
 			}
 		}
 	}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseMountImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseMountImpl.java
new file mode 100644
index 00000000..135dec06
--- /dev/null
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/FuseMountImpl.java
@@ -0,0 +1,30 @@
+package org.cryptomator.jfuse.mac;
+
+import org.cryptomator.jfuse.api.FuseMount;
+import org.cryptomator.jfuse.mac.extr.fuse_h;
+
+import java.lang.foreign.MemoryAddress;
+
+record FuseMountImpl(MemoryAddress fuse, MemoryAddress ch, FuseArgs args) implements FuseMount {
+
+	@Override
+	public int loop() {
+		if (args.multiThreaded()) {
+			return fuse_h.fuse_loop_mt(fuse);
+		} else {
+			return fuse_h.fuse_loop(fuse);
+		}
+	}
+
+	@Override
+	public void unmount() {
+		fuse_h.fuse_exit(fuse);
+		fuse_h.fuse_unmount(args.mountPoint(), ch);
+	}
+
+	@Override
+	public void destroy() {
+		fuse_h.fuse_destroy(fuse);
+	}
+
+}
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java
index 7b75ba33..e4e0af51 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/StatImpl.java
@@ -65,46 +65,4 @@ public long getSize() {
 		return stat.st_size$get(segment);
 	}
 
-	@Override
-	public boolean isDir() {
-		return (getMode() & stat_h.S_IFDIR()) == stat_h.S_IFDIR();
-	}
-
-	@Override
-	public void toggleDir(boolean isDir) {
-		if (isDir) {
-			setMode(getMode() | stat_h.S_IFDIR());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFDIR());
-		}
-	}
-
-	@Override
-	public boolean isReg() {
-		return (getMode() & stat_h.S_IFREG()) == stat_h.S_IFREG();
-	}
-
-	@Override
-	public void toggleReg(boolean isReg) {
-		if (isReg) {
-			setMode(getMode() | stat_h.S_IFREG());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFREG());
-		}
-	}
-
-	@Override
-	public boolean isLnk() {
-		return (getMode() & stat_h.S_IFLNK()) == stat_h.S_IFLNK();
-	}
-
-	@Override
-	public void toggleLnk(boolean isLnk) {
-		if (isLnk) {
-			setMode(getMode() | stat_h.S_IFLNK());
-		} else {
-			setMode(getMode() & ~stat_h.S_IFLNK());
-		}
-	}
-
 }
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/constants$0.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/constants$0.java
index eec6c864..2c5fa6eb 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/constants$0.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/constants$0.java
@@ -9,6 +9,32 @@
 import static java.lang.foreign.ValueLayout.*;
 class constants$0 {
 
+    static final FunctionDescriptor fuse_mount$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_mount$MH = RuntimeHelper.downcallHandle(
+        "fuse_mount",
+        constants$0.fuse_mount$FUNC
+    );
+    static final FunctionDescriptor fuse_unmount$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_unmount$MH = RuntimeHelper.downcallHandle(
+        "fuse_unmount",
+        constants$0.fuse_unmount$FUNC
+    );
+    static final FunctionDescriptor fuse_parse_cmdline$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_parse_cmdline$MH = RuntimeHelper.downcallHandle(
+        "fuse_parse_cmdline",
+        constants$0.fuse_parse_cmdline$FUNC
+    );
     static final FunctionDescriptor fuse_fill_dir_t$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
@@ -18,28 +44,16 @@ class constants$0 {
     static final MethodHandle fuse_fill_dir_t$MH = RuntimeHelper.downcallHandle(
         constants$0.fuse_fill_dir_t$FUNC
     );
-    static final FunctionDescriptor fuse_exit$FUNC = FunctionDescriptor.ofVoid(
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle fuse_exit$MH = RuntimeHelper.downcallHandle(
-        "fuse_exit",
-        constants$0.fuse_exit$FUNC
-    );
-    static final FunctionDescriptor fuse_get_context$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT);
-    static final MethodHandle fuse_get_context$MH = RuntimeHelper.downcallHandle(
-        "fuse_get_context",
-        constants$0.fuse_get_context$FUNC
-    );
-    static final FunctionDescriptor fuse_main_real$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
-        Constants$root.C_INT$LAYOUT,
+    static final FunctionDescriptor fuse_new$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_main_real$MH = RuntimeHelper.downcallHandle(
-        "fuse_main_real",
-        constants$0.fuse_main_real$FUNC
+    static final MethodHandle fuse_new$MH = RuntimeHelper.downcallHandle(
+        "fuse_new",
+        constants$0.fuse_new$FUNC
     );
 }
 
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/constants$1.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/constants$1.java
new file mode 100644
index 00000000..f1a3b6fe
--- /dev/null
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/constants$1.java
@@ -0,0 +1,42 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.mac.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+class constants$1 {
+
+    static final FunctionDescriptor fuse_destroy$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_destroy$MH = RuntimeHelper.downcallHandle(
+        "fuse_destroy",
+        constants$1.fuse_destroy$FUNC
+    );
+    static final FunctionDescriptor fuse_loop$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_loop$MH = RuntimeHelper.downcallHandle(
+        "fuse_loop",
+        constants$1.fuse_loop$FUNC
+    );
+    static final FunctionDescriptor fuse_exit$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_exit$MH = RuntimeHelper.downcallHandle(
+        "fuse_exit",
+        constants$1.fuse_exit$FUNC
+    );
+    static final FunctionDescriptor fuse_loop_mt$FUNC = FunctionDescriptor.of(Constants$root.C_INT$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_loop_mt$MH = RuntimeHelper.downcallHandle(
+        "fuse_loop_mt",
+        constants$1.fuse_loop_mt$FUNC
+    );
+}
+
+
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_args.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_args.java
new file mode 100644
index 00000000..54c885d3
--- /dev/null
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_args.java
@@ -0,0 +1,78 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.mac.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_args {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_INT$LAYOUT.withName("argc"),
+        MemoryLayout.paddingLayout(32),
+        Constants$root.C_POINTER$LAYOUT.withName("argv"),
+        Constants$root.C_INT$LAYOUT.withName("allocated"),
+        MemoryLayout.paddingLayout(32)
+    ).withName("fuse_args");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_args.$struct$LAYOUT;
+    }
+    static final VarHandle argc$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argc"));
+    public static VarHandle argc$VH() {
+        return fuse_args.argc$VH;
+    }
+    public static int argc$get(MemorySegment seg) {
+        return (int)fuse_args.argc$VH.get(seg);
+    }
+    public static void argc$set( MemorySegment seg, int x) {
+        fuse_args.argc$VH.set(seg, x);
+    }
+    public static int argc$get(MemorySegment seg, long index) {
+        return (int)fuse_args.argc$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argc$set(MemorySegment seg, long index, int x) {
+        fuse_args.argc$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle argv$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argv"));
+    public static VarHandle argv$VH() {
+        return fuse_args.argv$VH;
+    }
+    public static MemoryAddress argv$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg);
+    }
+    public static void argv$set( MemorySegment seg, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg, x);
+    }
+    public static MemoryAddress argv$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argv$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle allocated$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
+    public static VarHandle allocated$VH() {
+        return fuse_args.allocated$VH;
+    }
+    public static int allocated$get(MemorySegment seg) {
+        return (int)fuse_args.allocated$VH.get(seg);
+    }
+    public static void allocated$set( MemorySegment seg, int x) {
+        fuse_args.allocated$VH.set(seg, x);
+    }
+    public static int allocated$get(MemorySegment seg, long index) {
+        return (int)fuse_args.allocated$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void allocated$set(MemorySegment seg, long index, int x) {
+        fuse_args.allocated$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_context.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_context.java
deleted file mode 100644
index 334a3a77..00000000
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_context.java
+++ /dev/null
@@ -1,129 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.mac.extr;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-public class fuse_context {
-
-    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
-        Constants$root.C_POINTER$LAYOUT.withName("fuse"),
-        Constants$root.C_INT$LAYOUT.withName("uid"),
-        Constants$root.C_INT$LAYOUT.withName("gid"),
-        Constants$root.C_INT$LAYOUT.withName("pid"),
-        MemoryLayout.paddingLayout(32),
-        Constants$root.C_POINTER$LAYOUT.withName("private_data"),
-        Constants$root.C_SHORT$LAYOUT.withName("umask"),
-        MemoryLayout.paddingLayout(48)
-    ).withName("fuse_context");
-    public static MemoryLayout $LAYOUT() {
-        return fuse_context.$struct$LAYOUT;
-    }
-    static final VarHandle fuse$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fuse"));
-    public static VarHandle fuse$VH() {
-        return fuse_context.fuse$VH;
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg);
-    }
-    public static void fuse$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg, x);
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fuse$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle uid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("uid"));
-    public static VarHandle uid$VH() {
-        return fuse_context.uid$VH;
-    }
-    public static int uid$get(MemorySegment seg) {
-        return (int)fuse_context.uid$VH.get(seg);
-    }
-    public static void uid$set( MemorySegment seg, int x) {
-        fuse_context.uid$VH.set(seg, x);
-    }
-    public static int uid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.uid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void uid$set(MemorySegment seg, long index, int x) {
-        fuse_context.uid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle gid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("gid"));
-    public static VarHandle gid$VH() {
-        return fuse_context.gid$VH;
-    }
-    public static int gid$get(MemorySegment seg) {
-        return (int)fuse_context.gid$VH.get(seg);
-    }
-    public static void gid$set( MemorySegment seg, int x) {
-        fuse_context.gid$VH.set(seg, x);
-    }
-    public static int gid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.gid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void gid$set(MemorySegment seg, long index, int x) {
-        fuse_context.gid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle pid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("pid"));
-    public static VarHandle pid$VH() {
-        return fuse_context.pid$VH;
-    }
-    public static int pid$get(MemorySegment seg) {
-        return (int)fuse_context.pid$VH.get(seg);
-    }
-    public static void pid$set( MemorySegment seg, int x) {
-        fuse_context.pid$VH.set(seg, x);
-    }
-    public static int pid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.pid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void pid$set(MemorySegment seg, long index, int x) {
-        fuse_context.pid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle private_data$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("private_data"));
-    public static VarHandle private_data$VH() {
-        return fuse_context.private_data$VH;
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg);
-    }
-    public static void private_data$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg, x);
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void private_data$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle umask$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("umask"));
-    public static VarHandle umask$VH() {
-        return fuse_context.umask$VH;
-    }
-    public static short umask$get(MemorySegment seg) {
-        return (short)fuse_context.umask$VH.get(seg);
-    }
-    public static void umask$set( MemorySegment seg, short x) {
-        fuse_context.umask$VH.set(seg, x);
-    }
-    public static short umask$get(MemorySegment seg, long index) {
-        return (short)fuse_context.umask$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void umask$set(MemorySegment seg, long index, short x) {
-        fuse_context.umask$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
-    }
-    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
-}
-
-
diff --git a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_h.java b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_h.java
index bc74701a..22cce062 100644
--- a/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_h.java
+++ b/jfuse-mac/src/main/java/org/cryptomator/jfuse/mac/extr/fuse_h.java
@@ -18,35 +18,90 @@ public class fuse_h  {
     public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
     public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
     public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
-    public static MethodHandle fuse_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_exit$MH,"fuse_exit");
+    public static MethodHandle fuse_mount$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_mount$MH,"fuse_mount");
     }
-    public static void fuse_exit ( Addressable f) {
-        var mh$ = fuse_exit$MH();
+    public static MemoryAddress fuse_mount ( Addressable mountpoint,  Addressable args) {
+        var mh$ = fuse_mount$MH();
+        try {
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(mountpoint, args);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_unmount$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_unmount$MH,"fuse_unmount");
+    }
+    public static void fuse_unmount ( Addressable mountpoint,  Addressable ch) {
+        var mh$ = fuse_unmount$MH();
+        try {
+            mh$.invokeExact(mountpoint, ch);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_parse_cmdline$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_parse_cmdline$MH,"fuse_parse_cmdline");
+    }
+    public static int fuse_parse_cmdline ( Addressable args,  Addressable mountpoint,  Addressable multithreaded,  Addressable foreground) {
+        var mh$ = fuse_parse_cmdline$MH();
+        try {
+            return (int)mh$.invokeExact(args, mountpoint, multithreaded, foreground);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_new$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_new$MH,"fuse_new");
+    }
+    public static MemoryAddress fuse_new ( Addressable ch,  Addressable args,  Addressable op,  long op_size,  Addressable user_data) {
+        var mh$ = fuse_new$MH();
+        try {
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(ch, args, op, op_size, user_data);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_destroy$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_destroy$MH,"fuse_destroy");
+    }
+    public static void fuse_destroy ( Addressable f) {
+        var mh$ = fuse_destroy$MH();
         try {
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_get_context$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_get_context$MH,"fuse_get_context");
+    public static MethodHandle fuse_loop$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_loop$MH,"fuse_loop");
+    }
+    public static int fuse_loop ( Addressable f) {
+        var mh$ = fuse_loop$MH();
+        try {
+            return (int)mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse_exit$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_exit$MH,"fuse_exit");
     }
-    public static MemoryAddress fuse_get_context () {
-        var mh$ = fuse_get_context$MH();
+    public static void fuse_exit ( Addressable f) {
+        var mh$ = fuse_exit$MH();
         try {
-            return (java.lang.foreign.MemoryAddress)mh$.invokeExact();
+            mh$.invokeExact(f);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_main_real$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_main_real$MH,"fuse_main_real");
+    public static MethodHandle fuse_loop_mt$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse_loop_mt$MH,"fuse_loop_mt");
     }
-    public static int fuse_main_real ( int argc,  Addressable argv,  Addressable op,  long op_size,  Addressable user_data) {
-        var mh$ = fuse_main_real$MH();
+    public static int fuse_loop_mt ( Addressable f) {
+        var mh$ = fuse_loop_mt$MH();
         try {
-            return (int)mh$.invokeExact(argc, argv, op, op_size, user_data);
+            return (int)mh$.invokeExact(f);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseConnInfoImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseConnInfoImplTest.java
new file mode 100644
index 00000000..82defd21
--- /dev/null
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseConnInfoImplTest.java
@@ -0,0 +1,81 @@
+package org.cryptomator.jfuse.mac;
+
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.mac.extr.fuse_conn_info;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+public class FuseConnInfoImplTest {
+
+	@DisplayName("test getters")
+	@ParameterizedTest(name = "{1}")
+	@MethodSource
+	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(segment, 42);
+
+			Assertions.assertEquals(42, getter.apply(connInfo));
+		}
+	}
+
+	public static Stream<Arguments> testGetters() {
+		return Stream.of(
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::async_read$set, Named.of("asyncRead()", (GetInConnInfo) FuseConnInfo::asyncRead)),
+				Arguments.arguments((SetInMemorySegment) fuse_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+		);
+	}
+
+	private interface SetInMemorySegment extends BiConsumer<MemorySegment, Integer> {}
+
+	private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
+
+	@DisplayName("test setters")
+	@ParameterizedTest(name = "{0}")
+	@MethodSource
+	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(connInfo, 42);
+
+			Assertions.assertEquals(42, getter.apply(segment));
+		}
+	}
+
+	public static Stream<Arguments> testSetters() {
+		return Stream.of(
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse_conn_info::want$get),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse_conn_info::max_write$get),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse_conn_info::max_readahead$get),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse_conn_info::max_background$get),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse_conn_info::congestion_threshold$get),
+				Arguments.arguments(Named.of("setAsyncRead()", (SetInConnInfo) FuseConnInfo::setAsyncRead), (GetInMemorySegment) fuse_conn_info::async_read$get)
+		);
+	}
+
+	private interface SetInConnInfo extends BiConsumer<FuseConnInfo, Integer> {}
+
+	private interface GetInMemorySegment extends Function<MemorySegment, Integer> {}
+
+}
\ No newline at end of file
diff --git a/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseImplTest.java b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseImplTest.java
new file mode 100644
index 00000000..9e4140d4
--- /dev/null
+++ b/jfuse-mac/src/test/java/org/cryptomator/jfuse/mac/FuseImplTest.java
@@ -0,0 +1,215 @@
+package org.cryptomator.jfuse.mac;
+
+import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.api.TimeSpec;
+import org.cryptomator.jfuse.mac.extr.fuse_file_info;
+import org.cryptomator.jfuse.mac.extr.fuse_h;
+import org.cryptomator.jfuse.mac.extr.stat;
+import org.cryptomator.jfuse.mac.extr.timespec;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.lang.foreign.ValueLayout;
+import java.time.Instant;
+import java.util.List;
+
+import static java.lang.foreign.ValueLayout.JAVA_INT;
+
+public class FuseImplTest {
+
+	private FuseOperations fuseOps = Mockito.mock(FuseOperations.class);
+	private FuseImpl fuseImpl = new FuseImpl(fuseOps);
+
+	@Nested
+	@DisplayName("mount()")
+	public class Mount {
+
+		private List<String> args = List.of("foo", "bar");
+		private FuseImpl fuseImplSpy = Mockito.spy(fuseImpl);
+		private MockedStatic<fuse_h> fuseH;
+
+		@BeforeEach
+		public void setup() {
+			Mockito.doReturn(Mockito.mock(FuseArgs.class)).when(fuseImplSpy).parseArgs(args);
+			fuseH = Mockito.mockStatic(fuse_h.class);
+		}
+
+		@AfterEach
+		public void teardown() {
+			fuseH.close();
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_new fails")
+		public void testFuseNewFails() {
+			fuseH.when(() -> fuse_h.fuse_mount(Mockito.any(), Mockito.any())).thenReturn(MemoryAddress.ofLong(42L));
+			fuseH.when(() -> fuse_h.fuse_new(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any())).thenReturn(MemoryAddress.NULL);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			fuseH.verify(() -> fuse_h.fuse_unmount(Mockito.any(), Mockito.any()));
+			Assertions.assertEquals("fuse_new failed", thrown.getMessage());
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_mount fails")
+		public void testFuseMountFails() {
+			fuseH.when(() -> fuse_h.fuse_mount(Mockito.any(), Mockito.any())).thenReturn(MemoryAddress.NULL);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			fuseH.verify(() -> fuse_h.fuse_new(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any()), Mockito.never());
+			Assertions.assertEquals("fuse_mount failed", thrown.getMessage());
+		}
+
+	}
+
+	@Test
+	@DisplayName("parseArgs")
+	public void testParseArgs() {
+		try (var fuseH = Mockito.mockStatic(fuse_h.class);
+			var scope = MemorySession.openConfined()) {
+			fuseH.when(() -> fuse_h.fuse_parse_cmdline(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).then(invocation -> {
+				MemorySegment mp = invocation.getArgument(1);
+				MemorySegment mt = invocation.getArgument(2);
+				MemorySegment fg = invocation.getArgument(3);
+				mp.set(ValueLayout.ADDRESS, 0L, scope.allocateUtf8String("/mount/point"));
+				mt.set(JAVA_INT, 0L, 1);
+				fg.set(JAVA_INT, 0L, 1);
+				return 0;
+			});
+
+			var fuseArgs = fuseImpl.parseArgs(List.of("fusefs", "-foo", "-bar", "/mount/point"));
+
+			Assertions.assertTrue(fuseArgs.multiThreaded());
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[0] = fusefs"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[1] = -foo"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[2] = -bar"));
+			Assertions.assertTrue(fuseArgs.toString().contains("mountPoint = /mount/point"));
+		}
+	}
+
+	@Nested
+	@DisplayName("utimens")
+	public class Utimens {
+
+		@DisplayName("utimens(\"/foo\", UTIME_NOW, UTIME_NOW)")
+		@Test
+		public void testUtimensNow() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var times = MemoryAddress.NULL;
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.argThat(TimeSpec::isUtimeNow), Mockito.isNull());
+
+				var result = fuseImpl.utimens(path.address(), times);
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+		@DisplayName("utimens(\"/foo\", ...)")
+		@ParameterizedTest
+		@CsvSource(value = {
+				"123456,789, 456789,123",
+				"111222,333, 444555,666",
+		})
+		public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
+			Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
+			Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var times = timespec.allocateArray(2, scope);
+				timespec.tv_sec$set(times, 0, sec0);
+				timespec.tv_nsec$set(times, 0, nsec0);
+				timespec.tv_sec$set(times, 1, sec1);
+				timespec.tv_nsec$set(times, 1, nsec1);
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.isNull());
+
+				var result = fuseImpl.utimens(path.address(), times.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+	}
+
+	@Nested
+	@DisplayName("getattr")
+	public class GetAttr {
+
+		@Test
+		@DisplayName("getattr")
+		public void testGetattr() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var attr = stat.allocate(scope);
+				Mockito.doReturn(42).when(fuseOps).getattr(Mockito.eq("/foo"), Mockito.any(), Mockito.isNull());
+
+				var result = fuseImpl.getattr(path.address(), attr.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+		@Test
+		@DisplayName("fgetattr")
+		public void testFgetattr() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var attr = stat.allocate(scope);
+				var fi = fuse_file_info.allocate(scope);
+				Mockito.doReturn(42).when(fuseOps).getattr(Mockito.eq("/foo"), Mockito.any(), Mockito.notNull());
+
+				var result = fuseImpl.fgetattr(path.address(), attr.address(), fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+	}
+
+	@Nested
+	@DisplayName("truncate")
+	public class Truncate {
+
+		@Test
+		@DisplayName("truncate")
+		public void testTruncate() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				Mockito.doReturn(42).when(fuseOps).truncate(Mockito.eq("/foo"), Mockito.eq(1337L), Mockito.isNull());
+
+				var result = fuseImpl.truncate(path.address(), 1337L);
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+		@Test
+		@DisplayName("ftruncate")
+		public void testFtruncate() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var fi = fuse_file_info.allocate(scope);
+				Mockito.doReturn(42).when(fuseOps).truncate(Mockito.eq("/foo"), Mockito.eq(1337L), Mockito.notNull());
+
+				var result = fuseImpl.ftruncate(path.address(), 1337L, fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+	}
+
+}
\ No newline at end of file
diff --git a/jfuse-tests/pom.xml b/jfuse-tests/pom.xml
index dbbacd37..f995dbad 100644
--- a/jfuse-tests/pom.xml
+++ b/jfuse-tests/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>jfuse</artifactId>
-		<version>0.1.0</version>
+		<version>0.2.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jfuse-tests</artifactId>
diff --git a/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/BenchmarkTest.java b/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/BenchmarkTest.java
index 0c71779c..2d365152 100644
--- a/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/BenchmarkTest.java
+++ b/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/BenchmarkTest.java
@@ -8,10 +8,7 @@
 import org.openjdk.jmh.annotations.Mode;
 import org.openjdk.jmh.annotations.OutputTimeUnit;
 import org.openjdk.jmh.annotations.Warmup;
-import org.openjdk.jmh.runner.Runner;
-import org.openjdk.jmh.runner.RunnerException;
-import org.openjdk.jmh.runner.options.Options;
-import org.openjdk.jmh.runner.options.OptionsBuilder;
+import org.openjdk.jmh.infra.Blackhole;
 
 import java.io.IOException;
 import java.nio.file.Files;
@@ -30,19 +27,23 @@ public void runBenchmarks() throws IOException {
 	@Benchmark
 	@Warmup(iterations = 2)
 	@Fork(value = 1)
-	@OutputTimeUnit(TimeUnit.MICROSECONDS)
+	@OutputTimeUnit(TimeUnit.MILLISECONDS)
 	@BenchmarkMode(Mode.AverageTime)
-	public void testListDirJnrMulti() throws IOException {
-		Files.list(Path.of("/Volumes/bar")).close();
+	public void testListDirJnrMulti(Blackhole blackhole) throws IOException {
+		try (var ds = Files.walk(Path.of("/Volumes/bar"), 5)) {
+			ds.forEach(blackhole::consume);
+		}
 	}
 
 	@Benchmark
 	@Warmup(iterations = 2)
 	@Fork(value = 1)
-	@OutputTimeUnit(TimeUnit.MICROSECONDS)
+	@OutputTimeUnit(TimeUnit.MILLISECONDS)
 	@BenchmarkMode(Mode.AverageTime)
-	public void testListDirPanamaMulti() throws IOException {
-		Files.list(Path.of("/Volumes/foo")).close();
+	public void testListDirPanamaMulti(Blackhole blackhole) throws IOException {
+		try (var ds = Files.walk(Path.of("/Volumes/foo"), 5)) {
+			ds.forEach(blackhole::consume);
+		}
 	}
 
 //	@Benchmark
diff --git a/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/HelloJnrFileSystem.java b/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/HelloJnrFileSystem.java
deleted file mode 100644
index 3cc580fd..00000000
--- a/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/HelloJnrFileSystem.java
+++ /dev/null
@@ -1,96 +0,0 @@
-package org.cryptomator.jfuse.tests;
-
-import jnr.constants.platform.Errno;
-import jnr.ffi.Pointer;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-import ru.serce.jnrfuse.FuseFillDir;
-import ru.serce.jnrfuse.FuseStubFS;
-import ru.serce.jnrfuse.struct.FileStat;
-import ru.serce.jnrfuse.struct.FuseFileInfo;
-
-import java.nio.ByteBuffer;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Path;
-
-public class HelloJnrFileSystem extends FuseStubFS {
-
-	private static final int S_IFDIR = 0040000;
-	private static final int S_IFREG = 0100000;
-
-	private static final Logger LOG = LoggerFactory.getLogger(HelloJnrFileSystem.class);
-
-	public static final String HELLO_PATH = "/hello.txt";
-	public static final String HELLO_STR = "Hello JNR!";
-
-	public static void main(String[] args) {
-		Path mountPoint = Path.of("/Volumes/bar");
-		LOG.info("mounting at {}. Unmount to terminate this process.", mountPoint);
-		new HelloJnrFileSystem().mount(mountPoint, true, false, new String[]{"-s"});
-	}
-
-	@Override
-	public int getattr(String path, FileStat stat) {
-		LOG.debug("getattr() {}", path);
-		if ("/".equals(path)) {
-			stat.st_mode.set(S_IFDIR | 0755);
-			stat.st_nlink.set(2);
-			return 0;
-		} else if (HELLO_PATH.equals(path)) {
-			stat.st_mode.set(S_IFREG | 0444);
-			stat.st_nlink.set(1);
-			stat.st_size.set(HELLO_STR.getBytes().length);
-			return 0;
-		} else if (path.length() == 4) {
-			stat.st_mode.set(S_IFREG | 0444);
-			stat.st_nlink.set(1);
-			stat.st_size.set(0);
-			return 0;
-		} else {
-			return -Errno.ENOENT.value();
-		}
-	}
-
-	@Override
-	public int open(String path, FuseFileInfo fi) {
-		LOG.debug("open() {}", path);
-		if (!HELLO_PATH.equals(path)) {
-			return -Errno.ENOENT.value();
-		}
-		return 0;
-	}
-
-	@Override
-	public int read(String path, Pointer buf, long size, long offset, FuseFileInfo fi) {
-		LOG.debug("read() {}", path);
-		if (!HELLO_PATH.equals(path)) {
-			return -Errno.ENOENT.value();
-		}
-
-		ByteBuffer content = StandardCharsets.UTF_8.encode(HELLO_STR);
-		int pos = (int) Math.min(content.capacity(), offset);
-		int len = (int) Math.min(size, content.remaining());
-		buf.put(0, content.array(), pos, len);
-
-		return len;
-	}
-
-	@Override
-	public int readdir(String path, Pointer buf, FuseFillDir filler, long offset, FuseFileInfo fi) {
-		LOG.debug("readdir() {}", path);
-		if (offset == 0) {
-			filler.apply(buf, ".", null, 0);
-			filler.apply(buf, "..", null, 0);
-			filler.apply(buf, HELLO_PATH.substring(1), null, 0);
-			filler.apply(buf, "aaa", null, 0);
-			filler.apply(buf, "bbb", null, 0);
-			filler.apply(buf, "ccc", null, 0);
-			filler.apply(buf, "ddd", null, 0);
-			filler.apply(buf, "xxx", null, 0);
-			filler.apply(buf, "yyy", null, 0);
-			filler.apply(buf, "zzz", null, 0);
-		}
-		return 0;
-	}
-
-}
diff --git a/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/MirrorIT.java b/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/MirrorIT.java
index da81144b..2484dda6 100644
--- a/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/MirrorIT.java
+++ b/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/MirrorIT.java
@@ -1,6 +1,7 @@
 package org.cryptomator.jfuse.tests;
 
 import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.MountFailedException;
 import org.cryptomator.jfuse.examples.AbstractMirrorFileSystem;
 import org.cryptomator.jfuse.examples.PosixMirrorFileSystem;
 import org.cryptomator.jfuse.examples.WindowsMirrorFileSystem;
@@ -30,17 +31,20 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
 
 @TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public class MirrorIT {
 
+	static {
+		System.setProperty("org.slf4j.simpleLogger.defaultLogLevel", "TRACE");
+	}
+
 	private Path orig;
 	private Path mirror;
 	private Fuse fuse;
 
 	@BeforeAll
-	public void setup(@TempDir Path tmpDir) throws IOException, TimeoutException {
+	public void setup(@TempDir Path tmpDir) throws IOException, InterruptedException, MountFailedException {
 		var builder = Fuse.builder();
 		orig = tmpDir.resolve("orig");
 		Files.createDirectories(orig);
@@ -57,14 +61,14 @@ public void setup(@TempDir Path tmpDir) throws IOException, TimeoutException {
 			fs = new PosixMirrorFileSystem(orig, builder.errno());
 		}
 		fuse = builder.build(fs);
-		int result = fuse.mount("mirror-it", mirror, flags.toArray(String[]::new));
-		Assertions.assertEquals(0, result, "mount failed");
+		fuse.mount("mirror-it", mirror, flags.toArray(String[]::new));
 	}
 
 	@AfterAll
 	public void teardown() throws IOException, InterruptedException {
+		// attempt graceful unmount before closing
 		if (OS.MAC.isCurrentOs()) {
-			ProcessBuilder command = new ProcessBuilder("umount", "-f", "--", mirror.getFileName().toString());
+			ProcessBuilder command = new ProcessBuilder("umount", "--", mirror.getFileName().toString());
 			command.directory(mirror.getParent().toFile());
 			Process p = command.start();
 			p.waitFor(10, TimeUnit.SECONDS);
@@ -73,11 +77,13 @@ public void teardown() throws IOException, InterruptedException {
 			command.directory(mirror.getParent().toFile());
 			Process p = command.start();
 			p.waitFor(10, TimeUnit.SECONDS);
+		} else if (OS.WINDOWS.isCurrentOs()) {
+			// there is no graceful unmount, see https://github.com/winfsp/winfsp/issues/121
 		}
-		// for Windows we call internally fuse_exit
 		if (fuse != null) {
 			Assertions.assertTimeoutPreemptively(Duration.ofSeconds(10), fuse::close, "file system still active");
 		}
+		Thread.sleep(100); // give the file system some time before cleaning up the @TempDir
 	}
 
 	@Nested
diff --git a/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/RandomJnrFileSystem.java b/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/RandomJnrFileSystem.java
new file mode 100644
index 00000000..2ceba170
--- /dev/null
+++ b/jfuse-tests/src/test/java/org/cryptomator/jfuse/tests/RandomJnrFileSystem.java
@@ -0,0 +1,104 @@
+package org.cryptomator.jfuse.tests;
+
+import jnr.constants.platform.Errno;
+import jnr.ffi.Pointer;
+import org.cryptomator.jfuse.api.DirFiller;
+import org.cryptomator.jfuse.api.Stat;
+import org.cryptomator.jfuse.examples.RandomFileStructure;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import ru.serce.jnrfuse.FuseFillDir;
+import ru.serce.jnrfuse.FuseStubFS;
+import ru.serce.jnrfuse.struct.FileStat;
+import ru.serce.jnrfuse.struct.FuseFileInfo;
+
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+
+@SuppressWarnings("OctalInteger")
+public class RandomJnrFileSystem extends FuseStubFS {
+
+	private static final int S_IFDIR = 0040000;
+	private static final int S_IFREG = 0100000;
+
+	private static final Logger LOG = LoggerFactory.getLogger(RandomJnrFileSystem.class);
+
+	private final RandomFileStructure rfs = RandomFileStructure.init(42L, 100);
+
+	public static void main(String[] args) {
+		Path mountPoint = Path.of("/Volumes/bar");
+		LOG.info("mounting at {}. Unmount to terminate this process.", mountPoint);
+		new RandomJnrFileSystem().mount(mountPoint, true, false, new String[]{"-s"});
+	}
+
+	@Override
+	public int getattr(String path, FileStat stat) {
+		LOG.debug("getattr() {}", path);
+		var node = rfs.getNode(path);
+		if (node == null) {
+			return -Errno.ENOENT.value();
+		} else {
+			fillStats(node, stat);
+			return 0;
+		}
+	}
+
+	private void fillStats(RandomFileStructure.Node node, FileStat stat){
+		if (node.isDir()) {
+			stat.st_mode.set(S_IFDIR | 0755);
+			stat.st_nlink.set((short) (2 + node.children().size()));
+			stat.st_mtim.tv_sec.set(node.lastModified().getEpochSecond());
+			stat.st_mtim.tv_nsec.set(node.lastModified().getNano());
+		} else {
+			stat.st_mode.set(S_IFREG | 0444);
+			stat.st_nlink.set((short) 1);
+			stat.st_size.set(0);
+			stat.st_mtim.tv_sec.set(node.lastModified().getEpochSecond());
+			stat.st_mtim.tv_nsec.set(node.lastModified().getNano());
+		}
+	}
+
+	@Override
+	public int readdir(String path, Pointer buf, FuseFillDir filler, long offset, FuseFileInfo fi) {
+		LOG.debug("readdir() {}", path);
+		var node = rfs.getNode(path);
+		if (node == null) {
+			return -Errno.ENOENT.value();
+		} else if (!node.isDir()) {
+			return -Errno.ENOTDIR.value();
+		} else {
+			var runtime = jnr.ffi.Runtime.getSystemRuntime();
+			if (offset == 0 && filler.apply(buf, ".", null, ++offset) != 0)
+				return 0;
+			if (offset == 1 && filler.apply(buf, "..", null, ++offset) != 0)
+				return 0;
+			assert offset > 1;
+			var childIter = node.children().values().stream().skip(offset - 2).iterator();
+			while (childIter.hasNext()) {
+				var child = childIter.next();
+				var stat = new FileStat(runtime);
+				fillStats(node, stat);
+				if (filler.apply(buf, child.name(), stat, ++offset) != 0) {
+					return 0;
+				}
+			}
+			return 0;
+		}
+	}
+
+	@Override
+	public int open(String path, FuseFileInfo fi) {
+		return 0;
+	}
+
+	@Override
+	public int read(String path, Pointer buf, long size, long offset, FuseFileInfo fi) {
+		return 0;
+	}
+
+	@Override
+	public int release(String path, FuseFileInfo fi) {
+		return 0;
+	}
+}
diff --git a/jfuse-win-amd64/pom.xml b/jfuse-win-amd64/pom.xml
index c4972b77..f5dd7a61 100644
--- a/jfuse-win-amd64/pom.xml
+++ b/jfuse-win-amd64/pom.xml
@@ -5,7 +5,7 @@
 	<parent>
 		<groupId>org.cryptomator</groupId>
 		<artifactId>jfuse</artifactId>
-		<version>0.1.0</version>
+		<version>0.2.0</version>
 	</parent>
 	<modelVersion>4.0.0</modelVersion>
 	<artifactId>jfuse-win-amd64</artifactId>
@@ -76,7 +76,7 @@
 						<artifactId>jextract-maven-plugin</artifactId>
 						<version>0.2.0</version>
 						<configuration>
-							<executable>C:\Program Files\JDK\jextract-19\bin\jextract.bat</executable>
+							<executable>C:\Users\Arbeit\Programs\jextract-19\bin\jextract.bat</executable>
 							<headerSearchPaths>${win.ucrtHeaderPath}</headerSearchPaths>
 							<outputDirectory>${project.build.sourceDirectory}</outputDirectory>
 							<targetPackage>org.cryptomator.jfuse.win.amd64.extr</targetPackage>
@@ -88,36 +88,51 @@
 									<goal>sources</goal>
 								</goals>
 								<configuration>
-									<headerFile>${project.parent.basedir}/winfsp/inc/fuse/fuse.h</headerFile>
+									<headerFile>${project.parent.basedir}/winfsp/inc/fuse3/fuse.h</headerFile>
 									<headerClassName>fuse_h</headerClassName>
+									<cPreprocessorMacros>
+										<cPreprocessorMacro>WINFSP_DLL_INTERNAL</cPreprocessorMacro>
+										<cPreprocessorMacro>FUSE_USE_VERSION=32</cPreprocessorMacro>
+									</cPreprocessorMacros>
 									<includeFunctions>
-										<includeFunction>fuse_main_real</includeFunction>
-										<includeFunction>fuse_get_context</includeFunction>
-										<includeFunction>fuse_exit</includeFunction>
+										<includeFunction>fuse3_lib_help</includeFunction>
+										<includeFunction>fuse3_new</includeFunction>
+										<includeFunction>fuse3_mount</includeFunction>
+										<includeFunction>fuse3_get_session</includeFunction>
+										<includeFunction>fuse3_loop</includeFunction>
+										<includeFunction>fuse3_loop_mt_31</includeFunction>
+										<includeFunction>fuse3_exit</includeFunction>
+										<includeFunction>fuse3_unmount</includeFunction>
+										<includeFunction>fuse3_destroy</includeFunction>
 									</includeFunctions>
 									<includeTypedefs>
-										<includeTypedef>fuse_fill_dir_t</includeTypedef>
+										<includeTypedef>fuse3_fill_dir_t</includeTypedef>
 									</includeTypedefs>
 									<includeStructs>
-										<includeStruct>fuse_operations</includeStruct>
-										<includeStruct>fuse_file_info</includeStruct>
-										<includeStruct>fuse_context</includeStruct>
-										<includeStruct>fuse_conn_info</includeStruct>
+										<includeStruct>fuse3_operations</includeStruct>
+										<includeStruct>fuse3_file_info</includeStruct>
+										<includeStruct>fuse_stat</includeStruct>
+										<includeStruct>fuse_statvfs</includeStruct>
+										<includeStruct>fuse_timespec</includeStruct>
+										<includeStruct>fuse3_conn_info</includeStruct>
 									</includeStructs>
 								</configuration>
 							</execution>
+							<!-- winfsp does not support fuse_lowlevel.h. fuse_parse_cmdline is taken from fuse2.h -->
 							<execution>
-								<id>jextract-winfsp-fuse</id>
+								<id>jextract-fuse-parse-cmdline</id>
 								<goals>
 									<goal>sources</goal>
 								</goals>
 								<configuration>
-									<headerFile>${project.parent.basedir}/winfsp/inc/fuse/winfsp_fuse.h</headerFile>
-									<headerClassName>winfsp_fuse_h</headerClassName>
+									<targetPackage>org.cryptomator.jfuse.win.amd64.extr.fuse2</targetPackage>
+									<headerFile>${project.parent.basedir}/winfsp/inc/fuse/fuse_common.h</headerFile>
+									<headerClassName>fuse2_h</headerClassName>
+									<includeFunctions>
+										<includeFunction>fuse_parse_cmdline</includeFunction>
+									</includeFunctions>
 									<includeStructs>
-										<includeStruct>fuse_stat</includeStruct>
-										<includeStruct>fuse_statvfs</includeStruct>
-										<includeStruct>fuse_timespec</includeStruct>
+										<includeStruct>fuse_args</includeStruct>
 									</includeStructs>
 								</configuration>
 							</execution>
diff --git a/jfuse-win-amd64/src/main/java/module-info.java b/jfuse-win-amd64/src/main/java/module-info.java
index d310f1c7..0067f1cd 100644
--- a/jfuse-win-amd64/src/main/java/module-info.java
+++ b/jfuse-win-amd64/src/main/java/module-info.java
@@ -3,6 +3,8 @@
 
 @SuppressWarnings("JavaModuleNaming") // 64 is not a "version", see https://bugs.openjdk.java.net/browse/JDK-8264488
 module org.cryptomator.jfuse.win.amd64 {
+	requires static org.jetbrains.annotations;
+
 	requires org.cryptomator.jfuse.api;
 
 	provides FuseBuilder with WinFuseBuilder;
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/DirFillerImpl.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/DirFillerImpl.java
index f7520317..8a1fec8c 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/DirFillerImpl.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/DirFillerImpl.java
@@ -2,21 +2,26 @@
 
 import org.cryptomator.jfuse.api.DirFiller;
 import org.cryptomator.jfuse.api.Stat;
-import org.cryptomator.jfuse.win.amd64.extr.fuse_fill_dir_t;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_fill_dir_t;
+import org.cryptomator.jfuse.win.amd64.extr.fuse_h;
+import org.cryptomator.jfuse.win.amd64.extr.fuse_stat;
 
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemorySession;
+import java.util.Set;
+import java.util.function.Consumer;
 
-record DirFillerImpl(MemoryAddress buf, fuse_fill_dir_t callback, MemorySession scope) implements DirFiller {
+record DirFillerImpl(MemoryAddress buf, fuse3_fill_dir_t callback, MemorySession scope) implements DirFiller {
 
 	DirFillerImpl(MemoryAddress buf, MemoryAddress callback, MemorySession scope) {
-		this(buf, fuse_fill_dir_t.ofAddress(callback, scope), scope);
+		this(buf, fuse3_fill_dir_t.ofAddress(callback, scope), scope);
 	}
 
 	@Override
-	public int fill(String name, Stat stat, long offset) {
-		var statAddr = stat instanceof StatImpl s ? s.segment().address() : MemoryAddress.NULL;
-		return callback.apply(buf, scope.allocateUtf8String(name).address(), statAddr, offset);
+	public int fill(String name, Consumer<Stat> statFiller, long offset, int flags) {
+		var statSegment = fuse_stat.allocate(scope);
+		statFiller.accept(new StatImpl(statSegment));
+		return callback.apply(buf, scope.allocateUtf8String(name).address(), statSegment.address(), offset, flags);
 	}
 
 }
\ No newline at end of file
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FileInfoImpl.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FileInfoImpl.java
index 9768a7ed..b4615ee5 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FileInfoImpl.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FileInfoImpl.java
@@ -2,7 +2,7 @@
 
 import org.cryptomator.jfuse.api.FileInfo;
 import org.cryptomator.jfuse.win.amd64.extr.fcntl_h;
-import org.cryptomator.jfuse.win.amd64.extr.fuse_file_info;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_file_info;
 
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemorySegment;
@@ -22,22 +22,22 @@ record FileInfoImpl(MemorySegment segment) implements FileInfo {
 	private static final int O_EXCL = fcntl_h.O_EXCL();
 
 	public FileInfoImpl(MemoryAddress address, MemorySession scope) {
-		this(fuse_file_info.ofAddress(address, scope));
+		this(fuse3_file_info.ofAddress(address, scope));
 	}
 
 	@Override
 	public long getFh() {
-		return fuse_file_info.fh$get(segment);
+		return fuse3_file_info.fh$get(segment);
 	}
 
 	@Override
 	public void setFh(long fh) {
-		fuse_file_info.fh$set(segment, fh);
+		fuse3_file_info.fh$set(segment, fh);
 	}
 
 	@Override
 	public int getFlags() {
-		return fuse_file_info.flags$get(segment);
+		return fuse3_file_info.flags$get(segment);
 	}
 
 	@Override
@@ -72,7 +72,7 @@ public Set<StandardOpenOption> getOpenFlags() {
 
 	@Override
 	public long getLockOwner() {
-		return fuse_file_info.lock_owner$get(segment);
+		return fuse3_file_info.lock_owner$get(segment);
 	}
 
 }
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseArgs.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseArgs.java
new file mode 100644
index 00000000..0ee5474b
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseArgs.java
@@ -0,0 +1,24 @@
+package org.cryptomator.jfuse.win.amd64;
+
+import org.cryptomator.jfuse.win.amd64.extr.fuse2.fuse_args;
+
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.ValueLayout;
+
+record FuseArgs(MemorySegment args, MemoryAddress mountPoint, boolean multiThreaded) {
+
+	@Override
+	public String toString() {
+		var sb = new StringBuilder();
+		var argc = fuse_args.argc$get(args);
+		var argv = fuse_args.argv$get(args);
+		for (int i = 0; i < argc; i++) {
+			var cString = argv.getAtIndex(ValueLayout.ADDRESS, i);
+			sb.append("arg[").append(i).append("] = ").append(cString.getUtf8String(0)).append(", ");
+		}
+		sb.append("mountPoint = ").append(mountPoint().getUtf8String(0));
+		sb.append("singlethreaded = ").append(!multiThreaded);
+		return sb.toString();
+	}
+}
\ No newline at end of file
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseConnInfoImpl.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseConnInfoImpl.java
index 167c52ec..5bd40b83 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseConnInfoImpl.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseConnInfoImpl.java
@@ -1,7 +1,7 @@
 package org.cryptomator.jfuse.win.amd64;
 
 import org.cryptomator.jfuse.api.FuseConnInfo;
-import org.cryptomator.jfuse.win.amd64.extr.fuse_conn_info;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_conn_info;
 
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemorySegment;
@@ -10,16 +10,92 @@
 record FuseConnInfoImpl(MemorySegment segment) implements FuseConnInfo {
 
 	public FuseConnInfoImpl(MemoryAddress address, MemorySession scope) {
-		this(fuse_conn_info.ofAddress(address, scope));
+		this(fuse3_conn_info.ofAddress(address, scope));
 	}
 
 	@Override
 	public int protoMajor() {
-		return fuse_conn_info.proto_major$get(segment);
+		return fuse3_conn_info.proto_major$get(segment);
 	}
 
 	@Override
 	public int protoMinor() {
-		return fuse_conn_info.proto_minor$get(segment);
+		return fuse3_conn_info.proto_minor$get(segment);
 	}
+
+	@Override
+	public int capable() {
+		return fuse3_conn_info.capable$get(segment);
+	}
+
+	@Override
+	public int want() {
+		return fuse3_conn_info.want$get(segment);
+	}
+
+	@Override
+	public void setWant(int wanted) {
+		fuse3_conn_info.want$set(segment, wanted);
+	}
+
+	@Override
+	public int maxWrite() {
+		return fuse3_conn_info.max_write$get(segment);
+	}
+
+	@Override
+	public void setMaxWrite(int maxWrite) {
+		fuse3_conn_info.max_write$set(segment, maxWrite);
+	}
+
+	@Override
+	public int maxRead() {
+		return fuse3_conn_info.max_read$get(segment);
+	}
+
+	@Override
+	public void setMaxRead(int maxRead) {
+		fuse3_conn_info.max_read$set(segment, maxRead);
+	}
+
+	@Override
+	public int maxReadahead() {
+		return fuse3_conn_info.max_readahead$get(segment);
+	}
+
+	@Override
+	public void setMaxReadahead(int maxReadahead) {
+		fuse3_conn_info.max_readahead$set(segment, maxReadahead);
+	}
+
+	@Override
+	public int maxBackground() {
+		return fuse3_conn_info.max_background$get(segment);
+	}
+
+	@Override
+	public void setMaxBackground(int maxBackground) {
+		fuse3_conn_info.max_background$set(segment, maxBackground);
+	}
+
+	@Override
+	public int congestionThreshold() {
+		return fuse3_conn_info.congestion_threshold$get(segment);
+	}
+
+	@Override
+	public void setCongestionThreshold(int congestionThreshold) {
+		fuse3_conn_info.congestion_threshold$set(segment, congestionThreshold);
+	}
+
+	@Override
+	public int timeGran() {
+		return fuse3_conn_info.time_gran$get(segment);
+	}
+
+	@Override
+	public void setTimeGran(int timeGran) {
+		fuse3_conn_info.time_gran$set(segment, timeGran);
+	}
+
 }
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseImpl.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseImpl.java
index a07ee981..37ff1703 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseImpl.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseImpl.java
@@ -1,115 +1,161 @@
 package org.cryptomator.jfuse.win.amd64;
 
 import org.cryptomator.jfuse.api.Fuse;
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.api.FuseMount;
 import org.cryptomator.jfuse.api.FuseOperations;
-import org.cryptomator.jfuse.win.amd64.extr.fuse_context;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.win.amd64.extr.fuse2.fuse2_h;
+import org.cryptomator.jfuse.win.amd64.extr.fuse2.fuse_args;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_operations;
 import org.cryptomator.jfuse.win.amd64.extr.fuse_h;
-import org.cryptomator.jfuse.win.amd64.extr.fuse_operations;
 import org.cryptomator.jfuse.win.amd64.extr.fuse_timespec;
+import org.jetbrains.annotations.VisibleForTesting;
 
+import java.io.IOException;
+import java.lang.foreign.Addressable;
 import java.lang.foreign.MemoryAddress;
 import java.lang.foreign.MemoryLayout;
 import java.lang.foreign.MemorySegment;
 import java.lang.foreign.MemorySession;
-import java.nio.ByteBuffer;
+import java.lang.foreign.ValueLayout;
+import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicReference;
+import java.nio.file.attribute.BasicFileAttributeView;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 
-public final class FuseImpl extends Fuse {
+import static java.lang.foreign.ValueLayout.JAVA_INT;
 
-	private final CompletableFuture<Integer> initialized = new CompletableFuture<>();
+public class FuseImpl extends Fuse {
+
+	//Used to check, if the mounted fs is actually accessible, see https://github.com/winfsp/winfsp/discussions/440
+	private static final String MOUNT_PROBE = "/jfuse_windows_mount_probe";
 	private final FuseOperations delegate;
-	private final MemorySegment struct;
+	private final MemorySegment fuseOps;
 
-	private final AtomicReference<MemoryAddress> fuseHandle;
+	private final CountDownLatch mountProbeSucceeded = new CountDownLatch(1);
 
 	public FuseImpl(FuseOperations fuseOperations) {
-		this.struct = fuse_operations.allocate(fuseScope);
+		this.fuseOps = fuse3_operations.allocate(fuseScope);
 		this.delegate = fuseOperations;
-		fuse_operations.init$set(struct, fuse_operations.init.allocate(this::init, fuseScope).address());
 		fuseOperations.supportedOperations().forEach(this::bind);
-		fuseHandle = new AtomicReference<>();
-	}
-
-	private MemoryAddress init(MemoryAddress conn) {
-		try (var scope = MemorySession.openConfined()) {
-			if (delegate.supportedOperations().contains(FuseOperations.Operation.INIT)) {
-				delegate.init(new FuseConnInfoImpl(conn, scope));
-			}
-			//store fuse handle to be used in fuse_exit()
-			var ctx = fuse_context.ofAddress(fuse_h.fuse_get_context(), scope);
-			this.fuseHandle.set(fuse_context.fuse$get(ctx));
-
-			initialized.complete(0);
-		} catch (Exception e) {
-			initialized.completeExceptionally(e);
-		}
-		return MemoryAddress.NULL;
 	}
 
 	@Override
-	public int mount(String progName, Path mountPoint, String... flags) throws TimeoutException {
+	public void mount(String progName, Path mountPoint, String... flags) throws MountFailedException {
 		var adjustedMP = mountPoint;
-		if (mountPoint.compareTo(mountPoint.getRoot()) == 0 && mountPoint.isAbsolute()) {
+		if (mountPoint.equals(mountPoint.getRoot()) && mountPoint.isAbsolute()) {
 			//winfsp accepts only drive letters written in drive relative notation
 			adjustedMP = Path.of(mountPoint.toString().charAt(0) + ":");
 		}
-		return super.mount(progName, adjustedMP, flags);
+		super.mount(progName, adjustedMP, flags);
+		try {
+			waitForMountingToComplete(mountPoint);
+		} catch (InterruptedException e) {
+			Thread.currentThread().interrupt();
+			throw new MountFailedException("Interrupted while waiting for mounting to finish");
+		}
 	}
 
-	@Override
-	protected CompletableFuture<Integer> initialized() {
-		return initialized;
+	@VisibleForTesting
+	void waitForMountingToComplete(Path mountPoint) throws InterruptedException {
+		var probe = Files.getFileAttributeView(mountPoint.resolve(MOUNT_PROBE.substring(1)), BasicFileAttributeView.class);
+		do {
+			try {
+				probe.readAttributes(); // we don't care about the result, we just want to trigger a getattr call
+			} catch (IOException e) {
+				//noop
+			}
+		} while (!mountProbeSucceeded.await(333, TimeUnit.MILLISECONDS));
 	}
 
+
 	@Override
-	protected int fuseMain(int argc, MemorySegment argv) {
-		return fuse_h.fuse_main_real(argc, argv, struct, struct.byteSize(), MemoryAddress.NULL);
+	protected FuseMount mount(List<String> args) throws MountFailedException {
+		var fuseArgs = parseArgs(args);
+		var fuse = fuse_h.fuse3_new(fuseArgs.args(), fuseOps, fuseOps.byteSize(), MemoryAddress.NULL);
+		if (MemoryAddress.NULL.equals(fuse)) {
+			throw new MountFailedException("fuse_new failed");
+		}
+		if (fuse_h.fuse3_mount(fuse, fuseArgs.mountPoint()) != 0) {
+			throw new MountFailedException("fuse_mount failed");
+		}
+		return new FuseMountImpl(fuse, fuseArgs);
 	}
 
-	//TODO: subject to change
-	private void fuseExit() {
-		var actualHandle = fuseHandle.getAndSet(null);
-		if (actualHandle != null) {
-			fuse_h.fuse_exit(actualHandle);
+	@VisibleForTesting
+	FuseArgs parseArgs(List<String> cmdLineArgs) throws IllegalArgumentException {
+		var args = fuse_args.allocate(fuseScope);
+		var argc = cmdLineArgs.size();
+		var argv = fuseScope.allocateArray(ValueLayout.ADDRESS, argc + 1L);
+		for (int i = 0; i < argc; i++) {
+			var cString = fuseScope.allocateUtf8String(cmdLineArgs.get(i));
+			argv.setAtIndex(ValueLayout.ADDRESS, i, cString);
 		}
+		argv.setAtIndex(ValueLayout.ADDRESS, argc, MemoryAddress.NULL);
+		fuse_args.argc$set(args, argc);
+		fuse_args.argv$set(args, argv.address());
+		fuse_args.allocated$set(args, 0);
+
+		var multithreaded = fuseScope.allocate(JAVA_INT, 1);
+		var foreground = fuseScope.allocate(JAVA_INT, 1);
+		var mountPointPtr = fuseScope.allocate(ValueLayout.ADDRESS);
+		int parseResult = fuse2_h.fuse_parse_cmdline(args, mountPointPtr, multithreaded, foreground); //winfsp pecularity due to unsupportd fuse_lowlevel.h
+		if (parseResult != 0) {
+			throw new IllegalArgumentException("fuse_parse_cmdline failed to parse " + String.join(" ", cmdLineArgs));
+		}
+		var isMultiThreaded = multithreaded.get(JAVA_INT, 0) == 1;
+		var mountPoint = mountPointPtr.get(ValueLayout.ADDRESS, 0);
+		return new FuseArgs(args, mountPoint, isMultiThreaded);
 	}
 
+	/**
+	 * Sets a fuse callback. For supported callbacks, see winfsp/inc/fuse3/fuse_h
+	 * @param operation The fuse operation enum, indicating which operation to set.
+	 */
 	private void bind(FuseOperations.Operation operation) {
 		switch (operation) {
-			case INIT -> { /* handled already */ }
-			case ACCESS -> fuse_operations.access$set(struct, fuse_operations.access.allocate(this::access, fuseScope).address());
-			case CHMOD -> fuse_operations.chmod$set(struct, fuse_operations.chmod.allocate(this::chmod, fuseScope).address());
-			case CREATE -> fuse_operations.create$set(struct, fuse_operations.create.allocate(this::create, fuseScope).address());
-			case DESTROY -> fuse_operations.destroy$set(struct, fuse_operations.destroy.allocate(this::destroy, fuseScope).address());
-			case GET_ATTR -> fuse_operations.getattr$set(struct, fuse_operations.getattr.allocate(this::getattr, fuseScope).address());
-			case MKDIR -> fuse_operations.mkdir$set(struct, fuse_operations.mkdir.allocate(this::mkdir, fuseScope).address());
-			case OPEN -> fuse_operations.open$set(struct, fuse_operations.open.allocate(this::open, fuseScope).address());
-			case OPEN_DIR -> fuse_operations.opendir$set(struct, fuse_operations.opendir.allocate(this::opendir, fuseScope).address());
-			case READ -> fuse_operations.read$set(struct, fuse_operations.read.allocate(this::read, fuseScope).address());
-			case READ_DIR -> fuse_operations.readdir$set(struct, fuse_operations.readdir.allocate(this::readdir, fuseScope).address());
-			case READLINK -> fuse_operations.readlink$set(struct, fuse_operations.readlink.allocate(this::readlink, fuseScope).address());
-			case RELEASE -> fuse_operations.release$set(struct, fuse_operations.release.allocate(this::release, fuseScope).address());
-			case RELEASE_DIR -> fuse_operations.releasedir$set(struct, fuse_operations.releasedir.allocate(this::releasedir, fuseScope).address());
-			case RENAME -> fuse_operations.rename$set(struct, fuse_operations.rename.allocate(this::rename, fuseScope).address());
-			case RMDIR -> fuse_operations.rmdir$set(struct, fuse_operations.rmdir.allocate(this::rmdir, fuseScope).address());
-			case STATFS -> fuse_operations.statfs$set(struct, fuse_operations.statfs.allocate(this::statfs, fuseScope).address());
-			case SYMLINK -> fuse_operations.symlink$set(struct, fuse_operations.symlink.allocate(this::symlink, fuseScope).address());
-			case TRUNCATE -> fuse_operations.truncate$set(struct, fuse_operations.truncate.allocate(this::truncate, fuseScope).address());
-			case UNLINK -> fuse_operations.unlink$set(struct, fuse_operations.unlink.allocate(this::unlink, fuseScope).address());
-			case UTIMENS -> fuse_operations.utimens$set(struct, fuse_operations.utimens.allocate(this::utimens, fuseScope).address());
-			case WRITE -> fuse_operations.write$set(struct, fuse_operations.write.allocate(this::write, fuseScope).address());
-		}
-	}
-
-	private int access(MemoryAddress path, int mask) {
-		return delegate.access(path.getUtf8String(0), mask);
-	}
-
-	private int chmod(MemoryAddress path, int mode) {
-		return delegate.chmod(path.getUtf8String(0), mode);
+			case INIT -> fuse3_operations.init$set(fuseOps, fuse3_operations.init.allocate(this::init, fuseScope).address());
+			case ACCESS -> fuse3_operations.access$set(fuseOps, MemoryAddress.NULL);
+			case CHMOD -> fuse3_operations.chmod$set(fuseOps, fuse3_operations.chmod.allocate(this::chmod, fuseScope).address());
+			case CREATE -> fuse3_operations.create$set(fuseOps, fuse3_operations.create.allocate(this::create, fuseScope).address());
+			case DESTROY -> fuse3_operations.destroy$set(fuseOps, fuse3_operations.destroy.allocate(this::destroy, fuseScope).address());
+			case GET_ATTR -> fuse3_operations.getattr$set(fuseOps, fuse3_operations.getattr.allocate(this::getattr, fuseScope).address());
+			case MKDIR -> fuse3_operations.mkdir$set(fuseOps, fuse3_operations.mkdir.allocate(this::mkdir, fuseScope).address());
+			case OPEN -> fuse3_operations.open$set(fuseOps, fuse3_operations.open.allocate(this::open, fuseScope).address());
+			case OPEN_DIR -> fuse3_operations.opendir$set(fuseOps, fuse3_operations.opendir.allocate(this::opendir, fuseScope).address());
+			case READ -> fuse3_operations.read$set(fuseOps, fuse3_operations.read.allocate(this::read, fuseScope).address());
+			case READ_DIR -> fuse3_operations.readdir$set(fuseOps, fuse3_operations.readdir.allocate(this::readdir, fuseScope).address());
+			case READLINK -> fuse3_operations.readlink$set(fuseOps, fuse3_operations.readlink.allocate(this::readlink, fuseScope).address());
+			case RELEASE -> fuse3_operations.release$set(fuseOps, fuse3_operations.release.allocate(this::release, fuseScope).address());
+			case RELEASE_DIR -> fuse3_operations.releasedir$set(fuseOps, fuse3_operations.releasedir.allocate(this::releasedir, fuseScope).address());
+			case RENAME -> fuse3_operations.rename$set(fuseOps, fuse3_operations.rename.allocate(this::rename, fuseScope).address());
+			case RMDIR -> fuse3_operations.rmdir$set(fuseOps, fuse3_operations.rmdir.allocate(this::rmdir, fuseScope).address());
+			case STATFS -> fuse3_operations.statfs$set(fuseOps, fuse3_operations.statfs.allocate(this::statfs, fuseScope).address());
+			case SYMLINK -> fuse3_operations.symlink$set(fuseOps, fuse3_operations.symlink.allocate(this::symlink, fuseScope).address());
+			case TRUNCATE -> fuse3_operations.truncate$set(fuseOps, fuse3_operations.truncate.allocate(this::truncate, fuseScope).address());
+			case UNLINK -> fuse3_operations.unlink$set(fuseOps, fuse3_operations.unlink.allocate(this::unlink, fuseScope).address());
+			case UTIMENS -> fuse3_operations.utimens$set(fuseOps, fuse3_operations.utimens.allocate(this::utimens, fuseScope).address());
+			case WRITE -> fuse3_operations.write$set(fuseOps, fuse3_operations.write.allocate(this::write, fuseScope).address());
+		}
+	}
+
+	@VisibleForTesting
+	Addressable init(MemoryAddress conn, MemoryAddress fuseConfig) {
+		try (var scope = MemorySession.openConfined()) {
+			var connInfo = new FuseConnInfoImpl(conn, scope);
+			connInfo.setWant(connInfo.want() | FuseConnInfo.FUSE_CAP_READDIRPLUS);
+			delegate.init(connInfo);
+		}
+		return MemoryAddress.NULL;
+	}
+
+	private int chmod(MemoryAddress path, int mode, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.chmod(path.getUtf8String(0), mode, new FileInfoImpl(fi, scope));
+		}
 	}
 
 	private int create(MemoryAddress path, int mode, MemoryAddress fi) {
@@ -122,9 +168,14 @@ private void destroy(MemoryAddress addr) {
 		delegate.destroy();
 	}
 
-	private int getattr(MemoryAddress path, MemoryAddress stat) {
+	@VisibleForTesting
+	int getattr(MemoryAddress path, MemoryAddress stat, MemoryAddress fi) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.getattr(path.getUtf8String(0), new StatImpl(stat, scope));
+			var pathObj = path.getUtf8String(0);
+			if(mountProbeSucceeded.getCount() > 0 && pathObj.equals(MOUNT_PROBE) ) {
+				mountProbeSucceeded.countDown();
+			}
+			return delegate.getattr(pathObj, new StatImpl(stat, scope), new FileInfoImpl(fi, scope));
 		}
 	}
 
@@ -151,9 +202,9 @@ private int read(MemoryAddress path, MemoryAddress buf, long size, long offset,
 		}
 	}
 
-	private int readdir(MemoryAddress path, MemoryAddress buf, MemoryAddress filler, long offset, MemoryAddress fi) {
+	private int readdir(MemoryAddress path, MemoryAddress buf, MemoryAddress filler, long offset, MemoryAddress fi, int flags) {
 		try (var scope = MemorySession.openConfined()) {
-			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope));
+			return delegate.readdir(path.getUtf8String(0), new DirFillerImpl(buf, filler, scope), offset, new FileInfoImpl(fi, scope), flags);
 		}
 	}
 
@@ -176,8 +227,8 @@ private int releasedir(MemoryAddress path, MemoryAddress fi) {
 		}
 	}
 
-	private int rename(MemoryAddress oldpath, MemoryAddress newpath) {
-		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0));
+	private int rename(MemoryAddress oldpath, MemoryAddress newpath, int flags) {
+		return delegate.rename(oldpath.getUtf8String(0), newpath.getUtf8String(0), flags);
 	}
 
 	private int rmdir(MemoryAddress path) {
@@ -194,29 +245,33 @@ private int symlink(MemoryAddress linkname, MemoryAddress target) {
 		return delegate.symlink(linkname.getUtf8String(0), target.getUtf8String(0));
 	}
 
-	private int truncate(MemoryAddress path, long size) {
-		return delegate.truncate(path.getUtf8String(0), size);
+	@VisibleForTesting
+	int truncate(MemoryAddress path, long size, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			return delegate.truncate(path.getUtf8String(0), size, new FileInfoImpl(fi, scope));
+		}
 	}
 
 	private int unlink(MemoryAddress path) {
 		return delegate.unlink(path.getUtf8String(0));
 	}
 
-	private int utimens(MemoryAddress path, MemoryAddress times) {
-		if (MemoryAddress.NULL.equals(times)) {
-			// set both times to current time (using on-heap memory segments)
-			var segment = MemorySegment.ofBuffer(ByteBuffer.allocate((int) fuse_timespec.$LAYOUT().byteSize()));
-			fuse_timespec.tv_sec$set(segment, 0);
-			fuse_timespec.tv_nsec$set(segment, 0); // FIXME use hard-coded UTIME_NOW
-			var time = new TimeSpecImpl(segment);
-			return delegate.utimens(path.getUtf8String(0), time, time);
-		} else {
-			try (var scope = MemorySession.openConfined()) {
+	@VisibleForTesting
+	int utimens(MemoryAddress path, MemoryAddress times, MemoryAddress fi) {
+		try (var scope = MemorySession.openConfined()) {
+			if (MemoryAddress.NULL.equals(times)) {
+				// set both times to current time (using on-heap memory segments)
+				var segment = MemorySegment.allocateNative(fuse_timespec.$LAYOUT().byteSize(), scope);
+				fuse_timespec.tv_sec$set(segment, 0);
+				fuse_timespec.tv_nsec$set(segment, 0); //FIXME: use hardcoded UTIME_NOW
+				var time = new TimeSpecImpl(segment);
+				return delegate.utimens(path.getUtf8String(0), time, time, new FileInfoImpl(fi, scope));
+			} else {
 				var seq = MemoryLayout.sequenceLayout(2, fuse_timespec.$LAYOUT());
 				var segment = MemorySegment.ofAddress(times, seq.byteSize(), scope);
 				var time0 = segment.asSlice(0, fuse_timespec.$LAYOUT().byteSize());
 				var time1 = segment.asSlice(fuse_timespec.$LAYOUT().byteSize(), fuse_timespec.$LAYOUT().byteSize());
-				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1));
+				return delegate.utimens(path.getUtf8String(0), new TimeSpecImpl(time0), new TimeSpecImpl(time1), new FileInfoImpl(fi, scope));
 			}
 		}
 	}
@@ -228,11 +283,4 @@ private int write(MemoryAddress path, MemoryAddress buf, long size, long offset,
 		}
 	}
 
-	//TODO: subject to change
-	@Override
-	public void close() throws TimeoutException {
-		fuseExit();
-		super.close();
-	}
-
 }
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseMountImpl.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseMountImpl.java
new file mode 100644
index 00000000..755adefd
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/FuseMountImpl.java
@@ -0,0 +1,30 @@
+package org.cryptomator.jfuse.win.amd64;
+
+import org.cryptomator.jfuse.api.FuseMount;
+import org.cryptomator.jfuse.win.amd64.extr.fuse_h;
+
+import java.lang.foreign.MemoryAddress;
+
+record FuseMountImpl(MemoryAddress fuse, FuseArgs fuseArgs) implements FuseMount {
+
+	@Override
+	public int loop() {
+		if (fuseArgs.multiThreaded()) {
+			return fuse_h.fuse3_loop_mt_31(fuse, 0);
+		} else {
+			return fuse_h.fuse3_loop(fuse);
+		}
+	}
+
+	@Override
+	public void unmount() {
+		fuse_h.fuse3_exit(fuse);
+		fuse_h.fuse3_unmount(fuse);
+	}
+
+	@Override
+	public void destroy() {
+		fuse_h.fuse3_destroy(fuse);
+	}
+
+}
\ No newline at end of file
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/StatImpl.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/StatImpl.java
index 18be4896..a120555d 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/StatImpl.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/StatImpl.java
@@ -10,20 +10,6 @@
 
 record StatImpl(MemorySegment segment) implements Stat {
 
-	/*
-	 * Windows modes from <code>stat.h</code> are incorrect. Winfsp expects POSIX values.
-	 * @see <a href="https://github.com/billziss-gh/winfsp/blob/751eaa69dfbb203035208e99aa92693223dac5fe/src/dll/fuse/fuse_intf.c#L494-L521">WinFSP implementation</a>
-	 */
-
-	@SuppressWarnings("OctalInteger")
-	private static final int S_IFDIR = 0040000;
-
-	@SuppressWarnings("OctalInteger")
-	private static final int S_IFREG = 0100000;
-
-	@SuppressWarnings("OctalInteger")
-	private static final int S_IFLNK = 0120000;
-
 	public StatImpl(MemoryAddress address, MemorySession scope) {
 		this(fuse_stat.ofAddress(address, scope));
 	}
@@ -78,46 +64,4 @@ public long getSize() {
 		return fuse_stat.st_size$get(segment);
 	}
 
-	@Override
-	public boolean isDir() {
-		return (getMode() & S_IFDIR) == S_IFDIR;
-	}
-
-	@Override
-	public void toggleDir(boolean isDir) {
-		if (isDir) {
-			setMode(getMode() | S_IFDIR);
-		} else {
-			setMode(getMode() & ~S_IFDIR);
-		}
-	}
-
-	@Override
-	public boolean isReg() {
-		return (getMode() & S_IFREG) == S_IFREG;
-	}
-
-	@Override
-	public void toggleReg(boolean isReg) {
-		if (isReg) {
-			setMode(getMode() | S_IFREG);
-		} else {
-			setMode(getMode() & ~S_IFREG);
-		}
-	}
-
-	@Override
-	public boolean isLnk() {
-		return (getMode() & S_IFLNK) == S_IFLNK;
-	}
-
-	@Override
-	public void toggleLnk(boolean isLnk) {
-		if (isLnk) {
-			setMode(getMode() | S_IFLNK);
-		} else {
-			setMode(getMode() & ~S_IFLNK);
-		}
-	}
-
 }
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/constants$0.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/constants$0.java
index 48156317..6f64cd87 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/constants$0.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/constants$0.java
@@ -9,37 +9,47 @@
 import static java.lang.foreign.ValueLayout.*;
 class constants$0 {
 
-    static final FunctionDescriptor fuse_fill_dir_t$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
+    static final FunctionDescriptor fuse3_fill_dir_t$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_LONG$LAYOUT
+    );
+    static final MethodHandle fuse3_fill_dir_t$MH = RuntimeHelper.downcallHandle(
+        constants$0.fuse3_fill_dir_t$FUNC
+    );
+    static final FunctionDescriptor fuse3_lib_help$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_fill_dir_t$MH = RuntimeHelper.downcallHandle(
-        constants$0.fuse_fill_dir_t$FUNC
+    static final MethodHandle fuse3_lib_help$MH = RuntimeHelper.downcallHandle(
+        "fuse3_lib_help",
+        constants$0.fuse3_lib_help$FUNC
     );
-    static final FunctionDescriptor fuse_main_real$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_LONG$LAYOUT,
+    static final FunctionDescriptor fuse3_new$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_main_real$MH = RuntimeHelper.downcallHandle(
-        "fuse_main_real",
-        constants$0.fuse_main_real$FUNC
+    static final MethodHandle fuse3_new$MH = RuntimeHelper.downcallHandle(
+        "fuse3_new",
+        constants$0.fuse3_new$FUNC
     );
-    static final FunctionDescriptor fuse_exit$FUNC = FunctionDescriptor.ofVoid(
+    static final FunctionDescriptor fuse3_destroy$FUNC = FunctionDescriptor.ofVoid(
         Constants$root.C_POINTER$LAYOUT
     );
-    static final MethodHandle fuse_exit$MH = RuntimeHelper.downcallHandle(
-        "fuse_exit",
-        constants$0.fuse_exit$FUNC
+    static final MethodHandle fuse3_destroy$MH = RuntimeHelper.downcallHandle(
+        "fuse3_destroy",
+        constants$0.fuse3_destroy$FUNC
+    );
+    static final FunctionDescriptor fuse3_mount$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
-    static final FunctionDescriptor fuse_get_context$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT);
-    static final MethodHandle fuse_get_context$MH = RuntimeHelper.downcallHandle(
-        "fuse_get_context",
-        constants$0.fuse_get_context$FUNC
+    static final MethodHandle fuse3_mount$MH = RuntimeHelper.downcallHandle(
+        "fuse3_mount",
+        constants$0.fuse3_mount$FUNC
     );
 }
 
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/constants$1.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/constants$1.java
new file mode 100644
index 00000000..318db787
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/constants$1.java
@@ -0,0 +1,50 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.win.amd64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+class constants$1 {
+
+    static final FunctionDescriptor fuse3_unmount$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse3_unmount$MH = RuntimeHelper.downcallHandle(
+        "fuse3_unmount",
+        constants$1.fuse3_unmount$FUNC
+    );
+    static final FunctionDescriptor fuse3_loop$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse3_loop$MH = RuntimeHelper.downcallHandle(
+        "fuse3_loop",
+        constants$1.fuse3_loop$FUNC
+    );
+    static final FunctionDescriptor fuse3_loop_mt_31$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG$LAYOUT
+    );
+    static final MethodHandle fuse3_loop_mt_31$MH = RuntimeHelper.downcallHandle(
+        "fuse3_loop_mt_31",
+        constants$1.fuse3_loop_mt_31$FUNC
+    );
+    static final FunctionDescriptor fuse3_exit$FUNC = FunctionDescriptor.ofVoid(
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse3_exit$MH = RuntimeHelper.downcallHandle(
+        "fuse3_exit",
+        constants$1.fuse3_exit$FUNC
+    );
+    static final FunctionDescriptor fuse3_get_session$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse3_get_session$MH = RuntimeHelper.downcallHandle(
+        "fuse3_get_session",
+        constants$1.fuse3_get_session$FUNC
+    );
+}
+
+
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/Constants$root.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/Constants$root.java
new file mode 100644
index 00000000..85fa7c32
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/Constants$root.java
@@ -0,0 +1,23 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.win.amd64.extr.fuse2;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class Constants$root {
+
+    static final  OfBoolean C_BOOL$LAYOUT = JAVA_BOOLEAN;
+    static final  OfByte C_CHAR$LAYOUT = JAVA_BYTE;
+    static final  OfShort C_SHORT$LAYOUT = JAVA_SHORT.withBitAlignment(16);
+    static final  OfInt C_INT$LAYOUT = JAVA_INT.withBitAlignment(32);
+    static final  OfInt C_LONG$LAYOUT = JAVA_INT.withBitAlignment(32);
+    static final  OfLong C_LONG_LONG$LAYOUT = JAVA_LONG.withBitAlignment(64);
+    static final  OfFloat C_FLOAT$LAYOUT = JAVA_FLOAT.withBitAlignment(32);
+    static final  OfDouble C_DOUBLE$LAYOUT = JAVA_DOUBLE.withBitAlignment(64);
+    static final  OfAddress C_POINTER$LAYOUT = ADDRESS.withBitAlignment(64);
+}
+
+
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/RuntimeHelper.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/RuntimeHelper.java
new file mode 100644
index 00000000..69422f9c
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/RuntimeHelper.java
@@ -0,0 +1,233 @@
+package org.cryptomator.jfuse.win.amd64.extr.fuse2;
+// Generated by jextract
+
+import java.lang.foreign.Addressable;
+import java.lang.foreign.Linker;
+import java.lang.foreign.FunctionDescriptor;
+import java.lang.foreign.GroupLayout;
+import java.lang.foreign.SymbolLookup;
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemoryLayout;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.lang.foreign.SegmentAllocator;
+import java.lang.foreign.ValueLayout;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.io.File;
+import java.nio.file.Path;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import static java.lang.foreign.Linker.*;
+import static java.lang.foreign.ValueLayout.*;
+
+final class RuntimeHelper {
+
+    private RuntimeHelper() {}
+    private final static Linker LINKER = Linker.nativeLinker();
+    private final static ClassLoader LOADER = RuntimeHelper.class.getClassLoader();
+    private final static MethodHandles.Lookup MH_LOOKUP = MethodHandles.lookup();
+    private final static SymbolLookup SYMBOL_LOOKUP;
+
+    final static SegmentAllocator CONSTANT_ALLOCATOR =
+            (size, align) -> MemorySegment.allocateNative(size, align, MemorySession.openImplicit());
+
+    static {
+        
+        SymbolLookup loaderLookup = SymbolLookup.loaderLookup();
+        SYMBOL_LOOKUP = name -> loaderLookup.lookup(name).or(() -> LINKER.defaultLookup().lookup(name));
+    }
+
+    static <T> T requireNonNull(T obj, String symbolName) {
+        if (obj == null) {
+            throw new UnsatisfiedLinkError("unresolved symbol: " + symbolName);
+        }
+        return obj;
+    }
+
+    private final static SegmentAllocator THROWING_ALLOCATOR = (x, y) -> { throw new AssertionError("should not reach here"); };
+
+    static final MemorySegment lookupGlobalVariable(String name, MemoryLayout layout) {
+        return SYMBOL_LOOKUP.lookup(name).map(symbol -> MemorySegment.ofAddress(symbol.address(), layout.byteSize(), MemorySession.openShared())).orElse(null);
+    }
+
+    static final MethodHandle downcallHandle(String name, FunctionDescriptor fdesc) {
+        return SYMBOL_LOOKUP.lookup(name).
+                map(addr -> LINKER.downcallHandle(addr, fdesc)).
+                orElse(null);
+    }
+
+    static final MethodHandle downcallHandle(FunctionDescriptor fdesc) {
+        return LINKER.downcallHandle(fdesc);
+    }
+
+    static final MethodHandle downcallHandleVariadic(String name, FunctionDescriptor fdesc) {
+        return SYMBOL_LOOKUP.lookup(name).
+                map(addr -> VarargsInvoker.make(addr, fdesc)).
+                orElse(null);
+    }
+
+    static final <Z> MemorySegment upcallStub(Class<Z> fi, Z z, FunctionDescriptor fdesc, MemorySession session) {
+        try {
+            MethodHandle handle = MH_LOOKUP.findVirtual(fi, "apply", Linker.upcallType(fdesc));
+            handle = handle.bindTo(z);
+            return LINKER.upcallStub(handle, fdesc, session);
+        } catch (Throwable ex) {
+            throw new AssertionError(ex);
+        }
+    }
+
+    static MemorySegment asArray(MemoryAddress addr, MemoryLayout layout, int numElements, MemorySession session) {
+         return MemorySegment.ofAddress(addr, numElements * layout.byteSize(), session);
+    }
+
+    // Internals only below this point
+
+    private static class VarargsInvoker {
+        private static final MethodHandle INVOKE_MH;
+        private final MemorySegment symbol;
+        private final FunctionDescriptor function;
+
+        private VarargsInvoker(MemorySegment symbol, FunctionDescriptor function) {
+            this.symbol = symbol;
+            this.function = function;
+        }
+
+        static {
+            try {
+                INVOKE_MH = MethodHandles.lookup().findVirtual(VarargsInvoker.class, "invoke", MethodType.methodType(Object.class, SegmentAllocator.class, Object[].class));
+            } catch (ReflectiveOperationException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+        static MethodHandle make(MemorySegment symbol, FunctionDescriptor function) {
+            VarargsInvoker invoker = new VarargsInvoker(symbol, function);
+            MethodHandle handle = INVOKE_MH.bindTo(invoker).asCollector(Object[].class, function.argumentLayouts().size() + 1);
+            MethodType mtype = MethodType.methodType(function.returnLayout().isPresent() ? carrier(function.returnLayout().get(), true) : void.class);
+            for (MemoryLayout layout : function.argumentLayouts()) {
+                mtype = mtype.appendParameterTypes(carrier(layout, false));
+            }
+            mtype = mtype.appendParameterTypes(Object[].class);
+            if (mtype.returnType().equals(MemorySegment.class)) {
+                mtype = mtype.insertParameterTypes(0, SegmentAllocator.class);
+            } else {
+                handle = MethodHandles.insertArguments(handle, 0, THROWING_ALLOCATOR);
+            }
+            return handle.asType(mtype);
+        }
+
+        static Class<?> carrier(MemoryLayout layout, boolean ret) {
+            if (layout instanceof ValueLayout valueLayout) {
+                return (ret || valueLayout.carrier() != MemoryAddress.class) ?
+                        valueLayout.carrier() : Addressable.class;
+            } else if (layout instanceof GroupLayout) {
+                return MemorySegment.class;
+            } else {
+                throw new AssertionError("Cannot get here!");
+            }
+        }
+
+        private Object invoke(SegmentAllocator allocator, Object[] args) throws Throwable {
+            // one trailing Object[]
+            int nNamedArgs = function.argumentLayouts().size();
+            assert(args.length == nNamedArgs + 1);
+            // The last argument is the array of vararg collector
+            Object[] unnamedArgs = (Object[]) args[args.length - 1];
+
+            int argsCount = nNamedArgs + unnamedArgs.length;
+            Class<?>[] argTypes = new Class<?>[argsCount];
+            MemoryLayout[] argLayouts = new MemoryLayout[nNamedArgs + unnamedArgs.length];
+
+            int pos = 0;
+            for (pos = 0; pos < nNamedArgs; pos++) {
+                argLayouts[pos] = function.argumentLayouts().get(pos);
+            }
+
+            assert pos == nNamedArgs;
+            for (Object o: unnamedArgs) {
+                argLayouts[pos] = variadicLayout(normalize(o.getClass()));
+                pos++;
+            }
+            assert pos == argsCount;
+
+            FunctionDescriptor f = (function.returnLayout().isEmpty()) ?
+                    FunctionDescriptor.ofVoid(argLayouts) :
+                    FunctionDescriptor.of(function.returnLayout().get(), argLayouts);
+            MethodHandle mh = LINKER.downcallHandle(symbol, f);
+            if (mh.type().returnType() == MemorySegment.class) {
+                mh = mh.bindTo(allocator);
+            }
+            // flatten argument list so that it can be passed to an asSpreader MH
+            Object[] allArgs = new Object[nNamedArgs + unnamedArgs.length];
+            System.arraycopy(args, 0, allArgs, 0, nNamedArgs);
+            System.arraycopy(unnamedArgs, 0, allArgs, nNamedArgs, unnamedArgs.length);
+
+            return mh.asSpreader(Object[].class, argsCount).invoke(allArgs);
+        }
+
+        private static Class<?> unboxIfNeeded(Class<?> clazz) {
+            if (clazz == Boolean.class) {
+                return boolean.class;
+            } else if (clazz == Void.class) {
+                return void.class;
+            } else if (clazz == Byte.class) {
+                return byte.class;
+            } else if (clazz == Character.class) {
+                return char.class;
+            } else if (clazz == Short.class) {
+                return short.class;
+            } else if (clazz == Integer.class) {
+                return int.class;
+            } else if (clazz == Long.class) {
+                return long.class;
+            } else if (clazz == Float.class) {
+                return float.class;
+            } else if (clazz == Double.class) {
+                return double.class;
+            } else {
+                return clazz;
+            }
+        }
+
+        private Class<?> promote(Class<?> c) {
+            if (c == byte.class || c == char.class || c == short.class || c == int.class) {
+                return long.class;
+            } else if (c == float.class) {
+                return double.class;
+            } else {
+                return c;
+            }
+        }
+
+        private Class<?> normalize(Class<?> c) {
+            c = unboxIfNeeded(c);
+            if (c.isPrimitive()) {
+                return promote(c);
+            }
+            if (MemoryAddress.class.isAssignableFrom(c)) {
+                return MemoryAddress.class;
+            }
+            if (MemorySegment.class.isAssignableFrom(c)) {
+                return MemorySegment.class;
+            }
+            throw new IllegalArgumentException("Invalid type for ABI: " + c.getTypeName());
+        }
+
+        private MemoryLayout variadicLayout(Class<?> c) {
+            if (c == long.class) {
+                return JAVA_LONG;
+            } else if (c == double.class) {
+                return JAVA_DOUBLE;
+            } else if (MemoryAddress.class.isAssignableFrom(c)) {
+                return ADDRESS;
+            } else {
+                throw new IllegalArgumentException("Unhandled variadic argument class: " + c);
+            }
+        }
+    }
+}
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/constants$0.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/constants$0.java
new file mode 100644
index 00000000..c13c8dd4
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/constants$0.java
@@ -0,0 +1,24 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.win.amd64.extr.fuse2;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+class constants$0 {
+
+    static final FunctionDescriptor fuse_parse_cmdline$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
+    );
+    static final MethodHandle fuse_parse_cmdline$MH = RuntimeHelper.downcallHandle(
+        "fuse_parse_cmdline",
+        constants$0.fuse_parse_cmdline$FUNC
+    );
+}
+
+
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/fuse2_h.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/fuse2_h.java
new file mode 100644
index 00000000..d06c6cbc
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/fuse2_h.java
@@ -0,0 +1,34 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.win.amd64.extr.fuse2;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse2_h  {
+
+    /* package-private */ fuse2_h() {}
+    public static OfByte C_CHAR = Constants$root.C_CHAR$LAYOUT;
+    public static OfShort C_SHORT = Constants$root.C_SHORT$LAYOUT;
+    public static OfInt C_INT = Constants$root.C_LONG$LAYOUT;
+    public static OfInt C_LONG = Constants$root.C_LONG$LAYOUT;
+    public static OfLong C_LONG_LONG = Constants$root.C_LONG_LONG$LAYOUT;
+    public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
+    public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
+    public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
+    public static MethodHandle fuse_parse_cmdline$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse_parse_cmdline$MH,"fuse_parse_cmdline");
+    }
+    public static int fuse_parse_cmdline ( Addressable args,  Addressable mountpoint,  Addressable multithreaded,  Addressable foreground) {
+        var mh$ = fuse_parse_cmdline$MH();
+        try {
+            return (int)mh$.invokeExact(args, mountpoint, multithreaded, foreground);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+}
+
+
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/fuse_args.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/fuse_args.java
new file mode 100644
index 00000000..ab0abb67
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse2/fuse_args.java
@@ -0,0 +1,78 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.win.amd64.extr.fuse2;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse_args {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_LONG$LAYOUT.withName("argc"),
+        MemoryLayout.paddingLayout(32),
+        Constants$root.C_POINTER$LAYOUT.withName("argv"),
+        Constants$root.C_LONG$LAYOUT.withName("allocated"),
+        MemoryLayout.paddingLayout(32)
+    ).withName("fuse_args");
+    public static MemoryLayout $LAYOUT() {
+        return fuse_args.$struct$LAYOUT;
+    }
+    static final VarHandle argc$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argc"));
+    public static VarHandle argc$VH() {
+        return fuse_args.argc$VH;
+    }
+    public static int argc$get(MemorySegment seg) {
+        return (int)fuse_args.argc$VH.get(seg);
+    }
+    public static void argc$set( MemorySegment seg, int x) {
+        fuse_args.argc$VH.set(seg, x);
+    }
+    public static int argc$get(MemorySegment seg, long index) {
+        return (int)fuse_args.argc$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argc$set(MemorySegment seg, long index, int x) {
+        fuse_args.argc$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle argv$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("argv"));
+    public static VarHandle argv$VH() {
+        return fuse_args.argv$VH;
+    }
+    public static MemoryAddress argv$get(MemorySegment seg) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg);
+    }
+    public static void argv$set( MemorySegment seg, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg, x);
+    }
+    public static MemoryAddress argv$get(MemorySegment seg, long index) {
+        return (java.lang.foreign.MemoryAddress)fuse_args.argv$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void argv$set(MemorySegment seg, long index, MemoryAddress x) {
+        fuse_args.argv$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle allocated$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("allocated"));
+    public static VarHandle allocated$VH() {
+        return fuse_args.allocated$VH;
+    }
+    public static int allocated$get(MemorySegment seg) {
+        return (int)fuse_args.allocated$VH.get(seg);
+    }
+    public static void allocated$set( MemorySegment seg, int x) {
+        fuse_args.allocated$VH.set(seg, x);
+    }
+    public static int allocated$get(MemorySegment seg, long index) {
+        return (int)fuse_args.allocated$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void allocated$set(MemorySegment seg, long index, int x) {
+        fuse_args.allocated$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_conn_info.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_conn_info.java
new file mode 100644
index 00000000..f10ddfeb
--- /dev/null
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_conn_info.java
@@ -0,0 +1,199 @@
+// Generated by jextract
+
+package org.cryptomator.jfuse.win.amd64.extr;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.VarHandle;
+import java.nio.ByteOrder;
+import java.lang.foreign.*;
+import static java.lang.foreign.ValueLayout.*;
+public class fuse3_conn_info {
+
+    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
+        Constants$root.C_LONG$LAYOUT.withName("proto_major"),
+        Constants$root.C_LONG$LAYOUT.withName("proto_minor"),
+        Constants$root.C_LONG$LAYOUT.withName("max_write"),
+        Constants$root.C_LONG$LAYOUT.withName("max_read"),
+        Constants$root.C_LONG$LAYOUT.withName("max_readahead"),
+        Constants$root.C_LONG$LAYOUT.withName("capable"),
+        Constants$root.C_LONG$LAYOUT.withName("want"),
+        Constants$root.C_LONG$LAYOUT.withName("max_background"),
+        Constants$root.C_LONG$LAYOUT.withName("congestion_threshold"),
+        Constants$root.C_LONG$LAYOUT.withName("time_gran"),
+        MemoryLayout.sequenceLayout(22, Constants$root.C_LONG$LAYOUT).withName("reserved")
+    ).withName("fuse3_conn_info");
+    public static MemoryLayout $LAYOUT() {
+        return fuse3_conn_info.$struct$LAYOUT;
+    }
+    static final VarHandle proto_major$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("proto_major"));
+    public static VarHandle proto_major$VH() {
+        return fuse3_conn_info.proto_major$VH;
+    }
+    public static int proto_major$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.proto_major$VH.get(seg);
+    }
+    public static void proto_major$set( MemorySegment seg, int x) {
+        fuse3_conn_info.proto_major$VH.set(seg, x);
+    }
+    public static int proto_major$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.proto_major$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void proto_major$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.proto_major$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle proto_minor$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("proto_minor"));
+    public static VarHandle proto_minor$VH() {
+        return fuse3_conn_info.proto_minor$VH;
+    }
+    public static int proto_minor$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.proto_minor$VH.get(seg);
+    }
+    public static void proto_minor$set( MemorySegment seg, int x) {
+        fuse3_conn_info.proto_minor$VH.set(seg, x);
+    }
+    public static int proto_minor$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.proto_minor$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void proto_minor$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.proto_minor$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_write$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
+    public static VarHandle max_write$VH() {
+        return fuse3_conn_info.max_write$VH;
+    }
+    public static int max_write$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.max_write$VH.get(seg);
+    }
+    public static void max_write$set( MemorySegment seg, int x) {
+        fuse3_conn_info.max_write$VH.set(seg, x);
+    }
+    public static int max_write$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.max_write$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_write$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.max_write$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_read$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_read"));
+    public static VarHandle max_read$VH() {
+        return fuse3_conn_info.max_read$VH;
+    }
+    public static int max_read$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.max_read$VH.get(seg);
+    }
+    public static void max_read$set( MemorySegment seg, int x) {
+        fuse3_conn_info.max_read$VH.set(seg, x);
+    }
+    public static int max_read$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.max_read$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_read$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.max_read$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_readahead$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
+    public static VarHandle max_readahead$VH() {
+        return fuse3_conn_info.max_readahead$VH;
+    }
+    public static int max_readahead$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.max_readahead$VH.get(seg);
+    }
+    public static void max_readahead$set( MemorySegment seg, int x) {
+        fuse3_conn_info.max_readahead$VH.set(seg, x);
+    }
+    public static int max_readahead$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.max_readahead$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_readahead$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.max_readahead$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle capable$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("capable"));
+    public static VarHandle capable$VH() {
+        return fuse3_conn_info.capable$VH;
+    }
+    public static int capable$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.capable$VH.get(seg);
+    }
+    public static void capable$set( MemorySegment seg, int x) {
+        fuse3_conn_info.capable$VH.set(seg, x);
+    }
+    public static int capable$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.capable$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void capable$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.capable$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle want$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("want"));
+    public static VarHandle want$VH() {
+        return fuse3_conn_info.want$VH;
+    }
+    public static int want$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.want$VH.get(seg);
+    }
+    public static void want$set( MemorySegment seg, int x) {
+        fuse3_conn_info.want$VH.set(seg, x);
+    }
+    public static int want$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.want$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void want$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.want$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle max_background$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_background"));
+    public static VarHandle max_background$VH() {
+        return fuse3_conn_info.max_background$VH;
+    }
+    public static int max_background$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.max_background$VH.get(seg);
+    }
+    public static void max_background$set( MemorySegment seg, int x) {
+        fuse3_conn_info.max_background$VH.set(seg, x);
+    }
+    public static int max_background$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.max_background$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void max_background$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.max_background$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle congestion_threshold$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("congestion_threshold"));
+    public static VarHandle congestion_threshold$VH() {
+        return fuse3_conn_info.congestion_threshold$VH;
+    }
+    public static int congestion_threshold$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.congestion_threshold$VH.get(seg);
+    }
+    public static void congestion_threshold$set( MemorySegment seg, int x) {
+        fuse3_conn_info.congestion_threshold$VH.set(seg, x);
+    }
+    public static int congestion_threshold$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.congestion_threshold$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void congestion_threshold$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.congestion_threshold$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle time_gran$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("time_gran"));
+    public static VarHandle time_gran$VH() {
+        return fuse3_conn_info.time_gran$VH;
+    }
+    public static int time_gran$get(MemorySegment seg) {
+        return (int)fuse3_conn_info.time_gran$VH.get(seg);
+    }
+    public static void time_gran$set( MemorySegment seg, int x) {
+        fuse3_conn_info.time_gran$VH.set(seg, x);
+    }
+    public static int time_gran$get(MemorySegment seg, long index) {
+        return (int)fuse3_conn_info.time_gran$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void time_gran$set(MemorySegment seg, long index, int x) {
+        fuse3_conn_info.time_gran$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    public static MemorySegment reserved$slice(MemorySegment seg) {
+        return seg.asSlice(40, 88);
+    }
+    public static long sizeof() { return $LAYOUT().byteSize(); }
+    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
+    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
+        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
+    }
+    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
+}
+
+
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_file_info.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_file_info.java
similarity index 51%
rename from jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_file_info.java
rename to jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_file_info.java
index 70bc26e6..2a86fd2b 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_file_info.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_file_info.java
@@ -7,104 +7,92 @@
 import java.nio.ByteOrder;
 import java.lang.foreign.*;
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_file_info {
+public class fuse3_file_info {
 
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_LONG$LAYOUT.withName("flags"),
-        Constants$root.C_LONG$LAYOUT.withName("fh_old"),
-        Constants$root.C_LONG$LAYOUT.withName("writepage"),
         MemoryLayout.structLayout(
+            MemoryLayout.paddingLayout(1).withName("writepage"),
             MemoryLayout.paddingLayout(1).withName("direct_io"),
             MemoryLayout.paddingLayout(1).withName("keep_cache"),
             MemoryLayout.paddingLayout(1).withName("flush"),
             MemoryLayout.paddingLayout(1).withName("nonseekable"),
-            MemoryLayout.paddingLayout(28).withName("padding")
+            MemoryLayout.paddingLayout(1).withName("flock_release"),
+            MemoryLayout.paddingLayout(26),
+            MemoryLayout.paddingLayout(27).withName("padding"),
+            MemoryLayout.paddingLayout(37)
         ),
         Constants$root.C_LONG_LONG$LAYOUT.withName("fh"),
-        Constants$root.C_LONG_LONG$LAYOUT.withName("lock_owner")
-    ).withName("fuse_file_info");
+        Constants$root.C_LONG_LONG$LAYOUT.withName("lock_owner"),
+        Constants$root.C_LONG$LAYOUT.withName("poll_events"),
+        MemoryLayout.paddingLayout(32)
+    ).withName("fuse3_file_info");
     public static MemoryLayout $LAYOUT() {
-        return fuse_file_info.$struct$LAYOUT;
+        return fuse3_file_info.$struct$LAYOUT;
     }
     static final VarHandle flags$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("flags"));
     public static VarHandle flags$VH() {
-        return fuse_file_info.flags$VH;
+        return fuse3_file_info.flags$VH;
     }
     public static int flags$get(MemorySegment seg) {
-        return (int)fuse_file_info.flags$VH.get(seg);
+        return (int)fuse3_file_info.flags$VH.get(seg);
     }
     public static void flags$set( MemorySegment seg, int x) {
-        fuse_file_info.flags$VH.set(seg, x);
+        fuse3_file_info.flags$VH.set(seg, x);
     }
     public static int flags$get(MemorySegment seg, long index) {
-        return (int)fuse_file_info.flags$VH.get(seg.asSlice(index*sizeof()));
+        return (int)fuse3_file_info.flags$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void flags$set(MemorySegment seg, long index, int x) {
-        fuse_file_info.flags$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle fh_old$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fh_old"));
-    public static VarHandle fh_old$VH() {
-        return fuse_file_info.fh_old$VH;
-    }
-    public static int fh_old$get(MemorySegment seg) {
-        return (int)fuse_file_info.fh_old$VH.get(seg);
-    }
-    public static void fh_old$set( MemorySegment seg, int x) {
-        fuse_file_info.fh_old$VH.set(seg, x);
-    }
-    public static int fh_old$get(MemorySegment seg, long index) {
-        return (int)fuse_file_info.fh_old$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fh_old$set(MemorySegment seg, long index, int x) {
-        fuse_file_info.fh_old$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle writepage$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("writepage"));
-    public static VarHandle writepage$VH() {
-        return fuse_file_info.writepage$VH;
-    }
-    public static int writepage$get(MemorySegment seg) {
-        return (int)fuse_file_info.writepage$VH.get(seg);
-    }
-    public static void writepage$set( MemorySegment seg, int x) {
-        fuse_file_info.writepage$VH.set(seg, x);
-    }
-    public static int writepage$get(MemorySegment seg, long index) {
-        return (int)fuse_file_info.writepage$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void writepage$set(MemorySegment seg, long index, int x) {
-        fuse_file_info.writepage$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_file_info.flags$VH.set(seg.asSlice(index*sizeof()), x);
     }
     static final VarHandle fh$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fh"));
     public static VarHandle fh$VH() {
-        return fuse_file_info.fh$VH;
+        return fuse3_file_info.fh$VH;
     }
     public static long fh$get(MemorySegment seg) {
-        return (long)fuse_file_info.fh$VH.get(seg);
+        return (long)fuse3_file_info.fh$VH.get(seg);
     }
     public static void fh$set( MemorySegment seg, long x) {
-        fuse_file_info.fh$VH.set(seg, x);
+        fuse3_file_info.fh$VH.set(seg, x);
     }
     public static long fh$get(MemorySegment seg, long index) {
-        return (long)fuse_file_info.fh$VH.get(seg.asSlice(index*sizeof()));
+        return (long)fuse3_file_info.fh$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void fh$set(MemorySegment seg, long index, long x) {
-        fuse_file_info.fh$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_file_info.fh$VH.set(seg.asSlice(index*sizeof()), x);
     }
     static final VarHandle lock_owner$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("lock_owner"));
     public static VarHandle lock_owner$VH() {
-        return fuse_file_info.lock_owner$VH;
+        return fuse3_file_info.lock_owner$VH;
     }
     public static long lock_owner$get(MemorySegment seg) {
-        return (long)fuse_file_info.lock_owner$VH.get(seg);
+        return (long)fuse3_file_info.lock_owner$VH.get(seg);
     }
     public static void lock_owner$set( MemorySegment seg, long x) {
-        fuse_file_info.lock_owner$VH.set(seg, x);
+        fuse3_file_info.lock_owner$VH.set(seg, x);
     }
     public static long lock_owner$get(MemorySegment seg, long index) {
-        return (long)fuse_file_info.lock_owner$VH.get(seg.asSlice(index*sizeof()));
+        return (long)fuse3_file_info.lock_owner$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void lock_owner$set(MemorySegment seg, long index, long x) {
-        fuse_file_info.lock_owner$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_file_info.lock_owner$VH.set(seg.asSlice(index*sizeof()), x);
+    }
+    static final VarHandle poll_events$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("poll_events"));
+    public static VarHandle poll_events$VH() {
+        return fuse3_file_info.poll_events$VH;
+    }
+    public static int poll_events$get(MemorySegment seg) {
+        return (int)fuse3_file_info.poll_events$VH.get(seg);
+    }
+    public static void poll_events$set( MemorySegment seg, int x) {
+        fuse3_file_info.poll_events$VH.set(seg, x);
+    }
+    public static int poll_events$get(MemorySegment seg, long index) {
+        return (int)fuse3_file_info.poll_events$VH.get(seg.asSlice(index*sizeof()));
+    }
+    public static void poll_events$set(MemorySegment seg, long index, int x) {
+        fuse3_file_info.poll_events$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_fill_dir_t.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_fill_dir_t.java
similarity index 55%
rename from jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_fill_dir_t.java
rename to jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_fill_dir_t.java
index 6d4aa71b..45a0540b 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_fill_dir_t.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_fill_dir_t.java
@@ -7,17 +7,17 @@
 import java.nio.ByteOrder;
 import java.lang.foreign.*;
 import static java.lang.foreign.ValueLayout.*;
-public interface fuse_fill_dir_t {
+public interface fuse3_fill_dir_t {
 
-    int apply(java.lang.foreign.MemoryAddress buf, java.lang.foreign.MemoryAddress name, java.lang.foreign.MemoryAddress stbuf, long off);
-    static MemorySegment allocate(fuse_fill_dir_t fi, MemorySession session) {
-        return RuntimeHelper.upcallStub(fuse_fill_dir_t.class, fi, constants$0.fuse_fill_dir_t$FUNC, session);
+    int apply(java.lang.foreign.MemoryAddress buf, java.lang.foreign.MemoryAddress name, java.lang.foreign.MemoryAddress stbuf, long off, int flags);
+    static MemorySegment allocate(fuse3_fill_dir_t fi, MemorySession session) {
+        return RuntimeHelper.upcallStub(fuse3_fill_dir_t.class, fi, constants$0.fuse3_fill_dir_t$FUNC, session);
     }
-    static fuse_fill_dir_t ofAddress(MemoryAddress addr, MemorySession session) {
+    static fuse3_fill_dir_t ofAddress(MemoryAddress addr, MemorySession session) {
         MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-        return (java.lang.foreign.MemoryAddress _buf, java.lang.foreign.MemoryAddress _name, java.lang.foreign.MemoryAddress _stbuf, long _off) -> {
+        return (java.lang.foreign.MemoryAddress _buf, java.lang.foreign.MemoryAddress _name, java.lang.foreign.MemoryAddress _stbuf, long _off, int _flags) -> {
             try {
-                return (int)constants$0.fuse_fill_dir_t$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)_buf, (java.lang.foreign.Addressable)_name, (java.lang.foreign.Addressable)_stbuf, _off);
+                return (int)constants$0.fuse3_fill_dir_t$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)_buf, (java.lang.foreign.Addressable)_name, (java.lang.foreign.Addressable)_stbuf, _off, _flags);
             } catch (Throwable ex$) {
                 throw new AssertionError("should not reach here", ex$);
             }
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_operations.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_operations.java
similarity index 55%
rename from jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_operations.java
rename to jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_operations.java
index 0ae47be8..67910ecb 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_operations.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse3_operations.java
@@ -7,11 +7,10 @@
 import java.nio.ByteOrder;
 import java.lang.foreign.*;
 import static java.lang.foreign.ValueLayout.*;
-public class fuse_operations {
+public class fuse3_operations {
 
     static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
         Constants$root.C_POINTER$LAYOUT.withName("getattr"),
-        Constants$root.C_POINTER$LAYOUT.withName("getdir"),
         Constants$root.C_POINTER$LAYOUT.withName("readlink"),
         Constants$root.C_POINTER$LAYOUT.withName("mknod"),
         Constants$root.C_POINTER$LAYOUT.withName("mkdir"),
@@ -23,7 +22,6 @@ public class fuse_operations {
         Constants$root.C_POINTER$LAYOUT.withName("chmod"),
         Constants$root.C_POINTER$LAYOUT.withName("chown"),
         Constants$root.C_POINTER$LAYOUT.withName("truncate"),
-        Constants$root.C_POINTER$LAYOUT.withName("utime"),
         Constants$root.C_POINTER$LAYOUT.withName("open"),
         Constants$root.C_POINTER$LAYOUT.withName("read"),
         Constants$root.C_POINTER$LAYOUT.withName("write"),
@@ -43,59 +41,38 @@ public class fuse_operations {
         Constants$root.C_POINTER$LAYOUT.withName("destroy"),
         Constants$root.C_POINTER$LAYOUT.withName("access"),
         Constants$root.C_POINTER$LAYOUT.withName("create"),
-        Constants$root.C_POINTER$LAYOUT.withName("ftruncate"),
-        Constants$root.C_POINTER$LAYOUT.withName("fgetattr"),
         Constants$root.C_POINTER$LAYOUT.withName("lock"),
         Constants$root.C_POINTER$LAYOUT.withName("utimens"),
         Constants$root.C_POINTER$LAYOUT.withName("bmap"),
-        MemoryLayout.structLayout(
-            MemoryLayout.paddingLayout(1).withName("flag_nullpath_ok"),
-            MemoryLayout.paddingLayout(1).withName("flag_nopath"),
-            MemoryLayout.paddingLayout(1).withName("flag_utime_omit_ok"),
-            MemoryLayout.paddingLayout(29).withName("flag_reserved"),
-            MemoryLayout.paddingLayout(32)
-        ),
         Constants$root.C_POINTER$LAYOUT.withName("ioctl"),
         Constants$root.C_POINTER$LAYOUT.withName("poll"),
         Constants$root.C_POINTER$LAYOUT.withName("write_buf"),
         Constants$root.C_POINTER$LAYOUT.withName("read_buf"),
         Constants$root.C_POINTER$LAYOUT.withName("flock"),
-        Constants$root.C_POINTER$LAYOUT.withName("fallocate"),
-        Constants$root.C_POINTER$LAYOUT.withName("reserved00"),
-        Constants$root.C_POINTER$LAYOUT.withName("reserved01"),
-        Constants$root.C_POINTER$LAYOUT.withName("reserved02"),
-        Constants$root.C_POINTER$LAYOUT.withName("statfs_x"),
-        Constants$root.C_POINTER$LAYOUT.withName("setvolname"),
-        Constants$root.C_POINTER$LAYOUT.withName("exchange"),
-        Constants$root.C_POINTER$LAYOUT.withName("getxtimes"),
-        Constants$root.C_POINTER$LAYOUT.withName("setbkuptime"),
-        Constants$root.C_POINTER$LAYOUT.withName("setchgtime"),
-        Constants$root.C_POINTER$LAYOUT.withName("setcrtime"),
-        Constants$root.C_POINTER$LAYOUT.withName("chflags"),
-        Constants$root.C_POINTER$LAYOUT.withName("setattr_x"),
-        Constants$root.C_POINTER$LAYOUT.withName("fsetattr_x")
-    ).withName("fuse_operations");
+        Constants$root.C_POINTER$LAYOUT.withName("fallocate")
+    ).withName("fuse3_operations");
     public static MemoryLayout $LAYOUT() {
-        return fuse_operations.$struct$LAYOUT;
+        return fuse3_operations.$struct$LAYOUT;
     }
     static final FunctionDescriptor getattr$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle getattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.getattr$FUNC
+        fuse3_operations.getattr$FUNC
     );
     public interface getattr {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(getattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(getattr.class, fi, fuse_operations.getattr$FUNC, session);
+            return RuntimeHelper.upcallStub(getattr.class, fi, fuse3_operations.getattr$FUNC, session);
         }
         static getattr ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.getattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.getattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -105,87 +82,42 @@ static getattr ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle getattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("getattr"));
     public static VarHandle getattr$VH() {
-        return fuse_operations.getattr$VH;
+        return fuse3_operations.getattr$VH;
     }
     public static MemoryAddress getattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getattr$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.getattr$VH.get(seg);
     }
     public static void getattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.getattr$VH.set(seg, x);
+        fuse3_operations.getattr$VH.set(seg, x);
     }
     public static MemoryAddress getattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getattr$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.getattr$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void getattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.getattr$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.getattr$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static getattr getattr (MemorySegment segment, MemorySession session) {
         return getattr.ofAddress(getattr$get(segment), session);
     }
-    static final FunctionDescriptor getdir$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle getdir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.getdir$FUNC
-    );
-    public interface getdir {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(getdir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(getdir.class, fi, fuse_operations.getdir$FUNC, session);
-        }
-        static getdir ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.getdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle getdir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("getdir"));
-    public static VarHandle getdir$VH() {
-        return fuse_operations.getdir$VH;
-    }
-    public static MemoryAddress getdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getdir$VH.get(seg);
-    }
-    public static void getdir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.getdir$VH.set(seg, x);
-    }
-    public static MemoryAddress getdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getdir$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getdir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.getdir$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getdir getdir (MemorySegment segment, MemorySession session) {
-        return getdir.ofAddress(getdir$get(segment), session);
-    }
     static final FunctionDescriptor readlink$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT
     );
     static final MethodHandle readlink$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.readlink$FUNC
+        fuse3_operations.readlink$FUNC
     );
     public interface readlink {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2);
         static MemorySegment allocate(readlink fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(readlink.class, fi, fuse_operations.readlink$FUNC, session);
+            return RuntimeHelper.upcallStub(readlink.class, fi, fuse3_operations.readlink$FUNC, session);
         }
         static readlink ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2) -> {
                 try {
-                    return (int)fuse_operations.readlink$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
+                    return (int)fuse3_operations.readlink$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -195,19 +127,19 @@ static readlink ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle readlink$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("readlink"));
     public static VarHandle readlink$VH() {
-        return fuse_operations.readlink$VH;
+        return fuse3_operations.readlink$VH;
     }
     public static MemoryAddress readlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.readlink$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.readlink$VH.get(seg);
     }
     public static void readlink$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.readlink$VH.set(seg, x);
+        fuse3_operations.readlink$VH.set(seg, x);
     }
     public static MemoryAddress readlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.readlink$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.readlink$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void readlink$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.readlink$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.readlink$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static readlink readlink (MemorySegment segment, MemorySession session) {
         return readlink.ofAddress(readlink$get(segment), session);
@@ -218,19 +150,19 @@ public static readlink readlink (MemorySegment segment, MemorySession session) {
         Constants$root.C_LONG$LAYOUT
     );
     static final MethodHandle mknod$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.mknod$FUNC
+        fuse3_operations.mknod$FUNC
     );
     public interface mknod {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1, int _x2);
         static MemorySegment allocate(mknod fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(mknod.class, fi, fuse_operations.mknod$FUNC, session);
+            return RuntimeHelper.upcallStub(mknod.class, fi, fuse3_operations.mknod$FUNC, session);
         }
         static mknod ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1, int __x2) -> {
                 try {
-                    return (int)fuse_operations.mknod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2);
+                    return (int)fuse3_operations.mknod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -240,19 +172,19 @@ static mknod ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle mknod$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("mknod"));
     public static VarHandle mknod$VH() {
-        return fuse_operations.mknod$VH;
+        return fuse3_operations.mknod$VH;
     }
     public static MemoryAddress mknod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.mknod$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.mknod$VH.get(seg);
     }
     public static void mknod$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.mknod$VH.set(seg, x);
+        fuse3_operations.mknod$VH.set(seg, x);
     }
     public static MemoryAddress mknod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.mknod$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.mknod$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void mknod$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.mknod$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.mknod$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static mknod mknod (MemorySegment segment, MemorySession session) {
         return mknod.ofAddress(mknod$get(segment), session);
@@ -262,19 +194,19 @@ public static mknod mknod (MemorySegment segment, MemorySession session) {
         Constants$root.C_LONG$LAYOUT
     );
     static final MethodHandle mkdir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.mkdir$FUNC
+        fuse3_operations.mkdir$FUNC
     );
     public interface mkdir {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1);
         static MemorySegment allocate(mkdir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(mkdir.class, fi, fuse_operations.mkdir$FUNC, session);
+            return RuntimeHelper.upcallStub(mkdir.class, fi, fuse3_operations.mkdir$FUNC, session);
         }
         static mkdir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1) -> {
                 try {
-                    return (int)fuse_operations.mkdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse3_operations.mkdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -284,19 +216,19 @@ static mkdir ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle mkdir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("mkdir"));
     public static VarHandle mkdir$VH() {
-        return fuse_operations.mkdir$VH;
+        return fuse3_operations.mkdir$VH;
     }
     public static MemoryAddress mkdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.mkdir$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.mkdir$VH.get(seg);
     }
     public static void mkdir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.mkdir$VH.set(seg, x);
+        fuse3_operations.mkdir$VH.set(seg, x);
     }
     public static MemoryAddress mkdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.mkdir$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.mkdir$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void mkdir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.mkdir$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.mkdir$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static mkdir mkdir (MemorySegment segment, MemorySession session) {
         return mkdir.ofAddress(mkdir$get(segment), session);
@@ -305,19 +237,19 @@ public static mkdir mkdir (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle unlink$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.unlink$FUNC
+        fuse3_operations.unlink$FUNC
     );
     public interface unlink {
 
         int apply(java.lang.foreign.MemoryAddress _x0);
         static MemorySegment allocate(unlink fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(unlink.class, fi, fuse_operations.unlink$FUNC, session);
+            return RuntimeHelper.upcallStub(unlink.class, fi, fuse3_operations.unlink$FUNC, session);
         }
         static unlink ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0) -> {
                 try {
-                    return (int)fuse_operations.unlink$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
+                    return (int)fuse3_operations.unlink$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -327,19 +259,19 @@ static unlink ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle unlink$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("unlink"));
     public static VarHandle unlink$VH() {
-        return fuse_operations.unlink$VH;
+        return fuse3_operations.unlink$VH;
     }
     public static MemoryAddress unlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.unlink$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.unlink$VH.get(seg);
     }
     public static void unlink$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.unlink$VH.set(seg, x);
+        fuse3_operations.unlink$VH.set(seg, x);
     }
     public static MemoryAddress unlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.unlink$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.unlink$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void unlink$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.unlink$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.unlink$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static unlink unlink (MemorySegment segment, MemorySession session) {
         return unlink.ofAddress(unlink$get(segment), session);
@@ -348,19 +280,19 @@ public static unlink unlink (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle rmdir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.rmdir$FUNC
+        fuse3_operations.rmdir$FUNC
     );
     public interface rmdir {
 
         int apply(java.lang.foreign.MemoryAddress _x0);
         static MemorySegment allocate(rmdir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(rmdir.class, fi, fuse_operations.rmdir$FUNC, session);
+            return RuntimeHelper.upcallStub(rmdir.class, fi, fuse3_operations.rmdir$FUNC, session);
         }
         static rmdir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0) -> {
                 try {
-                    return (int)fuse_operations.rmdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
+                    return (int)fuse3_operations.rmdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -370,19 +302,19 @@ static rmdir ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle rmdir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("rmdir"));
     public static VarHandle rmdir$VH() {
-        return fuse_operations.rmdir$VH;
+        return fuse3_operations.rmdir$VH;
     }
     public static MemoryAddress rmdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.rmdir$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.rmdir$VH.get(seg);
     }
     public static void rmdir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.rmdir$VH.set(seg, x);
+        fuse3_operations.rmdir$VH.set(seg, x);
     }
     public static MemoryAddress rmdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.rmdir$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.rmdir$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void rmdir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.rmdir$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.rmdir$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static rmdir rmdir (MemorySegment segment, MemorySession session) {
         return rmdir.ofAddress(rmdir$get(segment), session);
@@ -392,19 +324,19 @@ public static rmdir rmdir (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle symlink$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.symlink$FUNC
+        fuse3_operations.symlink$FUNC
     );
     public interface symlink {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(symlink fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(symlink.class, fi, fuse_operations.symlink$FUNC, session);
+            return RuntimeHelper.upcallStub(symlink.class, fi, fuse3_operations.symlink$FUNC, session);
         }
         static symlink ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.symlink$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.symlink$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -414,41 +346,42 @@ static symlink ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle symlink$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("symlink"));
     public static VarHandle symlink$VH() {
-        return fuse_operations.symlink$VH;
+        return fuse3_operations.symlink$VH;
     }
     public static MemoryAddress symlink$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.symlink$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.symlink$VH.get(seg);
     }
     public static void symlink$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.symlink$VH.set(seg, x);
+        fuse3_operations.symlink$VH.set(seg, x);
     }
     public static MemoryAddress symlink$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.symlink$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.symlink$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void symlink$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.symlink$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.symlink$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static symlink symlink (MemorySegment segment, MemorySession session) {
         return symlink.ofAddress(symlink$get(segment), session);
     }
     static final FunctionDescriptor rename$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG$LAYOUT
     );
     static final MethodHandle rename$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.rename$FUNC
+        fuse3_operations.rename$FUNC
     );
     public interface rename {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, int _x2);
         static MemorySegment allocate(rename fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(rename.class, fi, fuse_operations.rename$FUNC, session);
+            return RuntimeHelper.upcallStub(rename.class, fi, fuse3_operations.rename$FUNC, session);
         }
         static rename ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, int __x2) -> {
                 try {
-                    return (int)fuse_operations.rename$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.rename$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -458,19 +391,19 @@ static rename ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle rename$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("rename"));
     public static VarHandle rename$VH() {
-        return fuse_operations.rename$VH;
+        return fuse3_operations.rename$VH;
     }
     public static MemoryAddress rename$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.rename$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.rename$VH.get(seg);
     }
     public static void rename$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.rename$VH.set(seg, x);
+        fuse3_operations.rename$VH.set(seg, x);
     }
     public static MemoryAddress rename$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.rename$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.rename$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void rename$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.rename$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.rename$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static rename rename (MemorySegment segment, MemorySession session) {
         return rename.ofAddress(rename$get(segment), session);
@@ -480,19 +413,19 @@ public static rename rename (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle link$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.link$FUNC
+        fuse3_operations.link$FUNC
     );
     public interface link {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(link fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(link.class, fi, fuse_operations.link$FUNC, session);
+            return RuntimeHelper.upcallStub(link.class, fi, fuse3_operations.link$FUNC, session);
         }
         static link ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.link$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.link$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -502,41 +435,42 @@ static link ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle link$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("link"));
     public static VarHandle link$VH() {
-        return fuse_operations.link$VH;
+        return fuse3_operations.link$VH;
     }
     public static MemoryAddress link$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.link$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.link$VH.get(seg);
     }
     public static void link$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.link$VH.set(seg, x);
+        fuse3_operations.link$VH.set(seg, x);
     }
     public static MemoryAddress link$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.link$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.link$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void link$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.link$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.link$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static link link (MemorySegment segment, MemorySession session) {
         return link.ofAddress(link$get(segment), session);
     }
     static final FunctionDescriptor chmod$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG$LAYOUT
+        Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle chmod$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.chmod$FUNC
+        fuse3_operations.chmod$FUNC
     );
     public interface chmod {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, int _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(chmod fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(chmod.class, fi, fuse_operations.chmod$FUNC, session);
+            return RuntimeHelper.upcallStub(chmod.class, fi, fuse3_operations.chmod$FUNC, session);
         }
         static chmod ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, int __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, int __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.chmod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse3_operations.chmod$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -546,19 +480,19 @@ static chmod ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle chmod$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("chmod"));
     public static VarHandle chmod$VH() {
-        return fuse_operations.chmod$VH;
+        return fuse3_operations.chmod$VH;
     }
     public static MemoryAddress chmod$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.chmod$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.chmod$VH.get(seg);
     }
     public static void chmod$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.chmod$VH.set(seg, x);
+        fuse3_operations.chmod$VH.set(seg, x);
     }
     public static MemoryAddress chmod$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.chmod$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.chmod$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void chmod$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.chmod$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.chmod$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static chmod chmod (MemorySegment segment, MemorySession session) {
         return chmod.ofAddress(chmod$get(segment), session);
@@ -566,22 +500,23 @@ public static chmod chmod (MemorySegment segment, MemorySession session) {
     static final FunctionDescriptor chown$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_LONG$LAYOUT
+        Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle chown$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.chown$FUNC
+        fuse3_operations.chown$FUNC
     );
     public interface chown {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, int _x2);
+        int apply(java.lang.foreign.MemoryAddress _x0, int _x1, int _x2, java.lang.foreign.MemoryAddress _x3);
         static MemorySegment allocate(chown fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(chown.class, fi, fuse_operations.chown$FUNC, session);
+            return RuntimeHelper.upcallStub(chown.class, fi, fuse3_operations.chown$FUNC, session);
         }
         static chown ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, int __x1, int __x2) -> {
+            return (java.lang.foreign.MemoryAddress __x0, int __x1, int __x2, java.lang.foreign.MemoryAddress __x3) -> {
                 try {
-                    return (int)fuse_operations.chown$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2);
+                    return (int)fuse3_operations.chown$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2, (java.lang.foreign.Addressable)__x3);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -591,41 +526,42 @@ static chown ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle chown$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("chown"));
     public static VarHandle chown$VH() {
-        return fuse_operations.chown$VH;
+        return fuse3_operations.chown$VH;
     }
     public static MemoryAddress chown$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.chown$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.chown$VH.get(seg);
     }
     public static void chown$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.chown$VH.set(seg, x);
+        fuse3_operations.chown$VH.set(seg, x);
     }
     public static MemoryAddress chown$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.chown$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.chown$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void chown$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.chown$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.chown$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static chown chown (MemorySegment segment, MemorySession session) {
         return chown.ofAddress(chown$get(segment), session);
     }
     static final FunctionDescriptor truncate$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT
+        Constants$root.C_LONG_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle truncate$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.truncate$FUNC
+        fuse3_operations.truncate$FUNC
     );
     public interface truncate {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, long _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, long _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(truncate fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(truncate.class, fi, fuse_operations.truncate$FUNC, session);
+            return RuntimeHelper.upcallStub(truncate.class, fi, fuse3_operations.truncate$FUNC, session);
         }
         static truncate ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, long __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, long __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.truncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse3_operations.truncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -635,85 +571,41 @@ static truncate ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle truncate$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("truncate"));
     public static VarHandle truncate$VH() {
-        return fuse_operations.truncate$VH;
+        return fuse3_operations.truncate$VH;
     }
     public static MemoryAddress truncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.truncate$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.truncate$VH.get(seg);
     }
     public static void truncate$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.truncate$VH.set(seg, x);
+        fuse3_operations.truncate$VH.set(seg, x);
     }
     public static MemoryAddress truncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.truncate$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.truncate$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void truncate$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.truncate$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.truncate$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static truncate truncate (MemorySegment segment, MemorySession session) {
         return truncate.ofAddress(truncate$get(segment), session);
     }
-    static final FunctionDescriptor utime$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle utime$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.utime$FUNC
-    );
-    public interface utime {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(utime fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(utime.class, fi, fuse_operations.utime$FUNC, session);
-        }
-        static utime ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.utime$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle utime$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("utime"));
-    public static VarHandle utime$VH() {
-        return fuse_operations.utime$VH;
-    }
-    public static MemoryAddress utime$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utime$VH.get(seg);
-    }
-    public static void utime$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.utime$VH.set(seg, x);
-    }
-    public static MemoryAddress utime$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utime$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void utime$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.utime$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static utime utime (MemorySegment segment, MemorySession session) {
-        return utime.ofAddress(utime$get(segment), session);
-    }
     static final FunctionDescriptor open$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle open$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.open$FUNC
+        fuse3_operations.open$FUNC
     );
     public interface open {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(open fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(open.class, fi, fuse_operations.open$FUNC, session);
+            return RuntimeHelper.upcallStub(open.class, fi, fuse3_operations.open$FUNC, session);
         }
         static open ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.open$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.open$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -723,19 +615,19 @@ static open ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle open$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("open"));
     public static VarHandle open$VH() {
-        return fuse_operations.open$VH;
+        return fuse3_operations.open$VH;
     }
     public static MemoryAddress open$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.open$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.open$VH.get(seg);
     }
     public static void open$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.open$VH.set(seg, x);
+        fuse3_operations.open$VH.set(seg, x);
     }
     public static MemoryAddress open$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.open$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.open$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void open$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.open$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.open$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static open open (MemorySegment segment, MemorySession session) {
         return open.ofAddress(open$get(segment), session);
@@ -748,19 +640,19 @@ public static open open (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle read$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.read$FUNC
+        fuse3_operations.read$FUNC
     );
     public interface read {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2, long _x3, java.lang.foreign.MemoryAddress _x4);
         static MemorySegment allocate(read fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(read.class, fi, fuse_operations.read$FUNC, session);
+            return RuntimeHelper.upcallStub(read.class, fi, fuse3_operations.read$FUNC, session);
         }
         static read ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2, long __x3, java.lang.foreign.MemoryAddress __x4) -> {
                 try {
-                    return (int)fuse_operations.read$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
+                    return (int)fuse3_operations.read$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -770,19 +662,19 @@ static read ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle read$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("read"));
     public static VarHandle read$VH() {
-        return fuse_operations.read$VH;
+        return fuse3_operations.read$VH;
     }
     public static MemoryAddress read$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.read$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.read$VH.get(seg);
     }
     public static void read$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.read$VH.set(seg, x);
+        fuse3_operations.read$VH.set(seg, x);
     }
     public static MemoryAddress read$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.read$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.read$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void read$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.read$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.read$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static read read (MemorySegment segment, MemorySession session) {
         return read.ofAddress(read$get(segment), session);
@@ -795,19 +687,19 @@ public static read read (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle write$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.write$FUNC
+        fuse3_operations.write$FUNC
     );
     public interface write {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2, long _x3, java.lang.foreign.MemoryAddress _x4);
         static MemorySegment allocate(write fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(write.class, fi, fuse_operations.write$FUNC, session);
+            return RuntimeHelper.upcallStub(write.class, fi, fuse3_operations.write$FUNC, session);
         }
         static write ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2, long __x3, java.lang.foreign.MemoryAddress __x4) -> {
                 try {
-                    return (int)fuse_operations.write$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
+                    return (int)fuse3_operations.write$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -817,19 +709,19 @@ static write ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle write$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("write"));
     public static VarHandle write$VH() {
-        return fuse_operations.write$VH;
+        return fuse3_operations.write$VH;
     }
     public static MemoryAddress write$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.write$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.write$VH.get(seg);
     }
     public static void write$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.write$VH.set(seg, x);
+        fuse3_operations.write$VH.set(seg, x);
     }
     public static MemoryAddress write$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.write$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.write$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void write$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.write$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.write$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static write write (MemorySegment segment, MemorySession session) {
         return write.ofAddress(write$get(segment), session);
@@ -839,19 +731,19 @@ public static write write (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle statfs$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.statfs$FUNC
+        fuse3_operations.statfs$FUNC
     );
     public interface statfs {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(statfs fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(statfs.class, fi, fuse_operations.statfs$FUNC, session);
+            return RuntimeHelper.upcallStub(statfs.class, fi, fuse3_operations.statfs$FUNC, session);
         }
         static statfs ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.statfs$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.statfs$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -861,19 +753,19 @@ static statfs ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle statfs$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("statfs"));
     public static VarHandle statfs$VH() {
-        return fuse_operations.statfs$VH;
+        return fuse3_operations.statfs$VH;
     }
     public static MemoryAddress statfs$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.statfs$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.statfs$VH.get(seg);
     }
     public static void statfs$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.statfs$VH.set(seg, x);
+        fuse3_operations.statfs$VH.set(seg, x);
     }
     public static MemoryAddress statfs$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.statfs$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.statfs$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void statfs$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.statfs$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.statfs$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static statfs statfs (MemorySegment segment, MemorySession session) {
         return statfs.ofAddress(statfs$get(segment), session);
@@ -883,19 +775,19 @@ public static statfs statfs (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle flush$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.flush$FUNC
+        fuse3_operations.flush$FUNC
     );
     public interface flush {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(flush fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(flush.class, fi, fuse_operations.flush$FUNC, session);
+            return RuntimeHelper.upcallStub(flush.class, fi, fuse3_operations.flush$FUNC, session);
         }
         static flush ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.flush$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.flush$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -905,19 +797,19 @@ static flush ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle flush$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("flush"));
     public static VarHandle flush$VH() {
-        return fuse_operations.flush$VH;
+        return fuse3_operations.flush$VH;
     }
     public static MemoryAddress flush$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.flush$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.flush$VH.get(seg);
     }
     public static void flush$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.flush$VH.set(seg, x);
+        fuse3_operations.flush$VH.set(seg, x);
     }
     public static MemoryAddress flush$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.flush$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.flush$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void flush$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.flush$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.flush$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static flush flush (MemorySegment segment, MemorySession session) {
         return flush.ofAddress(flush$get(segment), session);
@@ -927,19 +819,19 @@ public static flush flush (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle release$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.release$FUNC
+        fuse3_operations.release$FUNC
     );
     public interface release {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(release fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(release.class, fi, fuse_operations.release$FUNC, session);
+            return RuntimeHelper.upcallStub(release.class, fi, fuse3_operations.release$FUNC, session);
         }
         static release ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.release$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.release$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -949,19 +841,19 @@ static release ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle release$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("release"));
     public static VarHandle release$VH() {
-        return fuse_operations.release$VH;
+        return fuse3_operations.release$VH;
     }
     public static MemoryAddress release$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.release$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.release$VH.get(seg);
     }
     public static void release$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.release$VH.set(seg, x);
+        fuse3_operations.release$VH.set(seg, x);
     }
     public static MemoryAddress release$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.release$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.release$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void release$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.release$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.release$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static release release (MemorySegment segment, MemorySession session) {
         return release.ofAddress(release$get(segment), session);
@@ -972,19 +864,19 @@ public static release release (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle fsync$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.fsync$FUNC
+        fuse3_operations.fsync$FUNC
     );
     public interface fsync {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(fsync fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(fsync.class, fi, fuse_operations.fsync$FUNC, session);
+            return RuntimeHelper.upcallStub(fsync.class, fi, fuse3_operations.fsync$FUNC, session);
         }
         static fsync ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.fsync$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
+                    return (int)fuse3_operations.fsync$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -994,19 +886,19 @@ static fsync ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle fsync$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fsync"));
     public static VarHandle fsync$VH() {
-        return fuse_operations.fsync$VH;
+        return fuse3_operations.fsync$VH;
     }
     public static MemoryAddress fsync$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fsync$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.fsync$VH.get(seg);
     }
     public static void fsync$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.fsync$VH.set(seg, x);
+        fuse3_operations.fsync$VH.set(seg, x);
     }
     public static MemoryAddress fsync$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fsync$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.fsync$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void fsync$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.fsync$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.fsync$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static fsync fsync (MemorySegment segment, MemorySession session) {
         return fsync.ofAddress(fsync$get(segment), session);
@@ -1019,19 +911,19 @@ public static fsync fsync (MemorySegment segment, MemorySession session) {
         Constants$root.C_LONG$LAYOUT
     );
     static final MethodHandle setxattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.setxattr$FUNC
+        fuse3_operations.setxattr$FUNC
     );
     public interface setxattr {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3, int _x4);
         static MemorySegment allocate(setxattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(setxattr.class, fi, fuse_operations.setxattr$FUNC, session);
+            return RuntimeHelper.upcallStub(setxattr.class, fi, fuse3_operations.setxattr$FUNC, session);
         }
         static setxattr ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3, int __x4) -> {
                 try {
-                    return (int)fuse_operations.setxattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, __x4);
+                    return (int)fuse3_operations.setxattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, __x4);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1041,19 +933,19 @@ static setxattr ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle setxattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("setxattr"));
     public static VarHandle setxattr$VH() {
-        return fuse_operations.setxattr$VH;
+        return fuse3_operations.setxattr$VH;
     }
     public static MemoryAddress setxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setxattr$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.setxattr$VH.get(seg);
     }
     public static void setxattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.setxattr$VH.set(seg, x);
+        fuse3_operations.setxattr$VH.set(seg, x);
     }
     public static MemoryAddress setxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setxattr$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.setxattr$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void setxattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.setxattr$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.setxattr$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static setxattr setxattr (MemorySegment segment, MemorySession session) {
         return setxattr.ofAddress(setxattr$get(segment), session);
@@ -1065,19 +957,19 @@ public static setxattr setxattr (MemorySegment segment, MemorySession session) {
         Constants$root.C_LONG_LONG$LAYOUT
     );
     static final MethodHandle getxattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.getxattr$FUNC
+        fuse3_operations.getxattr$FUNC
     );
     public interface getxattr {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3);
         static MemorySegment allocate(getxattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(getxattr.class, fi, fuse_operations.getxattr$FUNC, session);
+            return RuntimeHelper.upcallStub(getxattr.class, fi, fuse3_operations.getxattr$FUNC, session);
         }
         static getxattr ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3) -> {
                 try {
-                    return (int)fuse_operations.getxattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3);
+                    return (int)fuse3_operations.getxattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1087,19 +979,19 @@ static getxattr ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle getxattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("getxattr"));
     public static VarHandle getxattr$VH() {
-        return fuse_operations.getxattr$VH;
+        return fuse3_operations.getxattr$VH;
     }
     public static MemoryAddress getxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getxattr$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.getxattr$VH.get(seg);
     }
     public static void getxattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.getxattr$VH.set(seg, x);
+        fuse3_operations.getxattr$VH.set(seg, x);
     }
     public static MemoryAddress getxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getxattr$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.getxattr$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void getxattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.getxattr$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.getxattr$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static getxattr getxattr (MemorySegment segment, MemorySession session) {
         return getxattr.ofAddress(getxattr$get(segment), session);
@@ -1110,19 +1002,19 @@ public static getxattr getxattr (MemorySegment segment, MemorySession session) {
         Constants$root.C_LONG_LONG$LAYOUT
     );
     static final MethodHandle listxattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.listxattr$FUNC
+        fuse3_operations.listxattr$FUNC
     );
     public interface listxattr {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2);
         static MemorySegment allocate(listxattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(listxattr.class, fi, fuse_operations.listxattr$FUNC, session);
+            return RuntimeHelper.upcallStub(listxattr.class, fi, fuse3_operations.listxattr$FUNC, session);
         }
         static listxattr ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2) -> {
                 try {
-                    return (int)fuse_operations.listxattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
+                    return (int)fuse3_operations.listxattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1132,19 +1024,19 @@ static listxattr ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle listxattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("listxattr"));
     public static VarHandle listxattr$VH() {
-        return fuse_operations.listxattr$VH;
+        return fuse3_operations.listxattr$VH;
     }
     public static MemoryAddress listxattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.listxattr$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.listxattr$VH.get(seg);
     }
     public static void listxattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.listxattr$VH.set(seg, x);
+        fuse3_operations.listxattr$VH.set(seg, x);
     }
     public static MemoryAddress listxattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.listxattr$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.listxattr$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void listxattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.listxattr$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.listxattr$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static listxattr listxattr (MemorySegment segment, MemorySession session) {
         return listxattr.ofAddress(listxattr$get(segment), session);
@@ -1154,19 +1046,19 @@ public static listxattr listxattr (MemorySegment segment, MemorySession session)
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle removexattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.removexattr$FUNC
+        fuse3_operations.removexattr$FUNC
     );
     public interface removexattr {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(removexattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(removexattr.class, fi, fuse_operations.removexattr$FUNC, session);
+            return RuntimeHelper.upcallStub(removexattr.class, fi, fuse3_operations.removexattr$FUNC, session);
         }
         static removexattr ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.removexattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.removexattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1176,19 +1068,19 @@ static removexattr ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle removexattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("removexattr"));
     public static VarHandle removexattr$VH() {
-        return fuse_operations.removexattr$VH;
+        return fuse3_operations.removexattr$VH;
     }
     public static MemoryAddress removexattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.removexattr$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.removexattr$VH.get(seg);
     }
     public static void removexattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.removexattr$VH.set(seg, x);
+        fuse3_operations.removexattr$VH.set(seg, x);
     }
     public static MemoryAddress removexattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.removexattr$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.removexattr$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void removexattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.removexattr$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.removexattr$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static removexattr removexattr (MemorySegment segment, MemorySession session) {
         return removexattr.ofAddress(removexattr$get(segment), session);
@@ -1198,19 +1090,19 @@ public static removexattr removexattr (MemorySegment segment, MemorySession sess
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle opendir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.opendir$FUNC
+        fuse3_operations.opendir$FUNC
     );
     public interface opendir {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(opendir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(opendir.class, fi, fuse_operations.opendir$FUNC, session);
+            return RuntimeHelper.upcallStub(opendir.class, fi, fuse3_operations.opendir$FUNC, session);
         }
         static opendir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.opendir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.opendir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1220,19 +1112,19 @@ static opendir ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle opendir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("opendir"));
     public static VarHandle opendir$VH() {
-        return fuse_operations.opendir$VH;
+        return fuse3_operations.opendir$VH;
     }
     public static MemoryAddress opendir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.opendir$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.opendir$VH.get(seg);
     }
     public static void opendir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.opendir$VH.set(seg, x);
+        fuse3_operations.opendir$VH.set(seg, x);
     }
     public static MemoryAddress opendir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.opendir$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.opendir$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void opendir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.opendir$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.opendir$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static opendir opendir (MemorySegment segment, MemorySession session) {
         return opendir.ofAddress(opendir$get(segment), session);
@@ -1242,22 +1134,23 @@ public static opendir opendir (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_LONG_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
+        Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_LONG$LAYOUT
     );
     static final MethodHandle readdir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.readdir$FUNC
+        fuse3_operations.readdir$FUNC
     );
     public interface readdir {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3, java.lang.foreign.MemoryAddress _x4);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, long _x3, java.lang.foreign.MemoryAddress _x4, int _x5);
         static MemorySegment allocate(readdir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(readdir.class, fi, fuse_operations.readdir$FUNC, session);
+            return RuntimeHelper.upcallStub(readdir.class, fi, fuse3_operations.readdir$FUNC, session);
         }
         static readdir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3, java.lang.foreign.MemoryAddress __x4) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, long __x3, java.lang.foreign.MemoryAddress __x4, int __x5) -> {
                 try {
-                    return (int)fuse_operations.readdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, (java.lang.foreign.Addressable)__x4);
+                    return (int)fuse3_operations.readdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, __x3, (java.lang.foreign.Addressable)__x4, __x5);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1267,19 +1160,19 @@ static readdir ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle readdir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("readdir"));
     public static VarHandle readdir$VH() {
-        return fuse_operations.readdir$VH;
+        return fuse3_operations.readdir$VH;
     }
     public static MemoryAddress readdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.readdir$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.readdir$VH.get(seg);
     }
     public static void readdir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.readdir$VH.set(seg, x);
+        fuse3_operations.readdir$VH.set(seg, x);
     }
     public static MemoryAddress readdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.readdir$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.readdir$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void readdir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.readdir$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.readdir$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static readdir readdir (MemorySegment segment, MemorySession session) {
         return readdir.ofAddress(readdir$get(segment), session);
@@ -1289,19 +1182,19 @@ public static readdir readdir (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle releasedir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.releasedir$FUNC
+        fuse3_operations.releasedir$FUNC
     );
     public interface releasedir {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(releasedir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(releasedir.class, fi, fuse_operations.releasedir$FUNC, session);
+            return RuntimeHelper.upcallStub(releasedir.class, fi, fuse3_operations.releasedir$FUNC, session);
         }
         static releasedir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (int)fuse_operations.releasedir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.releasedir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1311,19 +1204,19 @@ static releasedir ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle releasedir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("releasedir"));
     public static VarHandle releasedir$VH() {
-        return fuse_operations.releasedir$VH;
+        return fuse3_operations.releasedir$VH;
     }
     public static MemoryAddress releasedir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.releasedir$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.releasedir$VH.get(seg);
     }
     public static void releasedir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.releasedir$VH.set(seg, x);
+        fuse3_operations.releasedir$VH.set(seg, x);
     }
     public static MemoryAddress releasedir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.releasedir$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.releasedir$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void releasedir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.releasedir$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.releasedir$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static releasedir releasedir (MemorySegment segment, MemorySession session) {
         return releasedir.ofAddress(releasedir$get(segment), session);
@@ -1334,19 +1227,19 @@ public static releasedir releasedir (MemorySegment segment, MemorySession sessio
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle fsyncdir$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.fsyncdir$FUNC
+        fuse3_operations.fsyncdir$FUNC
     );
     public interface fsyncdir {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(fsyncdir fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(fsyncdir.class, fi, fuse_operations.fsyncdir$FUNC, session);
+            return RuntimeHelper.upcallStub(fsyncdir.class, fi, fuse3_operations.fsyncdir$FUNC, session);
         }
         static fsyncdir ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.fsyncdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
+                    return (int)fuse3_operations.fsyncdir$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1356,40 +1249,41 @@ static fsyncdir ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle fsyncdir$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fsyncdir"));
     public static VarHandle fsyncdir$VH() {
-        return fuse_operations.fsyncdir$VH;
+        return fuse3_operations.fsyncdir$VH;
     }
     public static MemoryAddress fsyncdir$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fsyncdir$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.fsyncdir$VH.get(seg);
     }
     public static void fsyncdir$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.fsyncdir$VH.set(seg, x);
+        fuse3_operations.fsyncdir$VH.set(seg, x);
     }
     public static MemoryAddress fsyncdir$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fsyncdir$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.fsyncdir$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void fsyncdir$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.fsyncdir$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.fsyncdir$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static fsyncdir fsyncdir (MemorySegment segment, MemorySession session) {
         return fsyncdir.ofAddress(fsyncdir$get(segment), session);
     }
     static final FunctionDescriptor init$FUNC = FunctionDescriptor.of(Constants$root.C_POINTER$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle init$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.init$FUNC
+        fuse3_operations.init$FUNC
     );
     public interface init {
 
-        java.lang.foreign.Addressable apply(java.lang.foreign.MemoryAddress _x0);
+        java.lang.foreign.Addressable apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
         static MemorySegment allocate(init fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(init.class, fi, fuse_operations.init$FUNC, session);
+            return RuntimeHelper.upcallStub(init.class, fi, fuse3_operations.init$FUNC, session);
         }
         static init ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
                 try {
-                    return (java.lang.foreign.Addressable)(java.lang.foreign.MemoryAddress)fuse_operations.init$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
+                    return (java.lang.foreign.Addressable)(java.lang.foreign.MemoryAddress)fuse3_operations.init$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1399,19 +1293,19 @@ static init ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle init$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("init"));
     public static VarHandle init$VH() {
-        return fuse_operations.init$VH;
+        return fuse3_operations.init$VH;
     }
     public static MemoryAddress init$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.init$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.init$VH.get(seg);
     }
     public static void init$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.init$VH.set(seg, x);
+        fuse3_operations.init$VH.set(seg, x);
     }
     public static MemoryAddress init$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.init$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.init$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void init$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.init$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.init$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static init init (MemorySegment segment, MemorySession session) {
         return init.ofAddress(init$get(segment), session);
@@ -1420,19 +1314,19 @@ public static init init (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle destroy$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.destroy$FUNC
+        fuse3_operations.destroy$FUNC
     );
     public interface destroy {
 
         void apply(java.lang.foreign.MemoryAddress _x0);
         static MemorySegment allocate(destroy fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(destroy.class, fi, fuse_operations.destroy$FUNC, session);
+            return RuntimeHelper.upcallStub(destroy.class, fi, fuse3_operations.destroy$FUNC, session);
         }
         static destroy ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0) -> {
                 try {
-                    fuse_operations.destroy$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
+                    fuse3_operations.destroy$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1442,19 +1336,19 @@ static destroy ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle destroy$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("destroy"));
     public static VarHandle destroy$VH() {
-        return fuse_operations.destroy$VH;
+        return fuse3_operations.destroy$VH;
     }
     public static MemoryAddress destroy$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.destroy$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.destroy$VH.get(seg);
     }
     public static void destroy$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.destroy$VH.set(seg, x);
+        fuse3_operations.destroy$VH.set(seg, x);
     }
     public static MemoryAddress destroy$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.destroy$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.destroy$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void destroy$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.destroy$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.destroy$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static destroy destroy (MemorySegment segment, MemorySession session) {
         return destroy.ofAddress(destroy$get(segment), session);
@@ -1464,19 +1358,19 @@ public static destroy destroy (MemorySegment segment, MemorySession session) {
         Constants$root.C_LONG$LAYOUT
     );
     static final MethodHandle access$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.access$FUNC
+        fuse3_operations.access$FUNC
     );
     public interface access {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1);
         static MemorySegment allocate(access fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(access.class, fi, fuse_operations.access$FUNC, session);
+            return RuntimeHelper.upcallStub(access.class, fi, fuse3_operations.access$FUNC, session);
         }
         static access ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1) -> {
                 try {
-                    return (int)fuse_operations.access$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
+                    return (int)fuse3_operations.access$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1486,19 +1380,19 @@ static access ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle access$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("access"));
     public static VarHandle access$VH() {
-        return fuse_operations.access$VH;
+        return fuse3_operations.access$VH;
     }
     public static MemoryAddress access$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.access$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.access$VH.get(seg);
     }
     public static void access$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.access$VH.set(seg, x);
+        fuse3_operations.access$VH.set(seg, x);
     }
     public static MemoryAddress access$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.access$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.access$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void access$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.access$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.access$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static access access (MemorySegment segment, MemorySession session) {
         return access.ofAddress(access$get(segment), session);
@@ -1509,19 +1403,19 @@ public static access access (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle create$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.create$FUNC
+        fuse3_operations.create$FUNC
     );
     public interface create {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(create fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(create.class, fi, fuse_operations.create$FUNC, session);
+            return RuntimeHelper.upcallStub(create.class, fi, fuse3_operations.create$FUNC, session);
         }
         static create ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.create$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
+                    return (int)fuse3_operations.create$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1531,113 +1425,23 @@ static create ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle create$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("create"));
     public static VarHandle create$VH() {
-        return fuse_operations.create$VH;
+        return fuse3_operations.create$VH;
     }
     public static MemoryAddress create$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.create$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.create$VH.get(seg);
     }
     public static void create$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.create$VH.set(seg, x);
+        fuse3_operations.create$VH.set(seg, x);
     }
     public static MemoryAddress create$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.create$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.create$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void create$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.create$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.create$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static create create (MemorySegment segment, MemorySession session) {
         return create.ofAddress(create$get(segment), session);
     }
-    static final FunctionDescriptor ftruncate$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle ftruncate$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.ftruncate$FUNC
-    );
-    public interface ftruncate {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, long _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(ftruncate fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(ftruncate.class, fi, fuse_operations.ftruncate$FUNC, session);
-        }
-        static ftruncate ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, long __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.ftruncate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle ftruncate$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("ftruncate"));
-    public static VarHandle ftruncate$VH() {
-        return fuse_operations.ftruncate$VH;
-    }
-    public static MemoryAddress ftruncate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ftruncate$VH.get(seg);
-    }
-    public static void ftruncate$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.ftruncate$VH.set(seg, x);
-    }
-    public static MemoryAddress ftruncate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ftruncate$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void ftruncate$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.ftruncate$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static ftruncate ftruncate (MemorySegment segment, MemorySession session) {
-        return ftruncate.ofAddress(ftruncate$get(segment), session);
-    }
-    static final FunctionDescriptor fgetattr$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle fgetattr$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.fgetattr$FUNC
-    );
-    public interface fgetattr {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(fgetattr fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(fgetattr.class, fi, fuse_operations.fgetattr$FUNC, session);
-        }
-        static fgetattr ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.fgetattr$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle fgetattr$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fgetattr"));
-    public static VarHandle fgetattr$VH() {
-        return fuse_operations.fgetattr$VH;
-    }
-    public static MemoryAddress fgetattr$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fgetattr$VH.get(seg);
-    }
-    public static void fgetattr$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.fgetattr$VH.set(seg, x);
-    }
-    public static MemoryAddress fgetattr$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fgetattr$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fgetattr$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.fgetattr$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fgetattr fgetattr (MemorySegment segment, MemorySession session) {
-        return fgetattr.ofAddress(fgetattr$get(segment), session);
-    }
     static final FunctionDescriptor lock$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
@@ -1645,19 +1449,19 @@ public static fgetattr fgetattr (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle lock$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.lock$FUNC
+        fuse3_operations.lock$FUNC
     );
     public interface lock {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, int _x2, java.lang.foreign.MemoryAddress _x3);
         static MemorySegment allocate(lock fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(lock.class, fi, fuse_operations.lock$FUNC, session);
+            return RuntimeHelper.upcallStub(lock.class, fi, fuse3_operations.lock$FUNC, session);
         }
         static lock ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, int __x2, java.lang.foreign.MemoryAddress __x3) -> {
                 try {
-                    return (int)fuse_operations.lock$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, (java.lang.foreign.Addressable)__x3);
+                    return (int)fuse3_operations.lock$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, (java.lang.foreign.Addressable)__x3);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1667,41 +1471,42 @@ static lock ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle lock$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("lock"));
     public static VarHandle lock$VH() {
-        return fuse_operations.lock$VH;
+        return fuse3_operations.lock$VH;
     }
     public static MemoryAddress lock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.lock$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.lock$VH.get(seg);
     }
     public static void lock$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.lock$VH.set(seg, x);
+        fuse3_operations.lock$VH.set(seg, x);
     }
     public static MemoryAddress lock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.lock$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.lock$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void lock$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.lock$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.lock$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static lock lock (MemorySegment segment, MemorySession session) {
         return lock.ofAddress(lock$get(segment), session);
     }
     static final FunctionDescriptor utimens$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
+        Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT,
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle utimens$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.utimens$FUNC
+        fuse3_operations.utimens$FUNC
     );
     public interface utimens {
 
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
+        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(utimens fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(utimens.class, fi, fuse_operations.utimens$FUNC, session);
+            return RuntimeHelper.upcallStub(utimens.class, fi, fuse3_operations.utimens$FUNC, session);
         }
         static utimens ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
+            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.utimens$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
+                    return (int)fuse3_operations.utimens$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1711,19 +1516,19 @@ static utimens ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle utimens$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("utimens"));
     public static VarHandle utimens$VH() {
-        return fuse_operations.utimens$VH;
+        return fuse3_operations.utimens$VH;
     }
     public static MemoryAddress utimens$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utimens$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.utimens$VH.get(seg);
     }
     public static void utimens$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.utimens$VH.set(seg, x);
+        fuse3_operations.utimens$VH.set(seg, x);
     }
     public static MemoryAddress utimens$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.utimens$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.utimens$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void utimens$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.utimens$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.utimens$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static utimens utimens (MemorySegment segment, MemorySession session) {
         return utimens.ofAddress(utimens$get(segment), session);
@@ -1734,19 +1539,19 @@ public static utimens utimens (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle bmap$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.bmap$FUNC
+        fuse3_operations.bmap$FUNC
     );
     public interface bmap {
 
         int apply(java.lang.foreign.MemoryAddress _x0, long _x1, java.lang.foreign.MemoryAddress _x2);
         static MemorySegment allocate(bmap fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(bmap.class, fi, fuse_operations.bmap$FUNC, session);
+            return RuntimeHelper.upcallStub(bmap.class, fi, fuse3_operations.bmap$FUNC, session);
         }
         static bmap ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, long __x1, java.lang.foreign.MemoryAddress __x2) -> {
                 try {
-                    return (int)fuse_operations.bmap$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
+                    return (int)fuse3_operations.bmap$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1756,19 +1561,19 @@ static bmap ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle bmap$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("bmap"));
     public static VarHandle bmap$VH() {
-        return fuse_operations.bmap$VH;
+        return fuse3_operations.bmap$VH;
     }
     public static MemoryAddress bmap$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.bmap$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.bmap$VH.get(seg);
     }
     public static void bmap$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.bmap$VH.set(seg, x);
+        fuse3_operations.bmap$VH.set(seg, x);
     }
     public static MemoryAddress bmap$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.bmap$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.bmap$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void bmap$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.bmap$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.bmap$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static bmap bmap (MemorySegment segment, MemorySession session) {
         return bmap.ofAddress(bmap$get(segment), session);
@@ -1782,19 +1587,19 @@ public static bmap bmap (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle ioctl$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.ioctl$FUNC
+        fuse3_operations.ioctl$FUNC
     );
     public interface ioctl {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1, java.lang.foreign.MemoryAddress _x2, java.lang.foreign.MemoryAddress _x3, int _x4, java.lang.foreign.MemoryAddress _x5);
         static MemorySegment allocate(ioctl fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(ioctl.class, fi, fuse_operations.ioctl$FUNC, session);
+            return RuntimeHelper.upcallStub(ioctl.class, fi, fuse3_operations.ioctl$FUNC, session);
         }
         static ioctl ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1, java.lang.foreign.MemoryAddress __x2, java.lang.foreign.MemoryAddress __x3, int __x4, java.lang.foreign.MemoryAddress __x5) -> {
                 try {
-                    return (int)fuse_operations.ioctl$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2, (java.lang.foreign.Addressable)__x3, __x4, (java.lang.foreign.Addressable)__x5);
+                    return (int)fuse3_operations.ioctl$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, (java.lang.foreign.Addressable)__x2, (java.lang.foreign.Addressable)__x3, __x4, (java.lang.foreign.Addressable)__x5);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1804,19 +1609,19 @@ static ioctl ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle ioctl$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("ioctl"));
     public static VarHandle ioctl$VH() {
-        return fuse_operations.ioctl$VH;
+        return fuse3_operations.ioctl$VH;
     }
     public static MemoryAddress ioctl$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ioctl$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.ioctl$VH.get(seg);
     }
     public static void ioctl$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.ioctl$VH.set(seg, x);
+        fuse3_operations.ioctl$VH.set(seg, x);
     }
     public static MemoryAddress ioctl$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.ioctl$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.ioctl$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void ioctl$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.ioctl$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.ioctl$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static ioctl ioctl (MemorySegment segment, MemorySession session) {
         return ioctl.ofAddress(ioctl$get(segment), session);
@@ -1828,19 +1633,19 @@ public static ioctl ioctl (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle poll$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.poll$FUNC
+        fuse3_operations.poll$FUNC
     );
     public interface poll {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2, java.lang.foreign.MemoryAddress _x3);
         static MemorySegment allocate(poll fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(poll.class, fi, fuse_operations.poll$FUNC, session);
+            return RuntimeHelper.upcallStub(poll.class, fi, fuse3_operations.poll$FUNC, session);
         }
         static poll ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2, java.lang.foreign.MemoryAddress __x3) -> {
                 try {
-                    return (int)fuse_operations.poll$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, (java.lang.foreign.Addressable)__x3);
+                    return (int)fuse3_operations.poll$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2, (java.lang.foreign.Addressable)__x3);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1850,19 +1655,19 @@ static poll ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle poll$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("poll"));
     public static VarHandle poll$VH() {
-        return fuse_operations.poll$VH;
+        return fuse3_operations.poll$VH;
     }
     public static MemoryAddress poll$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.poll$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.poll$VH.get(seg);
     }
     public static void poll$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.poll$VH.set(seg, x);
+        fuse3_operations.poll$VH.set(seg, x);
     }
     public static MemoryAddress poll$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.poll$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.poll$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void poll$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.poll$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.poll$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static poll poll (MemorySegment segment, MemorySession session) {
         return poll.ofAddress(poll$get(segment), session);
@@ -1874,19 +1679,19 @@ public static poll poll (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle write_buf$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.write_buf$FUNC
+        fuse3_operations.write_buf$FUNC
     );
     public interface write_buf {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2, java.lang.foreign.MemoryAddress _x3);
         static MemorySegment allocate(write_buf fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(write_buf.class, fi, fuse_operations.write_buf$FUNC, session);
+            return RuntimeHelper.upcallStub(write_buf.class, fi, fuse3_operations.write_buf$FUNC, session);
         }
         static write_buf ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2, java.lang.foreign.MemoryAddress __x3) -> {
                 try {
-                    return (int)fuse_operations.write_buf$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, (java.lang.foreign.Addressable)__x3);
+                    return (int)fuse3_operations.write_buf$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, (java.lang.foreign.Addressable)__x3);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1896,19 +1701,19 @@ static write_buf ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle write_buf$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("write_buf"));
     public static VarHandle write_buf$VH() {
-        return fuse_operations.write_buf$VH;
+        return fuse3_operations.write_buf$VH;
     }
     public static MemoryAddress write_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.write_buf$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.write_buf$VH.get(seg);
     }
     public static void write_buf$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.write_buf$VH.set(seg, x);
+        fuse3_operations.write_buf$VH.set(seg, x);
     }
     public static MemoryAddress write_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.write_buf$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.write_buf$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void write_buf$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.write_buf$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.write_buf$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static write_buf write_buf (MemorySegment segment, MemorySession session) {
         return write_buf.ofAddress(write_buf$get(segment), session);
@@ -1921,19 +1726,19 @@ public static write_buf write_buf (MemorySegment segment, MemorySession session)
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle read_buf$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.read_buf$FUNC
+        fuse3_operations.read_buf$FUNC
     );
     public interface read_buf {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, long _x2, long _x3, java.lang.foreign.MemoryAddress _x4);
         static MemorySegment allocate(read_buf fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(read_buf.class, fi, fuse_operations.read_buf$FUNC, session);
+            return RuntimeHelper.upcallStub(read_buf.class, fi, fuse3_operations.read_buf$FUNC, session);
         }
         static read_buf ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, long __x2, long __x3, java.lang.foreign.MemoryAddress __x4) -> {
                 try {
-                    return (int)fuse_operations.read_buf$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
+                    return (int)fuse3_operations.read_buf$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1943,19 +1748,19 @@ static read_buf ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle read_buf$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("read_buf"));
     public static VarHandle read_buf$VH() {
-        return fuse_operations.read_buf$VH;
+        return fuse3_operations.read_buf$VH;
     }
     public static MemoryAddress read_buf$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.read_buf$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.read_buf$VH.get(seg);
     }
     public static void read_buf$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.read_buf$VH.set(seg, x);
+        fuse3_operations.read_buf$VH.set(seg, x);
     }
     public static MemoryAddress read_buf$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.read_buf$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.read_buf$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void read_buf$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.read_buf$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.read_buf$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static read_buf read_buf (MemorySegment segment, MemorySession session) {
         return read_buf.ofAddress(read_buf$get(segment), session);
@@ -1966,19 +1771,19 @@ public static read_buf read_buf (MemorySegment segment, MemorySession session) {
         Constants$root.C_LONG$LAYOUT
     );
     static final MethodHandle flock$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.flock$FUNC
+        fuse3_operations.flock$FUNC
     );
     public interface flock {
 
         int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, int _x2);
         static MemorySegment allocate(flock fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(flock.class, fi, fuse_operations.flock$FUNC, session);
+            return RuntimeHelper.upcallStub(flock.class, fi, fuse3_operations.flock$FUNC, session);
         }
         static flock ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, int __x2) -> {
                 try {
-                    return (int)fuse_operations.flock$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
+                    return (int)fuse3_operations.flock$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -1988,19 +1793,19 @@ static flock ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle flock$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("flock"));
     public static VarHandle flock$VH() {
-        return fuse_operations.flock$VH;
+        return fuse3_operations.flock$VH;
     }
     public static MemoryAddress flock$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.flock$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.flock$VH.get(seg);
     }
     public static void flock$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.flock$VH.set(seg, x);
+        fuse3_operations.flock$VH.set(seg, x);
     }
     public static MemoryAddress flock$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.flock$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.flock$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void flock$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.flock$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.flock$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static flock flock (MemorySegment segment, MemorySession session) {
         return flock.ofAddress(flock$get(segment), session);
@@ -2013,19 +1818,19 @@ public static flock flock (MemorySegment segment, MemorySession session) {
         Constants$root.C_POINTER$LAYOUT
     );
     static final MethodHandle fallocate$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.fallocate$FUNC
+        fuse3_operations.fallocate$FUNC
     );
     public interface fallocate {
 
         int apply(java.lang.foreign.MemoryAddress _x0, int _x1, long _x2, long _x3, java.lang.foreign.MemoryAddress _x4);
         static MemorySegment allocate(fallocate fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(fallocate.class, fi, fuse_operations.fallocate$FUNC, session);
+            return RuntimeHelper.upcallStub(fallocate.class, fi, fuse3_operations.fallocate$FUNC, session);
         }
         static fallocate ofAddress(MemoryAddress addr, MemorySession session) {
             MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
             return (java.lang.foreign.MemoryAddress __x0, int __x1, long __x2, long __x3, java.lang.foreign.MemoryAddress __x4) -> {
                 try {
-                    return (int)fuse_operations.fallocate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
+                    return (int)fuse3_operations.fallocate$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1, __x2, __x3, (java.lang.foreign.Addressable)__x4);
                 } catch (Throwable ex$) {
                     throw new AssertionError("should not reach here", ex$);
                 }
@@ -2035,588 +1840,23 @@ static fallocate ofAddress(MemoryAddress addr, MemorySession session) {
 
     static final VarHandle fallocate$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fallocate"));
     public static VarHandle fallocate$VH() {
-        return fuse_operations.fallocate$VH;
+        return fuse3_operations.fallocate$VH;
     }
     public static MemoryAddress fallocate$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fallocate$VH.get(seg);
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.fallocate$VH.get(seg);
     }
     public static void fallocate$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.fallocate$VH.set(seg, x);
+        fuse3_operations.fallocate$VH.set(seg, x);
     }
     public static MemoryAddress fallocate$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fallocate$VH.get(seg.asSlice(index*sizeof()));
+        return (java.lang.foreign.MemoryAddress)fuse3_operations.fallocate$VH.get(seg.asSlice(index*sizeof()));
     }
     public static void fallocate$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.fallocate$VH.set(seg.asSlice(index*sizeof()), x);
+        fuse3_operations.fallocate$VH.set(seg.asSlice(index*sizeof()), x);
     }
     public static fallocate fallocate (MemorySegment segment, MemorySession session) {
         return fallocate.ofAddress(fallocate$get(segment), session);
     }
-    static final FunctionDescriptor reserved00$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT);
-    static final MethodHandle reserved00$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.reserved00$FUNC
-    );
-    public interface reserved00 {
-
-        int apply();
-        static MemorySegment allocate(reserved00 fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(reserved00.class, fi, fuse_operations.reserved00$FUNC, session);
-        }
-        static reserved00 ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return () -> {
-                try {
-                    return (int)fuse_operations.reserved00$MH.invokeExact((Addressable)symbol);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle reserved00$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("reserved00"));
-    public static VarHandle reserved00$VH() {
-        return fuse_operations.reserved00$VH;
-    }
-    public static MemoryAddress reserved00$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.reserved00$VH.get(seg);
-    }
-    public static void reserved00$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.reserved00$VH.set(seg, x);
-    }
-    public static MemoryAddress reserved00$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.reserved00$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void reserved00$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.reserved00$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static reserved00 reserved00 (MemorySegment segment, MemorySession session) {
-        return reserved00.ofAddress(reserved00$get(segment), session);
-    }
-    static final FunctionDescriptor reserved01$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT);
-    static final MethodHandle reserved01$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.reserved01$FUNC
-    );
-    public interface reserved01 {
-
-        int apply();
-        static MemorySegment allocate(reserved01 fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(reserved01.class, fi, fuse_operations.reserved01$FUNC, session);
-        }
-        static reserved01 ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return () -> {
-                try {
-                    return (int)fuse_operations.reserved01$MH.invokeExact((Addressable)symbol);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle reserved01$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("reserved01"));
-    public static VarHandle reserved01$VH() {
-        return fuse_operations.reserved01$VH;
-    }
-    public static MemoryAddress reserved01$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.reserved01$VH.get(seg);
-    }
-    public static void reserved01$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.reserved01$VH.set(seg, x);
-    }
-    public static MemoryAddress reserved01$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.reserved01$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void reserved01$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.reserved01$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static reserved01 reserved01 (MemorySegment segment, MemorySession session) {
-        return reserved01.ofAddress(reserved01$get(segment), session);
-    }
-    static final FunctionDescriptor reserved02$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT);
-    static final MethodHandle reserved02$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.reserved02$FUNC
-    );
-    public interface reserved02 {
-
-        int apply();
-        static MemorySegment allocate(reserved02 fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(reserved02.class, fi, fuse_operations.reserved02$FUNC, session);
-        }
-        static reserved02 ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return () -> {
-                try {
-                    return (int)fuse_operations.reserved02$MH.invokeExact((Addressable)symbol);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle reserved02$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("reserved02"));
-    public static VarHandle reserved02$VH() {
-        return fuse_operations.reserved02$VH;
-    }
-    public static MemoryAddress reserved02$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.reserved02$VH.get(seg);
-    }
-    public static void reserved02$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.reserved02$VH.set(seg, x);
-    }
-    public static MemoryAddress reserved02$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.reserved02$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void reserved02$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.reserved02$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static reserved02 reserved02 (MemorySegment segment, MemorySession session) {
-        return reserved02.ofAddress(reserved02$get(segment), session);
-    }
-    static final FunctionDescriptor statfs_x$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle statfs_x$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.statfs_x$FUNC
-    );
-    public interface statfs_x {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(statfs_x fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(statfs_x.class, fi, fuse_operations.statfs_x$FUNC, session);
-        }
-        static statfs_x ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.statfs_x$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle statfs_x$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("statfs_x"));
-    public static VarHandle statfs_x$VH() {
-        return fuse_operations.statfs_x$VH;
-    }
-    public static MemoryAddress statfs_x$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.statfs_x$VH.get(seg);
-    }
-    public static void statfs_x$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.statfs_x$VH.set(seg, x);
-    }
-    public static MemoryAddress statfs_x$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.statfs_x$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void statfs_x$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.statfs_x$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static statfs_x statfs_x (MemorySegment segment, MemorySession session) {
-        return statfs_x.ofAddress(statfs_x$get(segment), session);
-    }
-    static final FunctionDescriptor setvolname$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle setvolname$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.setvolname$FUNC
-    );
-    public interface setvolname {
-
-        int apply(java.lang.foreign.MemoryAddress _x0);
-        static MemorySegment allocate(setvolname fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(setvolname.class, fi, fuse_operations.setvolname$FUNC, session);
-        }
-        static setvolname ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0) -> {
-                try {
-                    return (int)fuse_operations.setvolname$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle setvolname$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("setvolname"));
-    public static VarHandle setvolname$VH() {
-        return fuse_operations.setvolname$VH;
-    }
-    public static MemoryAddress setvolname$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setvolname$VH.get(seg);
-    }
-    public static void setvolname$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.setvolname$VH.set(seg, x);
-    }
-    public static MemoryAddress setvolname$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setvolname$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setvolname$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.setvolname$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setvolname setvolname (MemorySegment segment, MemorySession session) {
-        return setvolname.ofAddress(setvolname$get(segment), session);
-    }
-    static final FunctionDescriptor exchange$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG$LAYOUT
-    );
-    static final MethodHandle exchange$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.exchange$FUNC
-    );
-    public interface exchange {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, int _x2);
-        static MemorySegment allocate(exchange fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(exchange.class, fi, fuse_operations.exchange$FUNC, session);
-        }
-        static exchange ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, int __x2) -> {
-                try {
-                    return (int)fuse_operations.exchange$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, __x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle exchange$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("exchange"));
-    public static VarHandle exchange$VH() {
-        return fuse_operations.exchange$VH;
-    }
-    public static MemoryAddress exchange$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.exchange$VH.get(seg);
-    }
-    public static void exchange$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.exchange$VH.set(seg, x);
-    }
-    public static MemoryAddress exchange$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.exchange$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void exchange$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.exchange$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static exchange exchange (MemorySegment segment, MemorySession session) {
-        return exchange.ofAddress(exchange$get(segment), session);
-    }
-    static final FunctionDescriptor getxtimes$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle getxtimes$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.getxtimes$FUNC
-    );
-    public interface getxtimes {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(getxtimes fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(getxtimes.class, fi, fuse_operations.getxtimes$FUNC, session);
-        }
-        static getxtimes ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.getxtimes$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle getxtimes$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("getxtimes"));
-    public static VarHandle getxtimes$VH() {
-        return fuse_operations.getxtimes$VH;
-    }
-    public static MemoryAddress getxtimes$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getxtimes$VH.get(seg);
-    }
-    public static void getxtimes$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.getxtimes$VH.set(seg, x);
-    }
-    public static MemoryAddress getxtimes$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.getxtimes$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void getxtimes$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.getxtimes$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static getxtimes getxtimes (MemorySegment segment, MemorySession session) {
-        return getxtimes.ofAddress(getxtimes$get(segment), session);
-    }
-    static final FunctionDescriptor setbkuptime$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle setbkuptime$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.setbkuptime$FUNC
-    );
-    public interface setbkuptime {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(setbkuptime fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(setbkuptime.class, fi, fuse_operations.setbkuptime$FUNC, session);
-        }
-        static setbkuptime ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.setbkuptime$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle setbkuptime$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("setbkuptime"));
-    public static VarHandle setbkuptime$VH() {
-        return fuse_operations.setbkuptime$VH;
-    }
-    public static MemoryAddress setbkuptime$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setbkuptime$VH.get(seg);
-    }
-    public static void setbkuptime$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.setbkuptime$VH.set(seg, x);
-    }
-    public static MemoryAddress setbkuptime$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setbkuptime$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setbkuptime$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.setbkuptime$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setbkuptime setbkuptime (MemorySegment segment, MemorySession session) {
-        return setbkuptime.ofAddress(setbkuptime$get(segment), session);
-    }
-    static final FunctionDescriptor setchgtime$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle setchgtime$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.setchgtime$FUNC
-    );
-    public interface setchgtime {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(setchgtime fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(setchgtime.class, fi, fuse_operations.setchgtime$FUNC, session);
-        }
-        static setchgtime ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.setchgtime$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle setchgtime$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("setchgtime"));
-    public static VarHandle setchgtime$VH() {
-        return fuse_operations.setchgtime$VH;
-    }
-    public static MemoryAddress setchgtime$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setchgtime$VH.get(seg);
-    }
-    public static void setchgtime$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.setchgtime$VH.set(seg, x);
-    }
-    public static MemoryAddress setchgtime$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setchgtime$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setchgtime$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.setchgtime$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setchgtime setchgtime (MemorySegment segment, MemorySession session) {
-        return setchgtime.ofAddress(setchgtime$get(segment), session);
-    }
-    static final FunctionDescriptor setcrtime$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle setcrtime$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.setcrtime$FUNC
-    );
-    public interface setcrtime {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(setcrtime fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(setcrtime.class, fi, fuse_operations.setcrtime$FUNC, session);
-        }
-        static setcrtime ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.setcrtime$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle setcrtime$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("setcrtime"));
-    public static VarHandle setcrtime$VH() {
-        return fuse_operations.setcrtime$VH;
-    }
-    public static MemoryAddress setcrtime$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setcrtime$VH.get(seg);
-    }
-    public static void setcrtime$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.setcrtime$VH.set(seg, x);
-    }
-    public static MemoryAddress setcrtime$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setcrtime$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setcrtime$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.setcrtime$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setcrtime setcrtime (MemorySegment segment, MemorySession session) {
-        return setcrtime.ofAddress(setcrtime$get(segment), session);
-    }
-    static final FunctionDescriptor chflags$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_LONG$LAYOUT
-    );
-    static final MethodHandle chflags$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.chflags$FUNC
-    );
-    public interface chflags {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, int _x1);
-        static MemorySegment allocate(chflags fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(chflags.class, fi, fuse_operations.chflags$FUNC, session);
-        }
-        static chflags ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, int __x1) -> {
-                try {
-                    return (int)fuse_operations.chflags$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, __x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle chflags$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("chflags"));
-    public static VarHandle chflags$VH() {
-        return fuse_operations.chflags$VH;
-    }
-    public static MemoryAddress chflags$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.chflags$VH.get(seg);
-    }
-    public static void chflags$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.chflags$VH.set(seg, x);
-    }
-    public static MemoryAddress chflags$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.chflags$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void chflags$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.chflags$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static chflags chflags (MemorySegment segment, MemorySession session) {
-        return chflags.ofAddress(chflags$get(segment), session);
-    }
-    static final FunctionDescriptor setattr_x$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle setattr_x$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.setattr_x$FUNC
-    );
-    public interface setattr_x {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1);
-        static MemorySegment allocate(setattr_x fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(setattr_x.class, fi, fuse_operations.setattr_x$FUNC, session);
-        }
-        static setattr_x ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1) -> {
-                try {
-                    return (int)fuse_operations.setattr_x$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle setattr_x$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("setattr_x"));
-    public static VarHandle setattr_x$VH() {
-        return fuse_operations.setattr_x$VH;
-    }
-    public static MemoryAddress setattr_x$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setattr_x$VH.get(seg);
-    }
-    public static void setattr_x$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.setattr_x$VH.set(seg, x);
-    }
-    public static MemoryAddress setattr_x$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.setattr_x$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void setattr_x$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.setattr_x$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static setattr_x setattr_x (MemorySegment segment, MemorySession session) {
-        return setattr_x.ofAddress(setattr_x$get(segment), session);
-    }
-    static final FunctionDescriptor fsetattr_x$FUNC = FunctionDescriptor.of(Constants$root.C_LONG$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT,
-        Constants$root.C_POINTER$LAYOUT
-    );
-    static final MethodHandle fsetattr_x$MH = RuntimeHelper.downcallHandle(
-        fuse_operations.fsetattr_x$FUNC
-    );
-    public interface fsetattr_x {
-
-        int apply(java.lang.foreign.MemoryAddress _x0, java.lang.foreign.MemoryAddress _x1, java.lang.foreign.MemoryAddress _x2);
-        static MemorySegment allocate(fsetattr_x fi, MemorySession session) {
-            return RuntimeHelper.upcallStub(fsetattr_x.class, fi, fuse_operations.fsetattr_x$FUNC, session);
-        }
-        static fsetattr_x ofAddress(MemoryAddress addr, MemorySession session) {
-            MemorySegment symbol = MemorySegment.ofAddress(addr, 0, session);
-            return (java.lang.foreign.MemoryAddress __x0, java.lang.foreign.MemoryAddress __x1, java.lang.foreign.MemoryAddress __x2) -> {
-                try {
-                    return (int)fuse_operations.fsetattr_x$MH.invokeExact((Addressable)symbol, (java.lang.foreign.Addressable)__x0, (java.lang.foreign.Addressable)__x1, (java.lang.foreign.Addressable)__x2);
-                } catch (Throwable ex$) {
-                    throw new AssertionError("should not reach here", ex$);
-                }
-            };
-        }
-    }
-
-    static final VarHandle fsetattr_x$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fsetattr_x"));
-    public static VarHandle fsetattr_x$VH() {
-        return fuse_operations.fsetattr_x$VH;
-    }
-    public static MemoryAddress fsetattr_x$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fsetattr_x$VH.get(seg);
-    }
-    public static void fsetattr_x$set( MemorySegment seg, MemoryAddress x) {
-        fuse_operations.fsetattr_x$VH.set(seg, x);
-    }
-    public static MemoryAddress fsetattr_x$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_operations.fsetattr_x$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fsetattr_x$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_operations.fsetattr_x$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static fsetattr_x fsetattr_x (MemorySegment segment, MemorySession session) {
-        return fsetattr_x.ofAddress(fsetattr_x$get(segment), session);
-    }
     public static long sizeof() { return $LAYOUT().byteSize(); }
     public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
     public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_conn_info.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_conn_info.java
deleted file mode 100644
index 99110f5e..00000000
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_conn_info.java
+++ /dev/null
@@ -1,148 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.amd64.extr;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-public class fuse_conn_info {
-
-    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
-        Constants$root.C_LONG$LAYOUT.withName("proto_major"),
-        Constants$root.C_LONG$LAYOUT.withName("proto_minor"),
-        Constants$root.C_LONG$LAYOUT.withName("async_read"),
-        Constants$root.C_LONG$LAYOUT.withName("max_write"),
-        Constants$root.C_LONG$LAYOUT.withName("max_readahead"),
-        Constants$root.C_LONG$LAYOUT.withName("capable"),
-        Constants$root.C_LONG$LAYOUT.withName("want"),
-        MemoryLayout.sequenceLayout(25, Constants$root.C_LONG$LAYOUT).withName("reserved")
-    ).withName("fuse_conn_info");
-    public static MemoryLayout $LAYOUT() {
-        return fuse_conn_info.$struct$LAYOUT;
-    }
-    static final VarHandle proto_major$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("proto_major"));
-    public static VarHandle proto_major$VH() {
-        return fuse_conn_info.proto_major$VH;
-    }
-    public static int proto_major$get(MemorySegment seg) {
-        return (int)fuse_conn_info.proto_major$VH.get(seg);
-    }
-    public static void proto_major$set( MemorySegment seg, int x) {
-        fuse_conn_info.proto_major$VH.set(seg, x);
-    }
-    public static int proto_major$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.proto_major$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void proto_major$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.proto_major$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle proto_minor$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("proto_minor"));
-    public static VarHandle proto_minor$VH() {
-        return fuse_conn_info.proto_minor$VH;
-    }
-    public static int proto_minor$get(MemorySegment seg) {
-        return (int)fuse_conn_info.proto_minor$VH.get(seg);
-    }
-    public static void proto_minor$set( MemorySegment seg, int x) {
-        fuse_conn_info.proto_minor$VH.set(seg, x);
-    }
-    public static int proto_minor$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.proto_minor$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void proto_minor$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.proto_minor$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle async_read$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("async_read"));
-    public static VarHandle async_read$VH() {
-        return fuse_conn_info.async_read$VH;
-    }
-    public static int async_read$get(MemorySegment seg) {
-        return (int)fuse_conn_info.async_read$VH.get(seg);
-    }
-    public static void async_read$set( MemorySegment seg, int x) {
-        fuse_conn_info.async_read$VH.set(seg, x);
-    }
-    public static int async_read$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.async_read$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void async_read$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.async_read$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle max_write$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_write"));
-    public static VarHandle max_write$VH() {
-        return fuse_conn_info.max_write$VH;
-    }
-    public static int max_write$get(MemorySegment seg) {
-        return (int)fuse_conn_info.max_write$VH.get(seg);
-    }
-    public static void max_write$set( MemorySegment seg, int x) {
-        fuse_conn_info.max_write$VH.set(seg, x);
-    }
-    public static int max_write$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.max_write$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void max_write$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.max_write$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle max_readahead$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("max_readahead"));
-    public static VarHandle max_readahead$VH() {
-        return fuse_conn_info.max_readahead$VH;
-    }
-    public static int max_readahead$get(MemorySegment seg) {
-        return (int)fuse_conn_info.max_readahead$VH.get(seg);
-    }
-    public static void max_readahead$set( MemorySegment seg, int x) {
-        fuse_conn_info.max_readahead$VH.set(seg, x);
-    }
-    public static int max_readahead$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.max_readahead$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void max_readahead$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.max_readahead$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle capable$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("capable"));
-    public static VarHandle capable$VH() {
-        return fuse_conn_info.capable$VH;
-    }
-    public static int capable$get(MemorySegment seg) {
-        return (int)fuse_conn_info.capable$VH.get(seg);
-    }
-    public static void capable$set( MemorySegment seg, int x) {
-        fuse_conn_info.capable$VH.set(seg, x);
-    }
-    public static int capable$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.capable$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void capable$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.capable$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle want$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("want"));
-    public static VarHandle want$VH() {
-        return fuse_conn_info.want$VH;
-    }
-    public static int want$get(MemorySegment seg) {
-        return (int)fuse_conn_info.want$VH.get(seg);
-    }
-    public static void want$set( MemorySegment seg, int x) {
-        fuse_conn_info.want$VH.set(seg, x);
-    }
-    public static int want$get(MemorySegment seg, long index) {
-        return (int)fuse_conn_info.want$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void want$set(MemorySegment seg, long index, int x) {
-        fuse_conn_info.want$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static MemorySegment reserved$slice(MemorySegment seg) {
-        return seg.asSlice(28, 100);
-    }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
-    }
-    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
-}
-
-
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_context.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_context.java
deleted file mode 100644
index 4ceae473..00000000
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_context.java
+++ /dev/null
@@ -1,129 +0,0 @@
-// Generated by jextract
-
-package org.cryptomator.jfuse.win.amd64.extr;
-
-import java.lang.invoke.MethodHandle;
-import java.lang.invoke.VarHandle;
-import java.nio.ByteOrder;
-import java.lang.foreign.*;
-import static java.lang.foreign.ValueLayout.*;
-public class fuse_context {
-
-    static final  GroupLayout $struct$LAYOUT = MemoryLayout.structLayout(
-        Constants$root.C_POINTER$LAYOUT.withName("fuse"),
-        Constants$root.C_LONG$LAYOUT.withName("uid"),
-        Constants$root.C_LONG$LAYOUT.withName("gid"),
-        Constants$root.C_LONG$LAYOUT.withName("pid"),
-        MemoryLayout.paddingLayout(32),
-        Constants$root.C_POINTER$LAYOUT.withName("private_data"),
-        Constants$root.C_LONG$LAYOUT.withName("umask"),
-        MemoryLayout.paddingLayout(32)
-    ).withName("fuse_context");
-    public static MemoryLayout $LAYOUT() {
-        return fuse_context.$struct$LAYOUT;
-    }
-    static final VarHandle fuse$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("fuse"));
-    public static VarHandle fuse$VH() {
-        return fuse_context.fuse$VH;
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg);
-    }
-    public static void fuse$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg, x);
-    }
-    public static MemoryAddress fuse$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.fuse$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void fuse$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.fuse$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle uid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("uid"));
-    public static VarHandle uid$VH() {
-        return fuse_context.uid$VH;
-    }
-    public static int uid$get(MemorySegment seg) {
-        return (int)fuse_context.uid$VH.get(seg);
-    }
-    public static void uid$set( MemorySegment seg, int x) {
-        fuse_context.uid$VH.set(seg, x);
-    }
-    public static int uid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.uid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void uid$set(MemorySegment seg, long index, int x) {
-        fuse_context.uid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle gid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("gid"));
-    public static VarHandle gid$VH() {
-        return fuse_context.gid$VH;
-    }
-    public static int gid$get(MemorySegment seg) {
-        return (int)fuse_context.gid$VH.get(seg);
-    }
-    public static void gid$set( MemorySegment seg, int x) {
-        fuse_context.gid$VH.set(seg, x);
-    }
-    public static int gid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.gid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void gid$set(MemorySegment seg, long index, int x) {
-        fuse_context.gid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle pid$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("pid"));
-    public static VarHandle pid$VH() {
-        return fuse_context.pid$VH;
-    }
-    public static int pid$get(MemorySegment seg) {
-        return (int)fuse_context.pid$VH.get(seg);
-    }
-    public static void pid$set( MemorySegment seg, int x) {
-        fuse_context.pid$VH.set(seg, x);
-    }
-    public static int pid$get(MemorySegment seg, long index) {
-        return (int)fuse_context.pid$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void pid$set(MemorySegment seg, long index, int x) {
-        fuse_context.pid$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle private_data$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("private_data"));
-    public static VarHandle private_data$VH() {
-        return fuse_context.private_data$VH;
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg);
-    }
-    public static void private_data$set( MemorySegment seg, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg, x);
-    }
-    public static MemoryAddress private_data$get(MemorySegment seg, long index) {
-        return (java.lang.foreign.MemoryAddress)fuse_context.private_data$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void private_data$set(MemorySegment seg, long index, MemoryAddress x) {
-        fuse_context.private_data$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    static final VarHandle umask$VH = $struct$LAYOUT.varHandle(MemoryLayout.PathElement.groupElement("umask"));
-    public static VarHandle umask$VH() {
-        return fuse_context.umask$VH;
-    }
-    public static int umask$get(MemorySegment seg) {
-        return (int)fuse_context.umask$VH.get(seg);
-    }
-    public static void umask$set( MemorySegment seg, int x) {
-        fuse_context.umask$VH.set(seg, x);
-    }
-    public static int umask$get(MemorySegment seg, long index) {
-        return (int)fuse_context.umask$VH.get(seg.asSlice(index*sizeof()));
-    }
-    public static void umask$set(MemorySegment seg, long index, int x) {
-        fuse_context.umask$VH.set(seg.asSlice(index*sizeof()), x);
-    }
-    public static long sizeof() { return $LAYOUT().byteSize(); }
-    public static MemorySegment allocate(SegmentAllocator allocator) { return allocator.allocate($LAYOUT()); }
-    public static MemorySegment allocateArray(int len, SegmentAllocator allocator) {
-        return allocator.allocate(MemoryLayout.sequenceLayout(len, $LAYOUT()));
-    }
-    public static MemorySegment ofAddress(MemoryAddress addr, MemorySession session) { return RuntimeHelper.asArray(addr, $LAYOUT(), 1, session); }
-}
-
-
diff --git a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_h.java b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_h.java
index 29484497..a55dfb51 100644
--- a/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_h.java
+++ b/jfuse-win-amd64/src/main/java/org/cryptomator/jfuse/win/amd64/extr/fuse_h.java
@@ -18,35 +18,101 @@ public class fuse_h  {
     public static OfFloat C_FLOAT = Constants$root.C_FLOAT$LAYOUT;
     public static OfDouble C_DOUBLE = Constants$root.C_DOUBLE$LAYOUT;
     public static OfAddress C_POINTER = Constants$root.C_POINTER$LAYOUT;
-    public static MethodHandle fuse_main_real$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_main_real$MH,"fuse_main_real");
+    public static MethodHandle fuse3_lib_help$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse3_lib_help$MH,"fuse3_lib_help");
     }
-    public static int fuse_main_real ( int argc,  Addressable argv,  Addressable ops,  long opsize,  Addressable data) {
-        var mh$ = fuse_main_real$MH();
+    public static void fuse3_lib_help ( Addressable args) {
+        var mh$ = fuse3_lib_help$MH();
         try {
-            return (int)mh$.invokeExact(argc, argv, ops, opsize, data);
+            mh$.invokeExact(args);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_exit$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_exit$MH,"fuse_exit");
+    public static MethodHandle fuse3_new$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse3_new$MH,"fuse3_new");
     }
-    public static void fuse_exit ( Addressable f) {
-        var mh$ = fuse_exit$MH();
+    public static MemoryAddress fuse3_new ( Addressable args,  Addressable ops,  long opsize,  Addressable data) {
+        var mh$ = fuse3_new$MH();
+        try {
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(args, ops, opsize, data);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse3_destroy$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse3_destroy$MH,"fuse3_destroy");
+    }
+    public static void fuse3_destroy ( Addressable f) {
+        var mh$ = fuse3_destroy$MH();
+        try {
+            mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse3_mount$MH() {
+        return RuntimeHelper.requireNonNull(constants$0.fuse3_mount$MH,"fuse3_mount");
+    }
+    public static int fuse3_mount ( Addressable f,  Addressable mountpoint) {
+        var mh$ = fuse3_mount$MH();
+        try {
+            return (int)mh$.invokeExact(f, mountpoint);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse3_unmount$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse3_unmount$MH,"fuse3_unmount");
+    }
+    public static void fuse3_unmount ( Addressable f) {
+        var mh$ = fuse3_unmount$MH();
+        try {
+            mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse3_loop$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse3_loop$MH,"fuse3_loop");
+    }
+    public static int fuse3_loop ( Addressable f) {
+        var mh$ = fuse3_loop$MH();
+        try {
+            return (int)mh$.invokeExact(f);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse3_loop_mt_31$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse3_loop_mt_31$MH,"fuse3_loop_mt_31");
+    }
+    public static int fuse3_loop_mt_31 ( Addressable f,  int clone_fd) {
+        var mh$ = fuse3_loop_mt_31$MH();
+        try {
+            return (int)mh$.invokeExact(f, clone_fd);
+        } catch (Throwable ex$) {
+            throw new AssertionError("should not reach here", ex$);
+        }
+    }
+    public static MethodHandle fuse3_exit$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse3_exit$MH,"fuse3_exit");
+    }
+    public static void fuse3_exit ( Addressable f) {
+        var mh$ = fuse3_exit$MH();
         try {
             mh$.invokeExact(f);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
     }
-    public static MethodHandle fuse_get_context$MH() {
-        return RuntimeHelper.requireNonNull(constants$0.fuse_get_context$MH,"fuse_get_context");
+    public static MethodHandle fuse3_get_session$MH() {
+        return RuntimeHelper.requireNonNull(constants$1.fuse3_get_session$MH,"fuse3_get_session");
     }
-    public static MemoryAddress fuse_get_context () {
-        var mh$ = fuse_get_context$MH();
+    public static MemoryAddress fuse3_get_session ( Addressable f) {
+        var mh$ = fuse3_get_session$MH();
         try {
-            return (java.lang.foreign.MemoryAddress)mh$.invokeExact();
+            return (java.lang.foreign.MemoryAddress)mh$.invokeExact(f);
         } catch (Throwable ex$) {
             throw new AssertionError("should not reach here", ex$);
         }
diff --git a/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FileInfoImplTest.java b/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FileInfoImplTest.java
index 63fdbd30..547bc92d 100644
--- a/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FileInfoImplTest.java
+++ b/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FileInfoImplTest.java
@@ -1,7 +1,7 @@
 package org.cryptomator.jfuse.win.amd64;
 
 import org.cryptomator.jfuse.win.amd64.extr.fcntl_h;
-import org.cryptomator.jfuse.win.amd64.extr.fuse_file_info;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_file_info;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -21,8 +21,8 @@ public class FileInfoImplTest {
 	@DisplayName("test getOpenFlags()")
 	public void testGetOpenFlags(int flags, Set<OpenOption> expectedResult) {
 		try (var scope = MemorySession.openConfined()) {
-			var fi = new FileInfoImpl(fuse_file_info.allocate(scope));
-			fuse_file_info.flags$set(fi.segment(), flags);
+			var fi = new FileInfoImpl(fuse3_file_info.allocate(scope));
+			fuse3_file_info.flags$set(fi.segment(), flags);
 
 			var result = fi.getOpenFlags();
 
diff --git a/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FuseConnInfoImplTest.java b/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FuseConnInfoImplTest.java
new file mode 100644
index 00000000..d37be619
--- /dev/null
+++ b/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FuseConnInfoImplTest.java
@@ -0,0 +1,83 @@
+package org.cryptomator.jfuse.win.amd64;
+
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_conn_info;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Named;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+public class FuseConnInfoImplTest {
+
+	@DisplayName("test getters")
+	@ParameterizedTest(name = "{1}")
+	@MethodSource
+	public void testGetters(SetInMemorySegment setter, GetInConnInfo getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse3_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(segment, 42);
+
+			Assertions.assertEquals(42, getter.apply(connInfo));
+		}
+	}
+
+	public static Stream<Arguments> testGetters() {
+		return Stream.of(
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::proto_major$set, Named.of("protoMajor()", (GetInConnInfo) FuseConnInfo::protoMajor)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::proto_minor$set, Named.of("protoMinor()", (GetInConnInfo) FuseConnInfo::protoMinor)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::capable$set, Named.of("capable()", (GetInConnInfo) FuseConnInfo::capable)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_write$set, Named.of("maxWrite()", (GetInConnInfo) FuseConnInfo::maxWrite)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_read$set, Named.of("maxRead()", (GetInConnInfo) FuseConnInfo::maxRead)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_readahead$set, Named.of("maxReadahead()", (GetInConnInfo) FuseConnInfo::maxReadahead)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::max_background$set, Named.of("maxBackground()", (GetInConnInfo) FuseConnInfo::maxBackground)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::congestion_threshold$set, Named.of("congestionThreshold()", (GetInConnInfo) FuseConnInfo::congestionThreshold)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::time_gran$set, Named.of("timeGran()", (GetInConnInfo) FuseConnInfo::timeGran)),
+				Arguments.arguments((SetInMemorySegment) fuse3_conn_info::want$set, Named.of("want()", (GetInConnInfo) FuseConnInfo::want))
+		);
+	}
+
+	private interface SetInMemorySegment extends BiConsumer<MemorySegment, Integer> {}
+
+	private interface GetInConnInfo extends Function<FuseConnInfo, Integer> {}
+
+	@DisplayName("test setters")
+	@ParameterizedTest(name = "{0}")
+	@MethodSource
+	public void testSetters(SetInConnInfo setter, GetInMemorySegment getter) {
+		try (var scope = MemorySession.openConfined()) {
+			var segment = fuse3_conn_info.allocate(scope);
+			var connInfo = new FuseConnInfoImpl(segment.address(), scope);
+
+			setter.accept(connInfo, 42);
+
+			Assertions.assertEquals(42, getter.apply(segment));
+		}
+	}
+
+	public static Stream<Arguments> testSetters() {
+		return Stream.of(
+				Arguments.arguments(Named.of("setWant()", (SetInConnInfo) FuseConnInfo::setWant), (GetInMemorySegment) fuse3_conn_info::want$get),
+				Arguments.arguments(Named.of("setMaxWrite()", (SetInConnInfo) FuseConnInfo::setMaxWrite), (GetInMemorySegment) fuse3_conn_info::max_write$get),
+				Arguments.arguments(Named.of("setMaxRead()", (SetInConnInfo) FuseConnInfo::setMaxRead), (GetInMemorySegment) fuse3_conn_info::max_read$get),
+				Arguments.arguments(Named.of("setMaxReadahead()", (SetInConnInfo) FuseConnInfo::setMaxReadahead), (GetInMemorySegment) fuse3_conn_info::max_readahead$get),
+				Arguments.arguments(Named.of("setMaxBackground()", (SetInConnInfo) FuseConnInfo::setMaxBackground), (GetInMemorySegment) fuse3_conn_info::max_background$get),
+				Arguments.arguments(Named.of("setCongestionThreshold()", (SetInConnInfo) FuseConnInfo::setCongestionThreshold), (GetInMemorySegment) fuse3_conn_info::congestion_threshold$get),
+				Arguments.arguments(Named.of("setTimeGran()", (SetInConnInfo) FuseConnInfo::setTimeGran), (GetInMemorySegment) fuse3_conn_info::time_gran$get)
+		);
+	}
+
+	private interface SetInConnInfo extends BiConsumer<FuseConnInfo, Integer> {}
+
+	private interface GetInMemorySegment extends Function<MemorySegment, Integer> {}
+
+}
\ No newline at end of file
diff --git a/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FuseImplTest.java b/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FuseImplTest.java
new file mode 100644
index 00000000..fad54afc
--- /dev/null
+++ b/jfuse-win-amd64/src/test/java/org/cryptomator/jfuse/win/amd64/FuseImplTest.java
@@ -0,0 +1,275 @@
+package org.cryptomator.jfuse.win.amd64;
+
+import org.cryptomator.jfuse.api.FileInfo;
+import org.cryptomator.jfuse.api.FuseConnInfo;
+import org.cryptomator.jfuse.api.FuseMount;
+import org.cryptomator.jfuse.api.FuseOperations;
+import org.cryptomator.jfuse.api.MountFailedException;
+import org.cryptomator.jfuse.win.amd64.extr.fuse2.fuse2_h;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_conn_info;
+import org.cryptomator.jfuse.win.amd64.extr.fuse3_file_info;
+import org.cryptomator.jfuse.win.amd64.extr.fuse_h;
+import org.cryptomator.jfuse.win.amd64.extr.fuse_stat;
+import org.cryptomator.jfuse.win.amd64.extr.fuse_timespec;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.mockito.ArgumentMatcher;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.lang.foreign.MemoryAddress;
+import java.lang.foreign.MemorySegment;
+import java.lang.foreign.MemorySession;
+import java.lang.foreign.ValueLayout;
+import java.nio.file.FileSystem;
+import java.nio.file.NoSuchFileException;
+import java.nio.file.Path;
+import java.nio.file.attribute.BasicFileAttributeView;
+import java.nio.file.spi.FileSystemProvider;
+import java.time.Duration;
+import java.time.Instant;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static java.lang.foreign.ValueLayout.JAVA_INT;
+
+public class FuseImplTest {
+
+	private FuseOperations fuseOps = Mockito.mock(FuseOperations.class);
+	private FuseImpl fuseImpl;
+
+	@BeforeEach
+	public void setup() {
+		// required to mock protected methods:
+		class MockableFuseImpl extends FuseImpl {
+			public MockableFuseImpl(FuseOperations fuseOperations) {
+				super(fuseOperations);
+			}
+		}
+
+		this.fuseImpl = new MockableFuseImpl(fuseOps);
+	}
+
+	@Nested
+	@DisplayName("mount()")
+	public class Mount {
+
+		private List<String> args = List.of("foo", "bar");
+		private FuseImpl fuseImplSpy;
+		private MockedStatic<fuse_h> fuseH;
+
+		@BeforeEach
+		public void setup() {
+			fuseImplSpy = Mockito.spy(fuseImpl);
+			Mockito.doReturn(Mockito.mock(FuseArgs.class)).when(fuseImplSpy).parseArgs(args);
+			fuseH = Mockito.mockStatic(fuse_h.class);
+		}
+
+		@AfterEach
+		public void teardown() {
+			fuseH.close();
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_new fails")
+		public void testFuseNewFails() {
+			fuseH.when(() -> fuse_h.fuse3_new(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any())).thenReturn(MemoryAddress.NULL);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			fuseH.verify(() -> fuse_h.fuse3_mount(Mockito.any(), Mockito.any()), Mockito.never());
+			Assertions.assertEquals("fuse_new failed", thrown.getMessage());
+		}
+
+		@Test
+		@DisplayName("MountFailedException when fuse_mount fails")
+		public void testFuseMountFails() {
+			fuseH.when(() -> fuse_h.fuse3_new(Mockito.any(), Mockito.any(), Mockito.anyLong(), Mockito.any())).thenReturn(MemoryAddress.ofLong(42L));
+			fuseH.when(() -> fuse_h.fuse3_mount(Mockito.any(), Mockito.any())).thenReturn(1);
+
+			var thrown = Assertions.assertThrows(MountFailedException.class, () -> fuseImplSpy.mount(args));
+
+			Assertions.assertEquals("fuse_mount failed", thrown.getMessage());
+		}
+
+		@Test
+		@DisplayName("Adjust mount point A -> A:")
+		public void testAdjustMountPoint() throws MountFailedException, InterruptedException {
+			Path mountPoint = Mockito.mock(Path.class, "A");
+			FuseMount fuseMount = Mockito.mock(FuseMount.class);
+			Mockito.doReturn(mountPoint).when(mountPoint).getRoot();
+			Mockito.doReturn(true).when(mountPoint).isAbsolute();
+			Mockito.doReturn(fuseMount).when(fuseImplSpy).mount(Mockito.any());
+			Mockito.doNothing().when(fuseImplSpy).waitForMountingToComplete(mountPoint);
+			Mockito.doReturn(0).when(fuseMount).loop();
+
+			fuseImplSpy.mount("test", mountPoint);
+
+			Mockito.verify(fuseImplSpy).mount(Mockito.argThat(list -> "A:".equals(list.get(list.size() - 1))));
+			Mockito.verify(fuseImplSpy).waitForMountingToComplete(mountPoint);
+		}
+
+		@Test
+		@DisplayName("waitForMountingToComplete() waits for getattr(\"/jfuse_windows_mount_probe\")")
+		public void testWaitForMountingToComplete() throws IOException {
+			Path mountPoint = Mockito.mock(Path.class, "M:");
+			Path probePath = Mockito.mock(Path.class, "M:/jfuse_windows_mount_probe");
+			FileSystem fs = Mockito.mock(FileSystem.class);
+			FileSystemProvider fsProv = Mockito.mock(FileSystemProvider.class);
+			BasicFileAttributeView attrView = Mockito.mock(BasicFileAttributeView.class);
+			Mockito.doReturn(probePath).when(mountPoint).resolve("jfuse_windows_mount_probe");
+			Mockito.doReturn(fs).when(probePath).getFileSystem();
+			Mockito.doReturn(fsProv).when(fs).provider();
+			Mockito.doReturn(attrView).when(fsProv).getFileAttributeView(probePath, BasicFileAttributeView.class);
+			Mockito.doAnswer(invocation -> {
+				try (var scope = MemorySession.openConfined()) {
+					var path = scope.allocateUtf8String("/jfuse_windows_mount_probe");
+					var stat = fuse_stat.allocate(scope);
+					var fi = fuse3_file_info.allocate(scope);
+					fuseImplSpy.getattr(path.address(), stat.address(), fi.address());
+				}
+				throw new NoSuchFileException("M:/jfuse_windows_mount_probe not found");
+			}).when(attrView).readAttributes();
+
+			Assertions.assertTimeoutPreemptively(Duration.ofSeconds(1), () -> fuseImplSpy.waitForMountingToComplete(mountPoint));
+
+			Mockito.verify(fuseOps).getattr(Mockito.eq("/jfuse_windows_mount_probe"), Mockito.any(), Mockito.any());
+		}
+	}
+
+	@Test
+	@DisplayName("parseArgs")
+	public void testParseArgs() {
+		try (var fuseH = Mockito.mockStatic(fuse2_h.class);
+			 var scope = MemorySession.openConfined()) {
+			fuseH.when(() -> fuse2_h.fuse_parse_cmdline(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.any())).then(invocation -> {
+				MemorySegment mp = invocation.getArgument(1);
+				MemorySegment mt = invocation.getArgument(2);
+				MemorySegment fg = invocation.getArgument(3);
+				mp.set(ValueLayout.ADDRESS, 0L, scope.allocateUtf8String("/mount/point"));
+				mt.set(JAVA_INT, 0L, 1);
+				fg.set(JAVA_INT, 0L, 1);
+				return 0;
+			});
+
+			var fuseArgs = fuseImpl.parseArgs(List.of("fusefs", "-foo", "-bar", "/mount/point"));
+
+			Assertions.assertTrue(fuseArgs.multiThreaded());
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[0] = fusefs"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[1] = -foo"));
+			Assertions.assertTrue(fuseArgs.toString().contains("arg[2] = -bar"));
+			Assertions.assertTrue(fuseArgs.toString().contains("mountPoint = /mount/point"));
+		}
+	}
+
+	@DisplayName("init() sets fuse_conn_info.wants |= FUSE_CAP_READDIRPLUS")
+	@Test
+	public void testInit() {
+		try (var scope = MemorySession.openConfined()) {
+			var result = new AtomicInteger();
+			Mockito.doAnswer(invocation -> {
+				FuseConnInfo connInfo = invocation.getArgument(0);
+				result.set(connInfo.want());
+				return null;
+			}).when(fuseOps).init(Mockito.any());
+			var connInfo = fuse3_conn_info.allocate(scope);
+			var fuseConfig = MemoryAddress.NULL; // TODO jextract fuse_config
+
+			fuseImpl.init(connInfo.address(), fuseConfig.address());
+
+			Assertions.assertEquals(FuseConnInfo.FUSE_CAP_READDIRPLUS, result.get() & FuseConnInfo.FUSE_CAP_READDIRPLUS);
+		}
+	}
+
+	@Nested
+	@DisplayName("utimens")
+	public class Utimens {
+
+		@DisplayName("utimens(\"/foo\", UTIME_NOW, UTIME_NOW)")
+		@Test
+		public void testUtimensNow() {
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var times = MemoryAddress.NULL;
+				var fi = scope.allocate(fuse3_file_info.$LAYOUT());
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> t.get().getNano() == 0L), Mockito.argThat(t -> t.get().getNano() == 0L), Mockito.argThat(usesSameMemorySegement(fi)));
+
+				var result = fuseImpl.utimens(path.address(), times, fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+
+		@DisplayName("utimens(\"/foo\", ...)")
+		@ParameterizedTest
+		@CsvSource(value = {
+				"123456,789, 456789,123",
+				"111222,333, 444555,666",
+		})
+		public void testUtimens(long sec0, long nsec0, long sec1, long nsec1) {
+			Instant expectedATime = Instant.ofEpochSecond(sec0, nsec0);
+			Instant expectedMTime = Instant.ofEpochSecond(sec1, nsec1);
+			try (var scope = MemorySession.openConfined()) {
+				var path = scope.allocateUtf8String("/foo");
+				var times = fuse_timespec.allocateArray(2, scope);
+				var fi = scope.allocate(fuse3_file_info.$LAYOUT());
+				fuse_timespec.tv_sec$set(times, 0, sec0);
+				fuse_timespec.tv_nsec$set(times, 0, nsec0);
+				fuse_timespec.tv_sec$set(times, 1, sec1);
+				fuse_timespec.tv_nsec$set(times, 1, nsec1);
+				Mockito.doReturn(42).when(fuseOps).utimens(Mockito.eq("/foo"), Mockito.argThat(t -> expectedATime.equals(t.get())), Mockito.argThat(t -> expectedMTime.equals(t.get())), Mockito.argThat(usesSameMemorySegement(fi)));
+
+				var result = fuseImpl.utimens(path.address(), times.address(), fi.address());
+
+				Assertions.assertEquals(42, result);
+			}
+		}
+	}
+
+	@Test
+	@DisplayName("getattr")
+	public void testGetattr() {
+		try (var scope = MemorySession.openConfined()) {
+			var path = scope.allocateUtf8String("/foo");
+			var attr = fuse_stat.allocate(scope);
+			var fi = scope.allocate(fuse3_file_info.$LAYOUT());
+			Mockito.doReturn(42).when(fuseOps).getattr(Mockito.eq("/foo"), Mockito.any(), Mockito.argThat(usesSameMemorySegement(fi)));
+
+			var result = fuseImpl.getattr(path.address(), attr.address(), fi.address());
+
+			Assertions.assertEquals(42, result);
+		}
+	}
+
+
+	@Test
+	@DisplayName("truncate")
+	public void testTruncate() {
+		try (var scope = MemorySession.openConfined()) {
+			var path = scope.allocateUtf8String("/foo");
+			var fi = scope.allocate(fuse3_file_info.$LAYOUT());
+			Mockito.doReturn(42).when(fuseOps).truncate(Mockito.eq("/foo"), Mockito.eq(1337L), Mockito.argThat(usesSameMemorySegement(fi)));
+
+			var result = fuseImpl.truncate(path.address(), 1337L, fi.address());
+
+			Assertions.assertEquals(42, result);
+		}
+	}
+
+	private static ArgumentMatcher<FileInfo> usesSameMemorySegement(MemorySegment expected) {
+		return obj -> {
+				if (obj instanceof FileInfoImpl fiImpl) {
+					return fiImpl.segment().address().equals(expected.address()) && fiImpl.segment().byteSize() == expected.byteSize();
+				}
+				return false;
+			};
+		}
+
+}
\ No newline at end of file
diff --git a/libfuse b/libfuse
deleted file mode 160000
index df499bf1..00000000
--- a/libfuse
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit df499bf1ce634f6e67d4d366c4475d32143f00f0
diff --git a/libfuse2 b/libfuse2
new file mode 160000
index 00000000..5a43d0f7
--- /dev/null
+++ b/libfuse2
@@ -0,0 +1 @@
+Subproject commit 5a43d0f724c56f8836f3f92411e0de1b5f82db32
diff --git a/libfuse3 b/libfuse3
new file mode 160000
index 00000000..7657ec15
--- /dev/null
+++ b/libfuse3
@@ -0,0 +1 @@
+Subproject commit 7657ec158becdc59656c59dff40346fefde78cb2
diff --git a/pom.xml b/pom.xml
index 2c6f8aec..6d2a3207 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,7 +6,7 @@
 	<groupId>org.cryptomator</groupId>
 	<artifactId>jfuse</artifactId>
 	<packaging>pom</packaging>
-	<version>0.1.0</version>
+	<version>0.2.0</version>
 	<name>jFUSE</name>
 	<description>Java bindings for FUSE using foreign functions &amp; memory API</description>
 	<url>https://github.com/cryptomator/jfuse</url>
@@ -60,7 +60,7 @@
 		</dependency>
 		<dependency>
 			<groupId>org.mockito</groupId>
-			<artifactId>mockito-core</artifactId>
+			<artifactId>mockito-inline</artifactId>
 			<version>4.7.0</version>
 			<scope>test</scope>
 		</dependency>
@@ -185,7 +185,7 @@
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-surefire-plugin</artifactId>
 				<configuration>
-					<argLine>@{surefire.jacoco.args} --enable-preview</argLine>
+					<argLine>@{surefire.jacoco.args} --enable-preview --enable-native-access=ALL-UNNAMED</argLine>
 				</configuration>
 			</plugin>
 		</plugins>
diff --git a/winfsp b/winfsp
index 6720dfac..5251dcbc 160000
--- a/winfsp
+++ b/winfsp
@@ -1 +1 @@
-Subproject commit 6720dfacbc3b114a04030c68e392b249f40e4374
+Subproject commit 5251dcbce93a334cc2b69565eb43de42eeaa2a64