asyncfuse 0.1.13

FUSE user-space library async version implementation.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

# Changelog

## 0.1.13 - 2026-09-19

### Changed
- asyncfuse: FUSE replies are written straight from the dedicated reply task with a blocking ``writev`` on that task's own ``/dev/fuse`` fd instead of being handed to the io_uring ring thread. This removes an mpsc hop, two thread wakeups and one ``io_uring_enter`` per reply (measured ~70us off each reply; +27% fio-randread and +25% fio-randrw throughput on the BrewFS compose baseline, neutral for serial seqread). Set ``BREWFS_FUSE_DIRECT_REPLY=0`` to fall back to the ring-thread path.

### Fixed
- asyncfuse: the io_uring connection no longer tears its ring thread down when
  the submission queue is full. A request that cannot be submitted is answered
  with a retryable error, so the mount survives instead of every later request
  failing or hanging.
- asyncfuse: the io_uring read and write slot tables are bounded and their
  slots are recycled. The write table previously grew by one entry per
  completed reply for as long as at least one reply stayed in flight, so a
  continuously busy mount leaked memory without bound.
- asyncfuse: `submit_and_wait` retries on `EINTR`, and when the ring really
  fails it fails every outstanding request instead of leaving callers waiting
  for a completion that can no longer arrive.

### Changed
- asyncfuse: the io_uring connection keeps up to `MAX_INFLIGHT_READS` (32)
  `readv` operations in flight instead of exactly one. The session loop still
  issues reads one at a time, but a cancelled or racing read can no longer block
  every later read with `WouldBlock: read already inflight`.

## 0.1.12 - 2026-07-19

### Fixed
- Reuse owned aligned buffers for worker-dispatched FUSE write payloads instead
  of copying every request, while preserving the copy path for other requests
  and non-Tokio runtimes.

## 0.1.11 - 2026-07-14

### Fixed
- asyncfuse: make inode allocation, reuse, and path-bridge bookkeeping robust
  under concurrent filesystem operations.

## 2026-07-09

### Added
- asyncfuse: add `Filesystem::init_with_notify`, allowing raw filesystems to
  capture a kernel notification handle during FUSE initialization while keeping
  the original `init` method as the default behavior.

## 2026-02-24

### Fixed
- asyncfuse: gate `LoggingFileSystem::{getlk,setlk}` behind the `file-lock` feature to match the `Filesystem` trait.
- asyncfuse: fix examples to construct `ReplyInit` via `ReplyInit::default()`.

## 2026-02-07

### Added
- asyncfuse: buffer pool feature flag (buffer-pool).
- asyncfuse: mount options for max_write and max_readahead.
- asyncfuse: benchmark filesystem example and fio helper script.
- asyncfuse: performance report (report.md).
- asyncfuse: direct_io mount option to force FOPEN_DIRECT_IO on all file operations

### Changed
- asyncfuse: init reply is now empty; size tuning is via mount options.
- asyncfuse: session uses aligned buffers and zero-copy request bodies for worker dispatch.
- asyncfuse: inode name manager uses DashMap for concurrent access.
- asyncfuse: cached bincode config uses OnceLock for MSRV compatibility.