rpms
/
fuse
7
0
Fork 0
Code Issues Pull Requests Releases Activity

Compare commits

base: rpms:imports/c8s/fuse-2.9.7-15.el8
Branches Tags
rpms:c8
rpms:c8-beta
rpms:c9s
rpms:c8s
rpms:c9
rpms:c9-beta
rpms:imports/c8/fuse-2.9.7-19.el8
rpms:imports/c8/fuse-2.9.7-17.el8
rpms:imports/c8-beta/fuse-2.9.7-17.el8
rpms:imports/c8/fuse-2.9.7-16.el8
rpms:imports/c8-beta/fuse-2.9.7-16.el8
rpms:imports/c8s/fuse-2.9.7-16.el8
rpms:imports/c9/fuse-2.9.9-15.el9
rpms:imports/c8/fuse-2.9.7-15.el8
rpms:imports/c8-beta/fuse-2.9.7-15.el8
rpms:imports/c8s/fuse-2.9.7-15.el8
rpms:imports/c9-beta/fuse-2.9.9-15.el9
rpms:imports/c8s/fuse-2.9.7-14.el8
rpms:imports/c9-beta/fuse-2.9.9-14.el9
rpms:imports/c9-beta/fuse-2.9.9-12.el9
rpms:imports/c8s/fuse-2.9.7-12.el8
rpms:imports/c8-beta/fuse-2.9.7-12.el8
rpms:imports/c8/fuse-2.9.7-12.el8
...
compare: rpms:c8
Branches Tags
rpms:c8
rpms:c8-beta
rpms:c9s
rpms:c8s
rpms:c9
rpms:c9-beta
rpms:imports/c8/fuse-2.9.7-19.el8
rpms:imports/c8/fuse-2.9.7-17.el8
rpms:imports/c8-beta/fuse-2.9.7-17.el8
rpms:imports/c8/fuse-2.9.7-16.el8
rpms:imports/c8-beta/fuse-2.9.7-16.el8
rpms:imports/c8s/fuse-2.9.7-16.el8
rpms:imports/c9/fuse-2.9.9-15.el9
rpms:imports/c8/fuse-2.9.7-15.el8
rpms:imports/c8-beta/fuse-2.9.7-15.el8
rpms:imports/c8s/fuse-2.9.7-15.el8
rpms:imports/c9-beta/fuse-2.9.9-15.el9
rpms:imports/c8s/fuse-2.9.7-14.el8
rpms:imports/c9-beta/fuse-2.9.9-14.el9
rpms:imports/c9-beta/fuse-2.9.9-12.el9
rpms:imports/c8s/fuse-2.9.7-12.el8
rpms:imports/c8-beta/fuse-2.9.7-12.el8
rpms:imports/c8/fuse-2.9.7-12.el8

No commits in common. "imports/c8s/fuse-2.9.7-15.el8" and "c8" have entirely different histories.
imports/c8 ... c8

12 changed files with 1061 additions and 1 deletions
Show Stats Expand all files Collapse all files

59
SOURCES/0001-Synchronize-fuse_kernel.h.patch Normal file
View File

@ -0,0 +1,59 @@
From 492d3a24c13babd103fb71d44adfb8e94687db52 Mon Sep 17 00:00:00 2001
From: Pavel Reichl <preichl@redhat.com>
Date: Tue, 7 Jun 2022 08:27:36 +0200
Subject: [PATCH 1/4] Synchronize fuse_kernel.h
Signed-off-by: Pavel Reichl <preichl@redhat.com>
---
include/fuse_kernel.h | 10 +++++++++-
1 file changed, 9 insertions(+), 1 deletion(-)
diff --git a/include/fuse_kernel.h b/include/fuse_kernel.h
index 42fa977..b55fa8b 100644
--- a/include/fuse_kernel.h
+++ b/include/fuse_kernel.h
@@ -215,10 +215,12 @@ struct fuse_file_lock {
* FOPEN_DIRECT_IO: bypass page cache for this open file
* FOPEN_KEEP_CACHE: don't invalidate the data cache on open
* FOPEN_NONSEEKABLE: the file is not seekable
+ * FOPEN_CACHE_DIR: allow caching this directory
*/
#define FOPEN_DIRECT_IO (1 << 0)
#define FOPEN_KEEP_CACHE (1 << 1)
#define FOPEN_NONSEEKABLE (1 << 2)
+#define FOPEN_CACHE_DIR (1 << 3)
/**
* INIT request/reply flags
@@ -244,6 +246,8 @@ struct fuse_file_lock {
* FUSE_PARALLEL_DIROPS: allow parallel lookups and readdir
* FUSE_HANDLE_KILLPRIV: fs handles killing suid/sgid/cap on write/chown/trunc
* FUSE_POSIX_ACL: filesystem supports posix acls
+ * FUSE_MAX_PAGES: init_out.max_pages contains the max number of req pages
+ * FUSE_CACHE_SYMLINKS: cache READLINK responses
*/
#define FUSE_ASYNC_READ (1 << 0)
#define FUSE_POSIX_LOCKS (1 << 1)
@@ -266,6 +270,8 @@ struct fuse_file_lock {
#define FUSE_PARALLEL_DIROPS (1 << 18)
#define FUSE_HANDLE_KILLPRIV (1 << 19)
#define FUSE_POSIX_ACL (1 << 20)
+#define FUSE_MAX_PAGES (1 << 22)
+#define FUSE_CACHE_SYMLINKS (1 << 23)
/**
* CUSE INIT request/reply flags
@@ -604,7 +610,9 @@ struct fuse_init_out {
uint16_t congestion_threshold;
uint32_t max_write;
uint32_t time_gran;
- uint32_t unused[9];
+ uint16_t max_pages;
+ uint16_t padding;
+ uint32_t unused[8];
};
#define CUSE_INIT_INFO_MAX 4096
--
2.36.1

130
SOURCES/0002-fuse_lowlevel-Add-max_pages-support-384.patch Normal file
View File

@ -0,0 +1,130 @@
From 5100bdc814435a1222fef6438cebcd81a3de6c73 Mon Sep 17 00:00:00 2001
From: scosu <mpargmann@allfex.org>
Date: Thu, 13 Jun 2019 13:59:10 +0200
Subject: [PATCH 2/4] fuse_lowlevel: Add max_pages support (#384)
Starting with kernel version 4.20 fuse supports a new property
'max_pages' which is the maximum number of pages that can be used per
request. This can be set via an argument during initialization.
This new property allows writes to be larger than 128k.
This patch sets the property if the matching capability is set
(FUSE_MAX_PAGES). It will also set max_write to 1MiB. Filesystems have
the possibility to decrease this size by setting max_write to a smaller
size. The max_pages and bufsize fields are adjusted accordingly.
Cc: Constantine Shulyupin <const@MakeLinux.com>
Signed-off-by: Markus Pargmann <scosu@quobyte.com>
(cherry picked from commit 027d0d17c8a4605109f09d9c988e255b64a2c19a)
Signed-off-by: Pavel Reichl <preichl@redhat.com>
---
ChangeLog.rst | 7 +++++++
lib/fuse_i.h | 6 ++++++
lib/fuse_lowlevel.c | 30 +++++++++++++++++++++---------
3 files changed, 34 insertions(+), 9 deletions(-)
diff --git a/ChangeLog.rst b/ChangeLog.rst
index 8ea9397..411cd4a 100644
--- a/ChangeLog.rst
+++ b/ChangeLog.rst
@@ -1,6 +1,13 @@
libfuse 3.3.0 (2018-11-06)
==========================
+* Added support for fuse kernel feature `max_pages` which allows to increase
+ the maximum number of pages that can be used per request. This feature was
+ introduced in kernel 4.20. `max_pages` is set based on the value in
+ `max_write`. By default `max_write` will be 1MiB now for kernels that support
+ `max_pages`. If you want smaller buffers or writes you have to set
+ `max_write` manually.
+
* The `auto_unmount` mode now works correctly in combination with
autofs.
diff --git a/lib/fuse_i.h b/lib/fuse_i.h
index cf35551..d38b630 100644
--- a/lib/fuse_i.h
+++ b/lib/fuse_i.h
@@ -131,3 +131,9 @@ struct fuse *fuse_new_31(struct fuse_args *args, const struct fuse_operations *o
int fuse_loop_mt_32(struct fuse *f, struct fuse_loop_config *config);
int fuse_session_loop_mt_32(struct fuse_session *se, struct fuse_loop_config *config);
+#define FUSE_MAX_MAX_PAGES 256
+#define FUSE_DEFAULT_MAX_PAGES_PER_REQ 32
+
+/* room needed in buffer to accommodate header */
+#define FUSE_BUFFER_HEADER_SIZE 0x1000
+
diff --git a/lib/fuse_lowlevel.c b/lib/fuse_lowlevel.c
index 844e797..60195e0 100644
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -1882,6 +1882,14 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
se->conn.capable |= FUSE_CAP_POSIX_ACL;
if (arg->flags & FUSE_HANDLE_KILLPRIV)
se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
+ if (!(arg->flags & FUSE_MAX_PAGES)) {
+ size_t max_bufsize =
+ FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize()
+ + FUSE_BUFFER_HEADER_SIZE;
+ if (bufsize > max_bufsize) {
+ bufsize = max_bufsize;
+ }
+ }
} else {
se->conn.max_readahead = 0;
}
@@ -1928,10 +1936,10 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
bufsize);
bufsize = FUSE_MIN_READ_BUFFER;
}
+ se->bufsize = bufsize;
- bufsize -= 4096;
- if (bufsize < se->conn.max_write)
- se->conn.max_write = bufsize;
+ if (se->conn.max_write > bufsize - FUSE_BUFFER_HEADER_SIZE)
+ se->conn.max_write = bufsize - FUSE_BUFFER_HEADER_SIZE;
se->got_init = 1;
if (se->op.init)
@@ -1958,6 +1966,14 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
return;
}
+ if (se->conn.max_write < bufsize - FUSE_BUFFER_HEADER_SIZE) {
+ se->bufsize = se->conn.max_write + FUSE_BUFFER_HEADER_SIZE;
+ }
+ if (arg->flags & FUSE_MAX_PAGES) {
+ outarg.flags |= FUSE_MAX_PAGES;
+ outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
+ }
+
/* Always enable big writes, this is superseded
by the max_write option */
outarg.flags |= FUSE_BIG_WRITES;
@@ -2779,11 +2795,6 @@ restart:
return res;
}
-#define KERNEL_BUF_PAGES 32
-
-/* room needed in buffer to accommodate header */
-#define HEADER_SIZE 0x1000
-
struct fuse_session *fuse_session_new(struct fuse_args *args,
const struct fuse_lowlevel_ops *op,
size_t op_size, void *userdata)
@@ -2844,7 +2855,8 @@ struct fuse_session *fuse_session_new(struct fuse_args *args,
if (se->debug)
fprintf(stderr, "FUSE library version: %s\n", PACKAGE_VERSION);
- se->bufsize = KERNEL_BUF_PAGES * getpagesize() + HEADER_SIZE;
+ se->bufsize = FUSE_MAX_MAX_PAGES * getpagesize() +
+ FUSE_BUFFER_HEADER_SIZE;
list_init_req(&se->list);
list_init_req(&se->interrupts);
--
2.36.1

83
SOURCES/0003-Allow-caching-symlinks-in-kernel-page-cache.-551.patch Normal file
View File

@ -0,0 +1,83 @@
From be7f19b21c84004c5a0705f040b957fd1c609e2e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Etienne=20Dubl=C3=A9?= <etienne.duble@imag.fr>
Date: Sun, 20 Sep 2020 20:08:15 +0200
Subject: [PATCH 3/4] Allow caching symlinks in kernel page cache. (#551)
This commit defines a new capability called `FUSE_CAP_CACHE_SYMLINKS`.
It is off by default but you can now enable it by setting this flag in
in the `want` field of the `fuse_conn_info` structure.
When enabled, the kernel will save symlinks in its page cache,
by making use of the feature introduced in kernel 4.20:
https://github.com/torvalds/linux/commit/5571f1e65486be025f73fa6aa30fb03725d362a2
(cherry picked from commit ba3b225a126ebb3c6d4fe27c9f7c73aa4167001e)
Signed-off-by: Pavel Reichl <preichl@redhat.com>
---
example/printcap.c | 2 ++
include/fuse_common.h | 13 +++++++++++++
lib/fuse_lowlevel.c | 4 ++++
3 files changed, 19 insertions(+)
diff --git a/example/printcap.c b/example/printcap.c
index 77dea14..a66036f 100644
--- a/example/printcap.c
+++ b/example/printcap.c
@@ -77,6 +77,8 @@ static void pc_init(void *userdata,
printf("\tFUSE_CAP_PARALLEL_DIROPS\n");
if(conn->capable & FUSE_CAP_POSIX_ACL)
printf("\tFUSE_CAP_POSIX_ACL\n");
+ if(conn->capable & FUSE_CAP_CACHE_SYMLINKS)
+ printf("\tFUSE_CAP_CACHE_SYMLINKS\n");
fuse_session_exit(se);
}
diff --git a/include/fuse_common.h b/include/fuse_common.h
index 83c9dee..a5a0ea5 100644
--- a/include/fuse_common.h
+++ b/include/fuse_common.h
@@ -316,6 +316,19 @@ struct fuse_loop_config {
*/
#define FUSE_CAP_HANDLE_KILLPRIV (1 << 20)
+/**
+ * Indicates that the kernel supports caching symlinks in its page cache.
+ *
+ * When this feature is enabled, symlink targets are saved in the page cache.
+ * You can invalidate a cached link by calling:
+ * `fuse_lowlevel_notify_inval_inode(se, ino, 0, 0);`
+ *
+ * This feature is disabled by default.
+ * If the kernel supports it (>= 4.20), you can enable this feature by
+ * setting this flag in the `want` field of the `fuse_conn_info` structure.
+ */
+#define FUSE_CAP_CACHE_SYMLINKS (1 << 23)
+
/**
* Ioctl flags
*
diff --git a/lib/fuse_lowlevel.c b/lib/fuse_lowlevel.c
index 60195e0..43f785f 100644
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -1882,6 +1882,8 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
se->conn.capable |= FUSE_CAP_POSIX_ACL;
if (arg->flags & FUSE_HANDLE_KILLPRIV)
se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
+ if (arg->flags & FUSE_CACHE_SYMLINKS)
+ se->conn.capable |= FUSE_CAP_CACHE_SYMLINKS;
if (!(arg->flags & FUSE_MAX_PAGES)) {
size_t max_bufsize =
FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize()
@@ -2002,6 +2004,8 @@ static void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
outarg.flags |= FUSE_WRITEBACK_CACHE;
if (se->conn.want & FUSE_CAP_POSIX_ACL)
outarg.flags |= FUSE_POSIX_ACL;
+ if (se->conn.want & FUSE_CAP_CACHE_SYMLINKS)
+ outarg.flags |= FUSE_CACHE_SYMLINKS;
outarg.max_readahead = se->conn.max_readahead;
outarg.max_write = se->conn.max_write;
if (se->conn.proto_minor >= 13) {
--
2.36.1

65
SOURCES/0004-Add-support-for-in-kernel-readdir-caching.patch Normal file
View File

@ -0,0 +1,65 @@
From da57354dc8593d37eff59bc7836ee4e460a2659a Mon Sep 17 00:00:00 2001
From: Nikolaus Rath <Nikolaus@rath.org>
Date: Sat, 6 Apr 2019 18:34:57 +0100
Subject: [PATCH 4/4] Add support for in-kernel readdir caching.
Fixes: #394.
(cherry picked from commit 1552b467fcd7751360299c5139382d78538e12b3)
Signed-off-by: Pavel Reichl <preichl@redhat.com>
---
include/fuse_common.h | 18 +++++++++++++-----
lib/fuse_lowlevel.c | 2 ++
2 files changed, 15 insertions(+), 5 deletions(-)
diff --git a/include/fuse_common.h b/include/fuse_common.h
index a5a0ea5..a28ffa5 100644
--- a/include/fuse_common.h
+++ b/include/fuse_common.h
@@ -45,9 +45,11 @@ struct fuse_file_info {
/** Can be filled in by open, to use direct I/O on this file. */
unsigned int direct_io : 1;
- /** Can be filled in by open, to indicate that currently
- cached file data (that the filesystem provided the last
- time the file was open) need not be invalidated. */
+ /** Can be filled in by open. It signals the kernel that any
+ currently cached file data (ie., data that the filesystem
+ provided the last time the file was open) need not be
+ invalidated. Has no effect when set in other contexts (in
+ particular it does nothing when set by opendir()). */
unsigned int keep_cache : 1;
/** Indicates a flush operation. Set in flush operation, also
@@ -64,8 +66,14 @@ struct fuse_file_info {
May only be set in ->release(). */
unsigned int flock_release : 1;
- /** Padding. Do not use*/
- unsigned int padding : 27;
+ /** Can be filled in by opendir. It signals the kernel to
+ enable caching of entries returned by readdir(). Has no
+ effect when set in other contexts (in particular it does
+ nothing when set by open()). */
+ unsigned int cache_readdir : 1;
+
+ /** Padding. Reserved for future use*/
+ unsigned int padding : 26;
/** File handle. May be filled in by filesystem in open().
Available in all other file operations */
diff --git a/lib/fuse_lowlevel.c b/lib/fuse_lowlevel.c
index 43f785f..6379e09 100644
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -392,6 +392,8 @@ static void fill_open(struct fuse_open_out *arg,
arg->open_flags |= FOPEN_DIRECT_IO;
if (f->keep_cache)
arg->open_flags |= FOPEN_KEEP_CACHE;
+ if (f->cache_readdir)
+ arg->open_flags |= FOPEN_CACHE_DIR;
if (f->nonseekable)
arg->open_flags |= FOPEN_NONSEEKABLE;
}
--
2.36.1

179
SOURCES/0005-BZ_217095_Modify-structures-in-libfuse-to-handle-flags-beyond-rhel-8.patch Normal file
View File

@ -0,0 +1,179 @@
From 4df08719f3415cde6f802a755922b7f76e198cd7 Mon Sep 17 00:00:00 2001
From: Dharmendra Singh <dsingh@ddn.com>
Date: Mon, 28 Feb 2022 11:15:06 +0000
Subject: [PATCH] Modify structures in libfuse to handle flags beyond 32 bits.
In fuse kernel, 'commit 53db28933e95 ("fuse: extend init flags")'
made the changes to handle flags going beyond 32 bits but i think
changes were not done in libfuse to handle the same.
This patch prepares the ground in libfuse for incoming FUSE kernel
patches (Atomic open + lookup) where flags went beyond 32 bits.
It makes struct same as in fuse kernel resulting in name change of
few fields.
---
include/fuse_kernel.h | 8 ++++-
lib/fuse_lowlevel.c | 75 ++++++++++++++++++++++++++++----------------------
2 files changed, 48 insertions(+), 35 deletions(-)
--- a/include/fuse_kernel.h
+++ b/include/fuse_kernel.h
@@ -272,6 +272,7 @@ struct fuse_file_lock {
#define FUSE_POSIX_ACL (1 << 20)
#define FUSE_MAX_PAGES (1 << 22)
#define FUSE_CACHE_SYMLINKS (1 << 23)
+#define FUSE_INIT_EXT (1 << 30)
/**
* CUSE INIT request/reply flags
@@ -596,6 +597,8 @@ struct fuse_init_in {
uint32_t minor;
uint32_t max_readahead;
uint32_t flags;
+ uint32_t flags2;
+ uint32_t unused[11];
};
#define FUSE_COMPAT_INIT_OUT_SIZE 8
@@ -611,8 +614,9 @@ struct fuse_init_out {
uint32_t max_write;
uint32_t time_gran;
uint16_t max_pages;
- uint16_t padding;
- uint32_t unused[8];
+ uint16_t map_alignment;
+ uint32_t flags2;
+ uint32_t unused[7];
};
#define CUSE_INIT_INFO_MAX 4096
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -1819,7 +1819,8 @@ static void do_init(fuse_req_t req, fuse
struct fuse_session *se = req->se;
size_t bufsize = se->bufsize;
size_t outargsize = sizeof(outarg);
-
+ uint64_t inargflags = 0;
+ uint64_t outargflags = 0;
(void) nodeid;
if (se->debug) {
fprintf(stderr, "INIT: %u.%u\n", arg->major, arg->minor);
@@ -1854,39 +1855,42 @@ static void do_init(fuse_req_t req, fuse
if (arg->minor >= 6) {
if (arg->max_readahead < se->conn.max_readahead)
se->conn.max_readahead = arg->max_readahead;
- if (arg->flags & FUSE_ASYNC_READ)
+ inargflags = arg->flags;
+ if (inargflags & FUSE_INIT_EXT)
+ inargflags = inargflags | (uint64_t) arg->flags2 << 32;
+ if (inargflags & FUSE_ASYNC_READ)
se->conn.capable |= FUSE_CAP_ASYNC_READ;
- if (arg->flags & FUSE_POSIX_LOCKS)
+ if (inargflags & FUSE_POSIX_LOCKS)
se->conn.capable |= FUSE_CAP_POSIX_LOCKS;
- if (arg->flags & FUSE_ATOMIC_O_TRUNC)
+ if (inargflags & FUSE_ATOMIC_O_TRUNC)
se->conn.capable |= FUSE_CAP_ATOMIC_O_TRUNC;
- if (arg->flags & FUSE_EXPORT_SUPPORT)
+ if (inargflags & FUSE_EXPORT_SUPPORT)
se->conn.capable |= FUSE_CAP_EXPORT_SUPPORT;
- if (arg->flags & FUSE_DONT_MASK)
+ if (inargflags & FUSE_DONT_MASK)
se->conn.capable |= FUSE_CAP_DONT_MASK;
- if (arg->flags & FUSE_FLOCK_LOCKS)
+ if (inargflags & FUSE_FLOCK_LOCKS)
se->conn.capable |= FUSE_CAP_FLOCK_LOCKS;
- if (arg->flags & FUSE_AUTO_INVAL_DATA)
+ if (inargflags & FUSE_AUTO_INVAL_DATA)
se->conn.capable |= FUSE_CAP_AUTO_INVAL_DATA;
- if (arg->flags & FUSE_DO_READDIRPLUS)
+ if (inargflags & FUSE_DO_READDIRPLUS)
se->conn.capable |= FUSE_CAP_READDIRPLUS;
- if (arg->flags & FUSE_READDIRPLUS_AUTO)
+ if (inargflags & FUSE_READDIRPLUS_AUTO)
se->conn.capable |= FUSE_CAP_READDIRPLUS_AUTO;
- if (arg->flags & FUSE_ASYNC_DIO)
+ if (inargflags & FUSE_ASYNC_DIO)
se->conn.capable |= FUSE_CAP_ASYNC_DIO;
- if (arg->flags & FUSE_WRITEBACK_CACHE)
+ if (inargflags & FUSE_WRITEBACK_CACHE)
se->conn.capable |= FUSE_CAP_WRITEBACK_CACHE;
- if (arg->flags & FUSE_NO_OPEN_SUPPORT)
+ if (inargflags & FUSE_NO_OPEN_SUPPORT)
se->conn.capable |= FUSE_CAP_NO_OPEN_SUPPORT;
- if (arg->flags & FUSE_PARALLEL_DIROPS)
+ if (inargflags & FUSE_PARALLEL_DIROPS)
se->conn.capable |= FUSE_CAP_PARALLEL_DIROPS;
- if (arg->flags & FUSE_POSIX_ACL)
+ if (inargflags & FUSE_POSIX_ACL)
se->conn.capable |= FUSE_CAP_POSIX_ACL;
- if (arg->flags & FUSE_HANDLE_KILLPRIV)
+ if (inargflags & FUSE_HANDLE_KILLPRIV)
se->conn.capable |= FUSE_CAP_HANDLE_KILLPRIV;
- if (arg->flags & FUSE_CACHE_SYMLINKS)
+ if (inargflags & FUSE_CACHE_SYMLINKS)
se->conn.capable |= FUSE_CAP_CACHE_SYMLINKS;
- if (!(arg->flags & FUSE_MAX_PAGES)) {
+ if (!(inargflags & FUSE_MAX_PAGES)) {
size_t max_bufsize =
FUSE_DEFAULT_MAX_PAGES_PER_REQ * getpagesize()
+ FUSE_BUFFER_HEADER_SIZE;
@@ -1977,37 +1981,42 @@ static void do_init(fuse_req_t req, fuse
outarg.flags |= FUSE_MAX_PAGES;
outarg.max_pages = (se->conn.max_write - 1) / getpagesize() + 1;
}
-
+ outargflags = outarg.flags;
/* Always enable big writes, this is superseded
by the max_write option */
- outarg.flags |= FUSE_BIG_WRITES;
+ outargflags |= FUSE_BIG_WRITES;
if (se->conn.want & FUSE_CAP_ASYNC_READ)
- outarg.flags |= FUSE_ASYNC_READ;
+ outargflags |= FUSE_ASYNC_READ;
if (se->conn.want & FUSE_CAP_POSIX_LOCKS)
- outarg.flags |= FUSE_POSIX_LOCKS;
+ outargflags |= FUSE_POSIX_LOCKS;
if (se->conn.want & FUSE_CAP_ATOMIC_O_TRUNC)
- outarg.flags |= FUSE_ATOMIC_O_TRUNC;
+ outargflags |= FUSE_ATOMIC_O_TRUNC;
if (se->conn.want & FUSE_CAP_EXPORT_SUPPORT)
- outarg.flags |= FUSE_EXPORT_SUPPORT;
+ outargflags |= FUSE_EXPORT_SUPPORT;
if (se->conn.want & FUSE_CAP_DONT_MASK)
- outarg.flags |= FUSE_DONT_MASK;
+ outargflags |= FUSE_DONT_MASK;
if (se->conn.want & FUSE_CAP_FLOCK_LOCKS)
- outarg.flags |= FUSE_FLOCK_LOCKS;
+ outargflags |= FUSE_FLOCK_LOCKS;
if (se->conn.want & FUSE_CAP_AUTO_INVAL_DATA)
- outarg.flags |= FUSE_AUTO_INVAL_DATA;
+ outargflags |= FUSE_AUTO_INVAL_DATA;
if (se->conn.want & FUSE_CAP_READDIRPLUS)
- outarg.flags |= FUSE_DO_READDIRPLUS;
+ outargflags |= FUSE_DO_READDIRPLUS;
if (se->conn.want & FUSE_CAP_READDIRPLUS_AUTO)
- outarg.flags |= FUSE_READDIRPLUS_AUTO;
+ outargflags |= FUSE_READDIRPLUS_AUTO;
if (se->conn.want & FUSE_CAP_ASYNC_DIO)
- outarg.flags |= FUSE_ASYNC_DIO;
+ outargflags |= FUSE_ASYNC_DIO;
if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)
- outarg.flags |= FUSE_WRITEBACK_CACHE;
+ outargflags |= FUSE_WRITEBACK_CACHE;
if (se->conn.want & FUSE_CAP_POSIX_ACL)
- outarg.flags |= FUSE_POSIX_ACL;
+ outargflags |= FUSE_POSIX_ACL;
if (se->conn.want & FUSE_CAP_CACHE_SYMLINKS)
- outarg.flags |= FUSE_CACHE_SYMLINKS;
+ outargflags |= FUSE_CACHE_SYMLINKS;
+
+ outarg.flags = outargflags;
+
+ if (inargflags & FUSE_INIT_EXT)
+ outarg.flags2 = outargflags >> 32;
outarg.max_readahead = se->conn.max_readahead;
outarg.max_write = se->conn.max_write;
if (se->conn.proto_minor >= 13) {

118
SOURCES/0006-BZ_2171095.patch Normal file
View File

@ -0,0 +1,118 @@
From 22cc0c761ad23395a8220ce1954cfb8a64f36ff4 Mon Sep 17 00:00:00 2001
From: HereThereBeDragons <HereThereBeDragons@users.noreply.github.com>
Date: Thu, 27 Oct 2022 17:52:10 +0200
Subject: [PATCH] Initial patch provided by Miklos Szeredi
<mszeredi@redhat.com>
---
include/fuse_kernel.h | 8 +++++++-
include/fuse_lowlevel.h | 8 ++++++++
lib/fuse_lowlevel.c | 18 ++++++++++++++----
lib/fuse_versionscript | 1 +
4 files changed, 30 insertions(+), 5 deletions(-)
diff --git a/include/fuse_kernel.h b/include/fuse_kernel.h
index 09da620b5..e0666a1f7 100644
--- a/include/fuse_kernel.h
+++ b/include/fuse_kernel.h
@@ -336,6 +336,12 @@
*/
#define FUSE_POLL_SCHEDULE_NOTIFY (1 << 0)
+/**
+ * notify_inval_entry flags
+ * FUSE_EXPIRE_ONLY
+ */
+#define FUSE_EXPIRE_ONLY (1 << 0)
+
enum fuse_opcode {
FUSE_LOOKUP = 1,
FUSE_FORGET = 2, /* no reply */
@@ -800,7 +806,7 @@ struct fuse_notify_inval_inode_out {
struct fuse_notify_inval_entry_out {
uint64_t parent;
uint32_t namelen;
- uint32_t padding;
+ uint32_t flags;
};
struct fuse_notify_delete_out {
diff --git a/include/fuse_lowlevel.h b/include/fuse_lowlevel.h
index 53f0fcf4b..c955cc4bb 100644
--- a/include/fuse_lowlevel.h
+++ b/include/fuse_lowlevel.h
@@ -1675,6 +1675,14 @@ int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
const char *name, size_t namelen);
+enum fuse_expire_flags {
+ FUSE_LL_EXPIRE_ONLY = (1 << 0),
+};
+
+int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
+ const char *name, size_t namelen,
+ enum fuse_expire_flags flags);
+
/**
* This function behaves like fuse_lowlevel_notify_inval_entry() with
* the following additional effect (at least as of Linux kernel 4.8):
diff --git a/lib/fuse_lowlevel.c b/lib/fuse_lowlevel.c
index e82cd9e9f..7b9d71043 100644
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -2161,21 +2161,24 @@
return send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);
}
-int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
- const char *name, size_t namelen)
+int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
+ const char *name, size_t namelen,
+ enum fuse_expire_flags flags)
{
struct fuse_notify_inval_entry_out outarg;
struct iovec iov[3];
if (!se)
return -EINVAL;
-
+
if (se->conn.proto_major < 6 || se->conn.proto_minor < 12)
return -ENOSYS;
outarg.parent = parent;
outarg.namelen = namelen;
- outarg.padding = 0;
+ outarg.flags = 0;
+ if (flags & FUSE_LL_EXPIRE_ONLY)
+ outarg.flags |= FUSE_EXPIRE_ONLY;
iov[1].iov_base = &outarg;
iov[1].iov_len = sizeof(outarg);
@@ -2292,6 +2295,13 @@ int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
return send_notify_iov(se, FUSE_NOTIFY_INVAL_ENTRY, iov, 3);
}
+int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
+ const char *name, size_t namelen)
+{
+ return fuse_lowlevel_notify_expire_entry(se, parent, name, namelen, 0);
+}
+
+
int fuse_lowlevel_notify_delete(struct fuse_session *se,
fuse_ino_t parent, fuse_ino_t child,
const char *name, size_t namelen)
diff --git a/lib/fuse_versionscript b/lib/fuse_versionscript
index 7e50e7507..795ea4aa9 100644
--- a/lib/fuse_versionscript
+++ b/lib/fuse_versionscript
@@ -151,6 +151,7 @@
FUSE_3.3 {
global:
fuse_open_channel;
+ fuse_lowlevel_notify_expire_entry;
} FUSE_3.2;
# Local Variables:

125
SOURCES/0007-BZ_2171095-cap.patch Normal file
View File

@ -0,0 +1,125 @@
From 6b1612e3a85b993f82124cccf149df3830e4a9c5 Mon Sep 17 00:00:00 2001
From: HereThereBeDragons <HereThereBeDragons@users.noreply.github.com>
Date: Thu, 27 Oct 2022 17:52:10 +0200
Subject: [PATCH] adding comments and capability discovery, enum for flags
moved to top of file
---
example/printcap.c | 2 ++
include/fuse_common.h | 16 ++++++++++++++++
include/fuse_lowlevel.h | 40 ++++++++++++++++++++++++++++++++++++----
lib/fuse_lowlevel.c | 2 ++
4 files changed, 56 insertions(+), 4 deletions(-)
diff --git a/example/printcap.c b/example/printcap.c
index edfd8f531..48679883c 100644
--- a/example/printcap.c
+++ b/example/printcap.c
@@ -79,6 +79,8 @@
printf("\tFUSE_CAP_POSIX_ACL\n");
if(conn->capable & FUSE_CAP_CACHE_SYMLINKS)
printf("\tFUSE_CAP_CACHE_SYMLINKS\n");
+ if(conn->capable & FUSE_CAP_EXPIRE_ONLY)
+ printf("\tFUSE_CAP_EXPIRE_ONLY\n");
fuse_session_exit(se);
}
diff --git a/include/fuse_common.h b/include/fuse_common.h
index e9d874556..dbba05af8 100644
--- a/include/fuse_common.h
+++ b/include/fuse_common.h
@@ -338,6 +338,22 @@
#define FUSE_CAP_CACHE_SYMLINKS (1 << 23)
/**
+ * Indicates support that dentries can be expired or invalidated.
+ *
+ * Expiring dentries, instead of invalidating them, makes a difference for
+ * overmounted dentries, where plain invalidation would detach all submounts
+ * before dropping the dentry from the cache. If only expiry is set on the
+ * dentry, then any overmounts are left alone and until ->d_revalidate()
+ * is called.
+ *
+ * Note: ->d_revalidate() is not called for the case of following a submount,
+ * so invalidation will only be triggered for the non-overmounted case.
+ * The dentry could also be mounted in a different mount instance, in which case
+ * any submounts will still be detached.
+*/
+#define FUSE_CAP_EXPIRE_ONLY (1 << 26)
+
+/**
* Ioctl flags
*
* FUSE_IOCTL_COMPAT: 32bit compat ioctl on 64bit machine
diff --git a/include/fuse_lowlevel.h b/include/fuse_lowlevel.h
index c955cc4bb..6a1a5d534 100644
--- a/include/fuse_lowlevel.h
+++ b/include/fuse_lowlevel.h
@@ -127,6 +127,15 @@ struct fuse_forget_data {
uint64_t nlookup;
};
+/**
+ * Flags for fuse_lowlevel_notify_expire_entry()
+ * 0 = invalidate entry
+ * FUSE_LL_EXPIRE_ONLY = expire entry
+*/
+enum fuse_expire_flags {
+ FUSE_LL_EXPIRE_ONLY = (1 << 0),
+};
+
/* 'to_set' flags in setattr */
#define FUSE_SET_ATTR_MODE (1 << 0)
#define FUSE_SET_ATTR_UID (1 << 1)
@@ -1675,10 +1684,33 @@ int fuse_lowlevel_notify_inval_inode(struct fuse_session *se, fuse_ino_t ino,
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
const char *name, size_t namelen);
-enum fuse_expire_flags {
- FUSE_LL_EXPIRE_ONLY = (1 << 0),
-};
-
+/**
+ * Notify to expire or invalidate parent attributes and the dentry
+ * matching parent/name
+ *
+ * Underlying function for fuse_lowlevel_notify_inval_entry().
+ *
+ * In addition to invalidating an entry, it also allows to expire an entry.
+ * In that case, the entry is not forcefully removed from kernel cache
+ * but instead the next access to it forces a lookup from the filesystem.
+ *
+ * This makes a difference for overmounted dentries, where plain invalidation
+ * would detach all submounts before dropping the dentry from the cache.
+ * If only expiry is set on the dentry, then any overmounts are left alone and
+ * until ->d_revalidate() is called.
+ *
+ * Note: ->d_revalidate() is not called for the case of following a submount,
+ * so invalidation will only be triggered for the non-overmounted case.
+ * The dentry could also be mounted in a different mount instance, in which case
+ * any submounts will still be detached.
+ *
+ * @param se the session object
+ * @param parent inode number
+ * @param name file name
+ * @param namelen strlen() of file name
+ * @param flags flags to control if the entry should be expired or invalidated
+ * @return zero for success, -errno for failure
+*/
int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
const char *name, size_t namelen,
enum fuse_expire_flags flags);
diff --git a/lib/fuse_lowlevel.c b/lib/fuse_lowlevel.c
index 7b9d71043..7d7630925 100644
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -1991,6 +1991,8 @@ void do_init(fuse_req_t req, fuse_ino_t nodeid, const void *inarg)
bufsize = max_bufsize;
}
}
+ if (arg->minor >= 38)
+ se->conn.capable |= FUSE_CAP_EXPIRE_ONLY;
} else {
se->conn.max_readahead = 0;
}

45
SOURCES/0008-BZ_217095-libfuse-add-feature-flag-for-expire-only.patch Normal file
View File

@ -0,0 +1,45 @@
From: Miklos Szeredi <mszeredi@redhat.com>
Subject: libfuse: add feature flag for expire-only
Add the FUSE_HAS_EXPIRE_ONLY flag. This should be used to set the
FUSE_CAP_EXPIRE_ONLY capability flag on the low level API instead of
checking for the version.
Checking the version doesn't work if the feature is backported to an
earlier kernel.
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
---
include/fuse_kernel.h | 2 ++
lib/fuse_lowlevel.c | 2 +-
2 files changed, 3 insertions(+), 1 deletion(-)
--- a/include/fuse_kernel.h
+++ b/include/fuse_kernel.h
@@ -248,6 +248,7 @@
* FUSE_POSIX_ACL: filesystem supports posix acls
* FUSE_MAX_PAGES: init_out.max_pages contains the max number of req pages
* FUSE_CACHE_SYMLINKS: cache READLINK responses
+ * FUSE_HAS_EXPIRE_ONLY: kernel supports expiry-only entry invalidation
*/
#define FUSE_ASYNC_READ (1 << 0)
#define FUSE_POSIX_LOCKS (1 << 1)
@@ -272,6 +273,7 @@
#define FUSE_MAX_PAGES (1 << 22)
#define FUSE_CACHE_SYMLINKS (1 << 23)
#define FUSE_INIT_EXT (1 << 30)
+#define FUSE_HAS_EXPIRE_ONLY (1ULL << 35)
/**
* CUSE INIT request/reply flags
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -2008,7 +2008,7 @@ void do_init(fuse_req_t req, fuse_ino_t
bufsize = max_bufsize;
}
}
- if (arg->minor >= 38)
+ if (inargflags & FUSE_HAS_EXPIRE_ONLY)
se->conn.capable |= FUSE_CAP_EXPIRE_ONLY;
} else {
se->conn.max_readahead = 0;

150
SOURCES/0009-Make-expire-only-function-fail-if-no-kernel-support-.patch Normal file
View File

@ -0,0 +1,150 @@
From 51bc827df873d9ff4069b83796cd32fcb6bd659e Mon Sep 17 00:00:00 2001
From: HereThereBeDragons <HereThereBeDragons@users.noreply.github.com>
Date: Fri, 30 Jun 2023 14:57:06 +0200
Subject: [PATCH] Make expire only function fail if no kernel support (#789)
---
include/fuse_common.h | 2 +-
include/fuse_lowlevel.h | 28 ++++++++++++++--------------
lib/fuse_lowlevel.c | 41 ++++++++++++++++++++++++++++++++++++-----
3 files changed, 51 insertions(+), 20 deletions(-)
--- a/include/fuse_common.h
+++ b/include/fuse_common.h
@@ -338,7 +338,7 @@ struct fuse_loop_config {
#define FUSE_CAP_CACHE_SYMLINKS (1 << 23)
/**
- * Indicates support that dentries can be expired or invalidated.
+ * Indicates support that dentries can be expired.
*
* Expiring dentries, instead of invalidating them, makes a difference for
* overmounted dentries, where plain invalidation would detach all submounts
--- a/include/fuse_lowlevel.h
+++ b/include/fuse_lowlevel.h
@@ -131,11 +131,12 @@ struct fuse_forget_data {
};
/**
- * Flags for fuse_lowlevel_notify_expire_entry()
+ * Flags for fuse_lowlevel_notify_entry()
* 0 = invalidate entry
* FUSE_LL_EXPIRE_ONLY = expire entry
*/
-enum fuse_expire_flags {
+enum fuse_notify_entry_flags {
+ FUSE_LL_INVALIDATE = 0,
FUSE_LL_EXPIRE_ONLY = (1 << 0),
};
@@ -1560,8 +1561,7 @@ int fuse_lowlevel_notify_inval_inode(str
off_t off, off_t len);
/**
- * Notify to invalidate parent attributes and the dentry matching
- * parent/name
+ * Notify to invalidate parent attributes and the dentry matching parent/name
*
* To avoid a deadlock this function must not be called while
* executing a related filesytem operation or while holding a lock
@@ -1588,14 +1588,13 @@ int fuse_lowlevel_notify_inval_entry(str
const char *name, size_t namelen);
/**
- * Notify to expire or invalidate parent attributes and the dentry
- * matching parent/name
+ * Notify to expire parent attributes and the dentry matching parent/name
*
- * Underlying function for fuse_lowlevel_notify_inval_entry().
+ * Same restrictions apply as for fuse_lowlevel_notify_inval_entry()
*
- * In addition to invalidating an entry, it also allows to expire an entry.
- * In that case, the entry is not forcefully removed from kernel cache
- * but instead the next access to it forces a lookup from the filesystem.
+ * Compared to invalidating an entry, expiring the entry results not in a
+ * forceful removal of that entry from kernel cache but instead the next access
+ * to it forces a lookup from the filesystem.
*
* This makes a difference for overmounted dentries, where plain invalidation
* would detach all submounts before dropping the dentry from the cache.
@@ -1606,17 +1605,18 @@ int fuse_lowlevel_notify_inval_entry(str
* so invalidation will only be triggered for the non-overmounted case.
* The dentry could also be mounted in a different mount instance, in which case
* any submounts will still be detached.
+ *
+ * Added in FUSE protocol version 7.38. If the kernel does not support
+ * this (or a newer) version, the function will return -ENOSYS and do nothing.
*
* @param se the session object
* @param parent inode number
* @param name file name
* @param namelen strlen() of file name
- * @param flags flags to control if the entry should be expired or invalidated
- * @return zero for success, -errno for failure
+ * @return zero for success, -errno for failure, -enosys if no kernel support
*/
int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
- const char *name, size_t namelen,
- enum fuse_expire_flags flags);
+ const char *name, size_t namelen);
/**
* This function behaves like fuse_lowlevel_notify_inval_entry() with
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -2172,9 +2172,28 @@ int fuse_lowlevel_notify_inval_inode(str
return send_notify_iov(se, FUSE_NOTIFY_INVAL_INODE, iov, 2);
}
-int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
- const char *name, size_t namelen,
- enum fuse_expire_flags flags)
+/**
+ * Notify parent attributes and the dentry matching parent/name
+ *
+ * Underlying base function for fuse_lowlevel_notify_inval_entry() and
+ * fuse_lowlevel_notify_expire_entry().
+ *
+ * @warning
+ * Only checks if fuse_lowlevel_notify_inval_entry() is supported by
+ * the kernel. All other flags will fall back to
+ * fuse_lowlevel_notify_inval_entry() if not supported!
+ * DO THE PROPER CHECKS IN THE DERIVED FUNCTION!
+ *
+ * @param se the session object
+ * @param parent inode number
+ * @param name file name
+ * @param namelen strlen() of file name
+ * @param flags flags to control if the entry should be expired or invalidated
+ * @return zero for success, -errno for failure
+*/
+static int fuse_lowlevel_notify_entry(struct fuse_session *se, fuse_ino_t parent,
+ const char *name, size_t namelen,
+ enum fuse_notify_entry_flags flags)
{
struct fuse_notify_inval_entry_out outarg;
struct iovec iov[3];
@@ -2200,9 +2219,21 @@ int fuse_lowlevel_notify_expire_entry(st
}
int fuse_lowlevel_notify_inval_entry(struct fuse_session *se, fuse_ino_t parent,
- const char *name, size_t namelen)
+ const char *name, size_t namelen)
+{
+ return fuse_lowlevel_notify_entry(se, parent, name, namelen, FUSE_LL_INVALIDATE);
+}
+
+int fuse_lowlevel_notify_expire_entry(struct fuse_session *se, fuse_ino_t parent,
+ const char *name, size_t namelen)
{
- return fuse_lowlevel_notify_expire_entry(se, parent, name, namelen, 0);
+ if (!se)
+ return -EINVAL;
+
+ if (!(se->conn.capable & FUSE_CAP_EXPIRE_ONLY))
+ return -ENOSYS;
+
+ return fuse_lowlevel_notify_entry(se, parent, name, namelen, FUSE_LL_EXPIRE_ONLY);
}

42
SOURCES/fuse-3.17.0-Don-t-set-FUSE_CAP_PARALLEL_DIROPS-by-default.patch Normal file
View File

@ -0,0 +1,42 @@
From 2c736f516f28dfb5c58aff345c668a5ea6386295 Mon Sep 17 00:00:00 2001
From: Miklos Szeredi <mszeredi@redhat.com>
Date: Wed, 10 Jan 2024 10:15:43 +0100
Subject: [PATCH] Don't set FUSE_CAP_PARALLEL_DIROPS by default
Allowing parallel dir operations could result in a crash in a filesystem
implementation that is not prepared for this.
To be safe keep this flag off by default (this is not a regression, since
there was no public release where this flag wasn't ignored).
If the filesystem wants better performance, then it should set this flag
explicitly.
Fixes: c9905341ea34 ("Pass FUSE_PARALLEL_DIROPS to kernel (#861)")
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>
---
include/fuse_common.h | 2 --
lib/fuse_lowlevel.c | 1 -
2 files changed, 3 deletions(-)
--- a/include/fuse_common.h
+++ b/include/fuse_common.h
@@ -313,8 +313,6 @@ struct fuse_loop_config {
* is unset, the FUSE kernel module will ensure that lookup() and
* readdir() requests are never issued concurrently for the same
* directory.
- *
- * This feature is enabled by default when supported by the kernel.
*/
#define FUSE_CAP_PARALLEL_DIROPS (1 << 18)
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -2009,7 +2009,6 @@ void do_init(fuse_req_t req, fuse_ino_t
if ((cond) && (se->conn.capable & (cap))) \
se->conn.want |= (cap)
LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_READ);
- LL_SET_DEFAULT(1, FUSE_CAP_PARALLEL_DIROPS);
LL_SET_DEFAULT(1, FUSE_CAP_AUTO_INVAL_DATA);
LL_SET_DEFAULT(1, FUSE_CAP_HANDLE_KILLPRIV);
LL_SET_DEFAULT(1, FUSE_CAP_ASYNC_DIO);

23
SOURCES/fuse-3.17.0-Pass-FUSE_PARALLEL_DIROPS-to-kernel-861.patch Normal file
View File

@ -0,0 +1,23 @@
From c9905341ea34ff9acbc11b3c53ba8bcea35eeed8 Mon Sep 17 00:00:00 2001
From: fdinoff <fdinoff@google.com>
Date: Thu, 16 Nov 2023 06:23:20 -0500
Subject: [PATCH] Pass FUSE_PARALLEL_DIROPS to kernel (#861)
This tells the kernel that parallel lookup/readdir operations are
supported. This is enabled by default but was not passed to the kernel
so you always get the synchronized version.
---
lib/fuse_lowlevel.c | 2 ++
1 file changed, 2 insertions(+)
--- a/lib/fuse_lowlevel.c
+++ b/lib/fuse_lowlevel.c
@@ -2093,6 +2093,8 @@ void do_init(fuse_req_t req, fuse_ino_t
outargflags |= FUSE_ASYNC_DIO;
if (se->conn.want & FUSE_CAP_WRITEBACK_CACHE)
outargflags |= FUSE_WRITEBACK_CACHE;
+ if (se->conn.want & FUSE_CAP_PARALLEL_DIROPS)
+ outargflags |= FUSE_PARALLEL_DIROPS;
if (se->conn.want & FUSE_CAP_POSIX_ACL)
outargflags |= FUSE_POSIX_ACL;
if (se->conn.want & FUSE_CAP_CACHE_SYMLINKS)

43
SPECS/fuse.spec
View File

@ -4,7 +4,7 @@
Name: fuse
Version: %{fuse2ver}
Release: 15%{?dist}
Release: 19%{?dist}
Summary: File System in Userspace (FUSE) v2 utilities
License: GPL+
URL: http://fuse.sf.net
@ -22,6 +22,17 @@ Patch4: fuse-3.2.1-no-dev.patch
Patch5: fusermount-don-t-feed-escaped-commas-into-mount-opti.patch
Patch6: buffer_size.patch
Patch7: fuse-3.10.4-fix-test-failure.patch
Patch8: 0001-Synchronize-fuse_kernel.h.patch
Patch9: 0002-fuse_lowlevel-Add-max_pages-support-384.patch
Patch10: 0003-Allow-caching-symlinks-in-kernel-page-cache.-551.patch
Patch11: 0004-Add-support-for-in-kernel-readdir-caching.patch
Patch12: 0005-BZ_217095_Modify-structures-in-libfuse-to-handle-flags-beyond-rhel-8.patch
Patch13: 0006-BZ_2171095.patch
Patch14: 0007-BZ_2171095-cap.patch
Patch15: 0008-BZ_217095-libfuse-add-feature-flag-for-expire-only.patch
Patch16: fuse-3.17.0-Pass-FUSE_PARALLEL_DIROPS-to-kernel-861.patch
Patch17: fuse-3.17.0-Don-t-set-FUSE_CAP_PARALLEL_DIROPS-by-default.patch
Patch18: 0009-Make-expire-only-function-fail-if-no-kernel-support-.patch
Requires: which
Conflicts: filesystem < 3
@ -112,6 +123,18 @@ pushd lib%{name}-%{name}-%{fuse3ver}
%patch1 -p1 -b .add_parentheses
%patch4 -p1 -b .nodev
%patch7 -p1 -b .test_fail
%patch8 -p1
%patch9 -p1
%patch10 -p1
%patch11 -p1
%patch12 -p1
%patch13 -p1
%patch14 -p1
%patch15 -p1
%patch16 -p1
%patch17 -p1
%patch18 -p1
popd
# fuse 2
@ -242,6 +265,24 @@ rm -f %{buildroot}/usr/lib/udev/rules.d/99-fuse3.rules
%{_includedir}/fuse3/
%changelog
* Tue Feb 06 2024 Pavel Reichl <preichl@redhat.com> - 2.9.7-19
- Synchronize expire-only API with upstream.
- Related: RHEL-23415
* Fri Feb 02 2024 Pavel Reichl <preichl@redhat.com> - 2.9.7-18
- Advertise support of FUSE_PARALLEL_DIROPS to kernel
- Fixes RHEL-19149
* Thu Mar 23 2023 Pavel Reichl <preichl@redhat.com> - 2.9.7-17
- Add feature_notify_inode_expire_only
- Fixes rhbz#2171095
* Mon May 30 2022 Pavel Reichl <preichl@redhat.com> - 2.9.7-16
- Back-port max_pages support,
- caching symlinks in kernel page cache,
- and in-kernel readdir caching
- Fixed rhbz#2080000
* Wed Feb 23 2022 Pavel Reichl <preichl@redhat.com> - 2.9.7-15
- Fix missing dependency of fuse3 on fuse3-libs
- Make symlink for mount.fuse to mount.fuse3